Java 8 sollicitatievragen (+ antwoorden)

Dit artikel maakt deel uit van een reeks: • Interviewvragen over Java Collections

• Vragen over het Java Type System-interview

• Vragen over Java Concurrency-sollicitatiegesprekken (+ antwoorden)

• Vragen over Java-klassenstructuur en initialisatie

• Java 8 sollicitatievragen (+ antwoorden) (huidig artikel) • Geheugenbeheer in Java sollicitatievragen (+ antwoorden)

• Java Generics sollicitatievragen (+ antwoorden)

• Vragen over Java Flow Control-interview (+ antwoorden)

• Interviewvragen over Java-uitzonderingen (+ antwoorden)

• Vragen over Java-annotaties tijdens sollicitatiegesprekken (+ antwoorden)

• Topvragen tijdens het Spring Framework-interview

1. Inleiding

In dit artikel gaan we enkele van de JDK8-gerelateerde vragen onderzoeken die tijdens een interview kunnen opduiken.

Java 8 is een platformrelease boordevol nieuwe taalfuncties en bibliotheekklassen. De meeste van deze nieuwe functies zijn gericht op het verkrijgen van schonere en compactere code, en sommige voegen nieuwe functionaliteit toe die nog nooit in Java is ondersteund.

2. Algemene kennis van Java 8

V1. Welke nieuwe functies zijn er toegevoegd in Java 8?

Java 8 wordt geleverd met verschillende nieuwe functies, maar de belangrijkste zijn de volgende:

Lambda-expressies - een nieuwe taalfunctie waarmee acties als objecten kunnen worden behandeld
Methodeverwijzingen - maak het mogelijk om Lambda-expressies te definiëren door rechtstreeks naar methoden te verwijzen met behulp van hun namen
Optioneel - speciale wrapper-klasse die wordt gebruikt voor het uitdrukken van optionaliteit
Functionele interface - een interface met maximaal één abstracte methode, implementatie kan worden geleverd met behulp van een Lambda Expression
Standaardmethoden - geef ons de mogelijkheid om naast abstracte methoden volledige implementaties in interfaces toe te voegen
Nashorn, JavaScript-engine - Java-gebaseerde engine voor het uitvoeren en evalueren van JavaScript-code
Stroom API - een speciale iteratorklasse die het mogelijk maakt om verzamelingen objecten op een functionele manier te verwerken
Datum API - een verbeterde, onveranderlijke, door JodaTime geïnspireerde Date API

Samen met deze nieuwe functies, worden veel functieverbeteringen onder de motorkap gedaan, zowel op compiler- als JVM-niveau.

3. Methodeverwijzingen

V1. Wat is een methodeverwijzing?

Een methodeverwijzing is een Java 8-construct dat kan worden gebruikt om naar een methode te verwijzen zonder deze aan te roepen. Het wordt gebruikt voor het behandelen van methoden als Lambda-expressies. Ze werken alleen als syntactische suiker om de breedsprakigheid van sommige lambda's te verminderen. Op deze manier de volgende code:

(o) -> o.toString ();

kan worden:

Object :: toString ();

Een methodeverwijzing kan worden geïdentificeerd door een dubbele dubbele punt tussen een klasse- of objectnaam en de naam van de methode. Het heeft verschillende variaties, zoals constructorreferentie:

String :: nieuw;

Statische methode referentie:

String :: valueOf;

Verwijzing naar gebonden instantie-methode:

str :: toString;

Referentie voor ongebonden instantiemethode:

String :: toString;

U kunt een gedetailleerde beschrijving van methodeverwijzingen met volledige voorbeelden lezen door deze link en deze te volgen.

Q2. Wat is de betekenis van String :: Valueof Expression?

Het is een statische methodeverwijzing naar de waarde van methode van de Draad klasse.

4. Optioneel

**V1. Wat is Optioneel? Hoe kan het worden gebruikt?**

Optioneel is een nieuwe klasse in Java 8 die een optionele waarde omvat, d.w.z. een waarde die er al dan niet is. Het is een omhulsel rond een object, en je kunt het zien als een container met nul of één element.

Optioneel heeft een speciale Optioneel.empty () waarde in plaats van verpakt nul. Het kan dus worden gebruikt in plaats van een nulwaarde om ervan af te komen NullPointerException vaak.

U kunt er een speciaal artikel over lezen Optioneel hier.

Het belangrijkste doel van Optioneel, zoals ontworpen door de makers, moest een terugkerend type methoden zijn dat voorheen zou terugkeren nul. Dergelijke methoden vereisen dat u standaardcode schrijft om de geretourneerde waarde te controleren en soms vergeet u een defensieve controle uit te voeren. In Java 8, een Optioneel Het retourtype vereist expliciet dat u null- of niet-null-verpakte waarden anders behandelt.

Bijvoorbeeld de Stream.min () methode berekent de minimumwaarde in een stroom waarden. Maar wat als de stroom leeg is? Als het niet voor was Optioneel, zou de methode terugkeren nul of een uitzondering maken.

Maar het retourneert een Optioneel waarde die kan zijn Optioneel.empty () (het tweede geval). Dit stelt ons in staat om een dergelijk geval gemakkelijk af te handelen:

int min1 = Arrays.stream (nieuwe int [] {1, 2, 3, 4, 5}) .min () .orElse (0); assertEquals (1, min1); int min2 = Arrays.stream (nieuwe int [] {}) .min () .orElse (0); assertEquals (0, min2);

Het is vermeldenswaard dat Optioneel is niet een klasse voor algemene doeleinden zoals Keuze in Scala. Het wordt niet aanbevolen om te worden gebruikt als een veldwaarde in entiteitsklassen, wat duidelijk wordt aangegeven doordat de Serialiseerbaar koppel.

5. Functionele interfaces

V1. Beschrijf enkele functionele interfaces in de standaardbibliotheek.

Er zijn veel functionele interfaces in het java.util.function pakket, de meest voorkomende omvatten, maar zijn niet beperkt tot:

Functie - het duurt één argument en retourneert een resultaat
Klant - er is één argument nodig en geeft geen resultaat (vertegenwoordigt een bijwerking)
Leverancier - het accepteert geen argument en retourneert een resultaat
Predikaat - het duurt één argument en retourneert een booleaanse waarde
BiFunction - het duurt twee argumenten en geeft een resultaat terug
BinaryOperator - het is vergelijkbaar met een BiFunction, twee argumenten nemen en een resultaat retourneren. De twee argumenten en het resultaat zijn allemaal van hetzelfde type
UnaryOperator - het is vergelijkbaar met een Functie, een enkel argument nemen en een resultaat van hetzelfde type retourneren

Zie het artikel "Functionele interfaces in Java 8" voor meer informatie over functionele interfaces.

Q2. Wat is een functionele interface? Wat zijn de regels voor het definiëren van een functionele interface?

Een functionele interface is een interface met niet meer, niet minder maar één enkele abstracte methode (standaard methoden tellen niet mee).

Waar een instantie van een dergelijke interface vereist is, kan in plaats daarvan een Lambda-expressie worden gebruikt. Formeler gesteld: Functionele interfaces bieden doeltypes voor lambda-expressies en methodeverwijzingen.

De argumenten en het retourneringstype van een dergelijke uitdrukking komen rechtstreeks overeen met die van de enkele abstracte methode.

Bijvoorbeeld de Runnable interface is een functionele interface, dus in plaats van:

Thread thread = nieuwe Thread (new Runnable () {public void run () {System.out.println ("Hallo wereld!");}});

je zou eenvoudig kunnen doen:

Thread thread = nieuwe Thread (() -> System.out.println ("Hallo wereld!"));

Functionele interfaces worden meestal geannoteerd met de @FunctioneleInterface annotatie - die informatief is en geen invloed heeft op de semantiek.

6. Standaardmethode

V1. Wat is een standaardmethode en wanneer gebruiken we deze?

Een standaardmethode is een methode met een implementatie - die te vinden is in een interface.

We kunnen een standaardmethode gebruiken om een nieuwe functionaliteit aan een interface toe te voegen met behoud van achterwaartse compatibiliteit met klassen die de interface al implementeren:

openbare interface Vehicle {public void move (); default void hoot () {System.out.println ("peep!"); }}

Wanneer een nieuwe abstracte methode aan een interface wordt toegevoegd, worden gewoonlijk alle implementatieklassen afgebroken totdat ze de nieuwe abstracte methode implementeren. In Java 8 is dit probleem opgelost door het gebruik van de standaardmethode.

Bijvoorbeeld, Verzameling interface heeft geen voor elk methode verklaring. Het toevoegen van een dergelijke methode zou dus simpelweg de hele API voor collecties breken.

Java 8 introduceert een standaardmethode zodat Verzameling interface kan een standaardimplementatie hebben van voor elk methode zonder dat de klassen die deze interface implementeren hetzelfde moeten implementeren.

Q2. Zal de volgende code worden gecompileerd?

@FunctionalInterface openbare interface Functie2 {openbare V van toepassing (T t, U u); standaard ongeldig aantal () {// incrementteller}}

Ja. De code zal compileren omdat het de functionele interface-specificatie volgt van het definiëren van slechts een enkele abstracte methode. De tweede methode, tellen, is een standaardmethode die het aantal abstracte methoden niet verhoogt.

7. Lambda-expressies

V1. Wat is een Lambda-uitdrukking en waarvoor wordt deze gebruikt?

In zeer eenvoudige bewoordingen is een lambda-uitdrukking een functie waarnaar kan worden verwezen en die als een object kan worden doorgegeven.

Lambda-expressies introduceren functionele stijlverwerking in Java en vergemakkelijken het schrijven van compacte en gemakkelijk te lezen code.

Daarom zijn lambda-expressies een natuurlijke vervanging voor anonieme klassen als methode-argumenten. Een van hun belangrijkste toepassingen is om inline implementaties van functionele interfaces te definiëren.

Q2. Verklaar de syntaxis en kenmerken van een Lambda-expressie

Een lambda-uitdrukking bestaat uit twee delen: het parametergedeelte en het uitdrukkingsgedeelte gescheiden door een voorwaartse pijl, zoals hieronder:

params -> uitdrukkingen

Elke lambda-uitdrukking heeft de volgende kenmerken:

Facultatieve typeverklaring - bij het declareren van de parameters aan de linkerkant van de lambda, hoeven we hun typen niet te declareren, aangezien de compiler ze kan afleiden uit hun waarden. Zo int param ->… en param ->… zijn allemaal geldig
Optionele haakjes - wanneer slechts één parameter wordt gedeclareerd, hoeven we deze niet tussen haakjes te plaatsen. Dit betekent param ->… en (param) ->… zijn allemaal geldig. Maar als er meer dan één parameter is gedeclareerd, zijn haakjes vereist
Optionele accolades - als het expressiegedeelte slechts één instructie heeft, zijn accolades niet nodig. Dit betekent dat param -> verklaring en param -> {statement;} zijn allemaal geldig. Maar accolades zijn vereist als er meer dan één verklaring is
Optionele retourverklaring - wanneer de uitdrukking een waarde retourneert en deze tussen accolades staat, hebben we geen retourinstructie nodig. Dat betekent (a, b) -> {retourneer a + b;} en (a, b) -> {a + b;} zijn beide geldig

Volg deze link en deze om meer te lezen over Lambda-uitdrukkingen.

8. Nashorn Javascript

V1. Wat is Nashorn in Java8?

Nashorn is de nieuwe Javascript-verwerkingsengine voor het Java-platform dat bij Java 8 werd geleverd. Tot JDK 7 gebruikte het Java-platform Mozilla Rhino voor hetzelfde doel. als een Javascript-verwerkingsengine.

Nashorn biedt betere naleving van de ECMA genormaliseerde JavaScript-specificatie en betere runtime-prestaties dan zijn voorganger.

Q2. Wat is JJS?

In Java 8, jjs is het nieuwe uitvoerbare bestand of opdrachtregelprogramma dat wordt gebruikt om Javascript-code op de console uit te voeren.

9. Streams

V1. Wat is een stream? Hoe verschilt het van een verzameling?

In eenvoudige bewoordingen is een stream een iterator wiens rol het is om een reeks acties te accepteren die moeten worden toegepast op elk van de elementen die deze bevat.

De stroom vertegenwoordigt een reeks objecten uit een bron, zoals een verzameling, die geaggregeerde bewerkingen ondersteunt. Ze zijn ontworpen om de verwerking van collecties eenvoudig en beknopt te maken. In tegenstelling tot de collecties, is de iteratielogica geïmplementeerd in de stream, dus we kunnen methoden gebruiken zoals kaart en flatMap voor het uitvoeren van een declaratieve verwerking.

Een ander verschil is dat de Stroom API is vloeiend en maakt pipelining mogelijk:

int sum = Arrays.stream (nieuwe int [] {1, 2, 3}) .filter (i -> i> = 2) .map (i -> i * 3) .sum ();

En nog een ander belangrijk onderscheid met collecties is dat streams van nature lui worden geladen en verwerkt.

Q2. Wat is het verschil tussen tussenliggende en terminale operaties?

Streambewerkingen worden gecombineerd in pijplijnen om streams te verwerken. Alle bewerkingen zijn tussenliggend of terminaal.

Tussenliggende bewerkingen zijn die bewerkingen die terugkeren Stroom zelf waardoor verdere bewerkingen op een stream mogelijk zijn.

Deze bewerkingen zijn altijd lui, d.w.z. ze verwerken de stream niet op de oproeplocatie, een tussenliggende bewerking kan alleen gegevens verwerken als er een terminalbewerking is. Enkele van de tussenliggende bewerkingen zijn filter, kaart en flatMap.

Terminaloperaties beëindigen de pijplijn en starten de streamverwerking. De stream wordt door alle tussenliggende bewerkingen geleid tijdens een oproep voor terminaloperaties. Terminaloperaties omvatten voor elk, verminderen, verzamelen en som.

Laten we, om dit punt naar huis te rijden, eens kijken naar een voorbeeld met bijwerkingen:

public static void main (String [] args) {System.out.println ("Stream zonder terminaloperatie"); Arrays.stream (nieuwe int [] {1, 2, 3}). Map (i -> {System.out.println ("doubling" + i); return i * 2;}); System.out.println ("Stream met terminalbediening"); Arrays.stream (new int [] {1, 2, 3}). Map (i -> {System.out.println ("doubling" + i); return i * 2;}). Sum (); }

De output is als volgt:

Stream zonder terminalwerking Stream met terminalwerking verdubbeling 1 verdubbeling 2 verdubbeling 3

Zoals u kunt zien, worden de tussenliggende bewerkingen alleen geactiveerd als er een terminalbewerking bestaat.

**Q3. Wat is het verschil tussen Kaart en flatMap Stream operatie?**

Er is een verschil in ondertekening tussen kaart en flatMap. Over het algemeen geldt een kaart operatie wikkelt de geretourneerde waarde in het ordinale type while flatMap doet niet.

Bijvoorbeeld in Optioneel, een kaart operatie zou terugkeren Optioneel typ while flatMap zou terugbrengen Draad type.

Dus na het in kaart brengen, moet men het object uitpakken (lees "afvlakken") om de waarde op te halen, terwijl na een vlakke mapping dit niet nodig is omdat het object al is afgevlakt. Hetzelfde concept wordt toegepast op mapping en flat mapping in Stroom.

Beide kaart en flatMap zijn tussenliggende streambewerkingen die een functie ontvangen en deze functie toepassen op alle elementen van een stream.

Het verschil is dat voor de kaart, deze functie retourneert een waarde, maar voor flatMap, deze functie retourneert een stream. De flatMap operatie "vlakt" de streams in één.

Hier is een voorbeeld waarbij we een kaart met de namen van gebruikers en lijsten met telefoons nemen en deze afvlakken tot een lijst met telefoons van alle gebruikers die flatMap:

Kaart people = nieuwe HashMap (); people.put ("John", Arrays.asList ("555-1123", "555-3389")); people.put ("Mary", Arrays.asList ("555-2243", "555-5264")); people.put ("Steve", Arrays.asList ("555-6654", "555-3242")); Lijst telefoons = people.values (). Stream () .flatMap (Collectie :: stream) .collect (Collectors.toList ());

V4. Wat is Stream Pipelining in Java 8?

Stream pipelining is het concept van het aan elkaar koppelen van operaties. Dit wordt gedaan door de bewerkingen die op een stream kunnen plaatsvinden, op te splitsen in twee categorieën: tussenliggende bewerkingen en terminalbewerkingen.

Elke tussenliggende bewerking retourneert een instantie van Stream zelf wanneer deze wordt uitgevoerd, daarom kan een willekeurig aantal tussenliggende bewerkingen worden ingesteld om gegevens te verwerken die een verwerkingspijplijn vormen.

Er moet dan een terminaloperatie zijn die een eindwaarde retourneert en de pijplijn beëindigt.

10. Java 8-API voor datum en tijd

V1. Vertel ons over de nieuwe datum- en tijd-API in Java 8

Een al lang bestaand probleem voor Java-ontwikkelaars is de ontoereikende ondersteuning voor de datum- en tijdmanipulaties die gewone ontwikkelaars nodig hebben.

De bestaande klassen zoals java.util.Date en SimpleDateFormatter zijn niet thread-safe, wat kan leiden tot mogelijke gelijktijdigheidsproblemen voor gebruikers.

Slecht API-ontwerp is ook een realiteit in de oude Java Data API. Hier is slechts een snel voorbeeld - jaren later java.util.Date beginnen bij 1900, maanden beginnen bij 1, en dagen beginnen bij 0, wat niet erg intuïtief is.

Deze en verschillende andere problemen hebben geleid tot de populariteit van datum- en tijdbibliotheken van derden, zoals Joda-Time.

Om deze problemen aan te pakken en betere ondersteuning te bieden in JDK, is een nieuwe datum- en tijd-API, die vrij is van deze problemen, ontworpen voor Java SE 8 onder het pakket java.time.

11. Conclusie

In dit artikel hebben we enkele zeer belangrijke vragen onderzocht voor technische interviewvragen met een voorkeur voor Java 8. Dit is geenszins een uitputtende lijst, maar bevat alleen vragen waarvan we denken dat ze het meest waarschijnlijk zullen verschijnen in elke nieuwe functie van Java. 8.

Zelfs als je net begint, is onwetendheid over Java 8 geen goede manier om in een interview te gaan, vooral niet als Java sterk op je cv staat. Het is daarom belangrijk dat u de tijd neemt om de antwoorden op deze vragen te begrijpen en eventueel meer onderzoek gaat doen.

Veel succes met je sollicitatiegesprek.

De volgende » Geheugenbeheer in Java sollicitatievragen (+ antwoorden) « Eerdere Java Class Structure and Initialization Interview-vragen