Menu

Fremtrædende Java 8-funktioner med kodeeksempler

prominent java 8 features with code examples

Prøv Vores Instrument Til At Fjerne Problemer

En omfattende liste og forklaring på alle de fremtrædende funktioner introduceret i Java 8-udgivelse med eksempler:

Java 8-frigivelse fra Oracle var en revolutionerende frigivelse af verdens # 1 udviklingsplatform. Det omfattede en kæmpe opgradering til Java-programmeringsmodellen som helhed sammen med udviklingen af ​​JVM, Java-sprog og biblioteker på en koordineret måde.

Denne udgivelse indeholdt flere funktioner til brugervenlighed, produktivitet, forbedret polyglot-programmering, sikkerhed og samlet forbedret ydeevne.

Java 8-funktioner

Hvad du vil lære:

Funktioner tilføjet til Java 8-udgivelse

Blandt de store ændringer er følgende de bemærkelsesværdige funktioner, der blev føjet til denne udgivelse.

  • Funktionelle grænseflader og Lambda-udtryk
  • forEach () metode i Iterable interface
  • Valgfri klasse,
  • standard- og statiske metoder i grænseflader
  • Metodehenvisninger
  • Java Stream API til massedataoperationer på samlinger
  • Java Date Time API
  • Samling API forbedringer
  • Samtidige API-forbedringer
  • Java IO forbedringer
  • Næsehorn JavaScript-motor
  • Base64-kodeindkodning
  • Diverse forbedringer af Core API

I denne vejledning vil vi kort diskutere hver af disse funktioner og forsøge at forklare hver af dem ved hjælp af enkle og lette eksempler.

Funktionelle grænseflader og Lambda-udtryk

Java 8 introducerer en kommentar kendt som @FunctionalInterface, der normalt er til fejl på compiler-niveau. Det bruges typisk, når den grænseflade, du bruger, overtræder kontrakterne om funktionel grænseflade.

Alternativt kan du kalde en funktionel grænseflade som SAM-interface eller Single Abstract Method-grænseflade. En funktionel grænseflade tillader nøjagtigt en “abstrakt metode” som medlem.

Nedenfor er et eksempel på funktionel grænseflade:

@FunctionalInterface public interface MyFirstFunctionalInterface { public void firstWork(); }

Du kan udelade kommentaren, @FunctionalInterface, og din funktionelle grænseflade vil stadig være gyldig. Vi bruger kun denne kommentar til at informere kompilatoren om, at grænsefladen vil have en enkelt abstrakt metode.

Bemærk: Per definition er standardmetoder ikke-abstrakte, og du kan tilføje så mange standardmetoder i den funktionelle grænseflade, som du vil.

For det andet, hvis en grænseflade har en abstrakt metode, der tilsidesætter en af ​​de offentlige metoder i “java.lang.object”, betragtes den ikke som grænseflades abstrakte metode.

Nedenfor er et gyldigt eksempel på et funktionelt interface.

@FunctionalInterface public interface FunctionalInterface_one { public void firstInt_method(); @Override public String toString(); //Overridden from Object class @Override public boolean equals(Object obj); //Overridden from Object class }

Et Lambda-udtryk (eller funktion) kan defineres som en anonym funktion (en funktion uden navn og identifikator). Lambda-udtryk defineres nøjagtigt på det sted, hvor de er nødvendige, normalt som en parameter til en anden funktion.

Fra et andet perspektiv udtrykker Lambda Expressions forekomster af Funktionelle grænseflader (beskrevet ovenfor). Lambda Expressions implementerer den eneste abstrakte funktion til stede i den funktionelle grænseflade og implementerer således funktionelle grænseflader.

Den grundlæggende syntaks for et Lambda-udtryk er:

lambda udtryk syntaks

Et grundlæggende eksempel på Lambda-udtrykket er:

lambda-ekspressionseksempel

Ovenstående udtryk tager to parametre x og y og returnerer sin sum x + y. Baseret på datatypen x og y kan metoden bruges flere gange forskellige steder. Således vil parametrene x og y matche int eller Heltal og streng, og baseret på kontekst vil det tilføje to heltal (når parametrene er int) eller konkat de to strenge (når parametre er en streng).

Lad os implementere et program, der demonstrerer Lambda Expressions.

interface MyInterface { void abstract_func(int x,int y); default void default_Fun() { System.out.println('This is default method'); } } class Main { public static void main(String args()) { //lambda expression MyInterface fobj = (int x, int y)->System.out.println(x+y); System.out.print('The result = '); fobj.abstract_func(5,5); fobj.default_Fun(); } }

Produktion:

lambda-udtryk - output

Ovenstående program viser brugen af ​​Lambda Expression til at føje til parametre og viser deres sum. Derefter bruger vi dette til at implementere den abstrakte metode “abstract_fun”, som vi erklærede i interface-definitionen. Resultatet af at kalde funktionen 'abstrakt_funktion' er summen af ​​de to heltal, der er sendt som parametre, mens funktionen kaldes.

Vi lærer mere om Lambda Expressions senere i vejledningen.

forEach () -metode i Iterabel grænseflade

Java 8 har introduceret en 'forEach' -metode i grænsefladen java.lang.Iterable, der kan gentage elementerne i samlingen. “ForEach” er en standardmetode, der er defineret i Iterable interface. Det bruges af samlingsklasser, der udvider den interterbare grænseflade til iterere elementer.

Metoden “forEach” tager den funktionelle grænseflade som en enkelt parameter, dvs. du kan videregive Lambda-udtryk som et argument.

Eksempel på metoden forEach ().

importjava.util.ArrayList; importjava.util.List; public class Main { public static void main(String() args) { List subList = new ArrayList(); subList.add('Maths'); subList.add('English'); subList.add('French'); subList.add('Sanskrit'); subList.add('Abacus'); System.out.println('------------Subject List--------------'); subList.forEach(sub -> System.out.println(sub)); } }

Produktion:

forHver metodeoutput

Så vi har en samling emner, dvs. subliste. Vi viser indholdet af underlisten ved hjælp af forEach-metoden, der tager Lambda-ekspression til at udskrive hvert element.

Valgfri klasse

Java 8 introducerede en valgfri klasse i pakken “java.util”. “Valgfri” er en offentlig endelig klasse og bruges til at håndtere NullPointerException i Java-applikationen. Ved hjælp af Valgfrit kan du angive alternativ kode eller værdier, der skal køres. Ved at bruge Valgfri behøver du ikke bruge for mange nulchecks for at undgå nullPointerException.

Du kan bruge klassen Valgfri for at undgå unormal afslutning af programmet og forhindre, at programmet går ned. Klassen Valgfri indeholder metoder, der bruges til at kontrollere tilstedeværelsen af ​​værdi for en bestemt variabel.

Det følgende program demonstrerer brugen af ​​den valgfri klasse.

import java.util.Optional; public class Main{ public static void main(String() args) { String() str = new String(10); OptionalcheckNull = Optional.ofNullable(str(5)); if (checkNull.isPresent()) { String word = str(5).toLowerCase(); System.out.print(str); } else System.out.println('string is null'); } }

Produktion:

Valgfri klasse output

I dette program bruger vi egenskaben “ofNullable” i klassen Optional til at kontrollere, om strengen er nul. Hvis det er tilfældet, udskrives den relevante meddelelse til brugeren.

Standard og statiske metoder i grænseflader

I Java 8 kan du tilføje metoder i grænsefladen, der ikke er abstrakte, dvs. du kan have grænseflader med metodeimplementering. Du kan bruge nøgleordet Standard og Statisk til at oprette grænseflader med metodeimplementering. Standardmetoder muliggør primært Lambda Expression-funktionalitet.

Ved hjælp af standardmetoder kan du tilføje ny funktionalitet til dine grænseflader i dine biblioteker. Dette vil sikre, at koden skrevet til de ældre versioner er kompatibel med disse grænseflader (binær kompatibilitet).

Lad os forstå standardmetoden med et eksempel:

import java.util.Optional; interface interface_default { default void default_method(){ System.out.println('I am default method of interface'); } } class derived_class implements interface_default{ } class Main{ public static void main(String() args){ derived_class obj1 = new derived_class(); obj1.default_method(); } }

Produktion:

Standardmetode - output

Vi har en grænseflade med navnet “interface_default” med metoden default_method () med en standardimplementering. Dernæst definerer vi en klasse 'derivated_class', der implementerer grænsefladen 'interface_default'.

Bemærk, at vi ikke har implementeret nogen interface-metoder i denne klasse. Derefter opretter vi i hovedfunktionen et objekt af klassen 'derivated_class' og kalder direkte 'default_method' for grænsefladen uden at skulle definere det i klassen.

Dette er brugen af ​​standard- og statiske metoder i grænsefladen. Men hvis en klasse ønsker at tilpasse standardmetoden, kan du give sin egen implementering ved at tilsidesætte metoden.

Metode Referencer

Metodehenvisningsfunktionen introduceret i Java 8 er en kort beskrivelse af Lambda Expressions for at kalde en metode til funktionel grænseflade. Så hver gang du bruger et Lambda-udtryk til at henvise en metode, kan du erstatte dit Lambda-udtryk med en metodehenvisning.

Eksempel på metodehenvisning.

import java.util.Optional; interface interface_default { void display(); } class derived_class{ public void classMethod(){ System.out.println('Derived class Method'); } } class Main{ public static void main(String() args){ derived_class obj1 = new derived_class(); interface_default ref = obj1::classMethod; ref.display(); } }

Produktion:

Metode Reference output

I dette program har vi et interface 'interface_default' med en abstrakt metode 'display ()'. Dernæst er der en klasse 'derivated_class', der har en offentlig metode 'classMethod', der udskriver en besked.

I hovedfunktionen har vi et objekt til klassen, og derefter har vi en henvisning til grænsefladen, der refererer til en klassemetode 'classMethod' gennem obj1 (klasseobjekt). Nu når den abstrakte metodevisning kaldes ved interface-reference, vises indholdet af classMethod.

Java Stream API til massedataoperationer på samlinger

Stream API er endnu en større ændring introduceret i Java 8. Stream API bruges til behandling af indsamling af objekter, og den understøtter en anden type iteration. En stream er en sekvens af objekter (elementer), der giver dig mulighed for at pipeline forskellige metoder for at producere de ønskede resultater.

En Stream er ikke en datastruktur, og den modtager sit input fra samlinger, arrays eller andre kanaler. Vi kan pipeline forskellige mellemliggende operationer ved hjælp af Streams, og terminaloperationerne returnerer resultatet. Vi vil diskutere stream API mere detaljeret i en separat Java-tutorial.

Java Date Time API

Java 8 introducerer en ny dato-tid API under pakken java.time.

De vigtigste klasser blandt dem er:

  • Lokal: Forenklet dato-tid API uden kompleksitet i tidszonehåndtering.
  • Zone: Specialiseret API til dato og tid til at håndtere forskellige tidszoner.

Datoer

Dataklasse er blevet forældet i Java 8.

Følgende er de nye klasser introduceret:

  • Klassen LocalDate definerer en dato. Det har ingen repræsentation for tid eller tidszone.
  • LocalTime klasse definerer en tid. Det har ingen repræsentation for dato eller tidszone.
  • Klassen LocalDateTime definerer en dato-tid. Det har ingen repræsentation af en tidszone.

For at inkludere tidszoneoplysninger med datofunktionalitet kan du bruge Lambda, der giver 3 klasser, dvs. OffsetDate, OffsetTime og OffsetDateTime. Her er tidszoneforskydning repræsenteret ved hjælp af en anden klasse - “ZoneId”. Vi vil dække dette emne i detaljer i de senere dele af denne Java-serie.

Næsehorn JavaScript-motor

Java 8 introducerede en meget forbedret motor til JavaScript, dvs. Nashorn, der erstatter den eksisterende Rhino. Nashorn kompilerer koden direkte i hukommelsen og sender derefter bytecoden til JVM og forbedrer dermed ydeevnen med 10 gange.

Nashorn introducerer et nyt kommandolinjeværktøj - jjs, der udfører JavaScript-kode på konsollen.

Lad os oprette en JavaScript-fil 'sample.js', der indeholder følgende kode.

print (‘Hello, World!!’);

Giv følgende kommando i konsollen:

C: Java jjs sample.js

hvordan man løser standard gateway windows 10

Produktion: Hej Verden!!

Vi kan også køre JavaScript-programmer i interaktiv tilstand og også levere argumenter til programmerne.

Base64-kodeindkodning

I Java 8 er der indbygget kode og afkode til Base64-kodning. Klassen til Base64-kodning er java.util.Base64.

Denne klasse indeholder tre Base64-koder og dekodere:

  • Grundlæggende: I dette kortlægges output til et sæt tegn mellem A-Za-z0-9 + /. Der tilføjes ingen linjefødning til output af koderen, og dekoderen afviser noget andet tegn end ovenstående.
  • URL: Her er output URL'en og filnavnet sikkert kortlægges til sæt af tegn mellem A-Za-z0-9 + /.
  • MIME: I denne type indkoder kortlægges output til et MIME-venligt format.

Samling API Forbedringer

Java 8 har tilføjet følgende nye metoder til Collection API:

  • forEachRemaining (Forbrugerhandling): Dette er en standardmetode, og det er til Iterator. Den udfører 'handlingen' for hvert af de resterende elementer, indtil alle elementerne er behandlet, eller 'handling' kaster en undtagelse.
  • Standardmetoden til samling removeIf (Predicate filter): Dette fjerner alle de elementer i samlingen, der opfylder det givne “filter”.
  • Spliterator (): Dette er en indsamlingsmetode og returnerer spliterator-instans, som du kan bruge til at krydse elementerne på enten sekventiel eller parallel måde.
  • Kortindsamling har substitutionsmetoder (All) (), beregning () og fletning ().
  • HashMap-klasse med nøglekollisioner er blevet forbedret for at forbedre ydeevnen.

Ændringer / forbedringer af API-samtidighed

Følgende er de vigtige forbedringer i Concurrent API:

  • ConcurrentHashMap forbedres med følgende metoder:
    1. beregne (),
    2. for hver (),
    3. forEachEntry (),
    4. forEachKey (),
    5. forEachValue (),
    6. gå (),
    7. reducere () og
    8. Søg ()
  • Metoden 'newWorkStealingPool ()' til eksekutører skaber en arbejdsstjæling af trådpuljen. Det bruger de tilgængelige processorer som målparallelismeniveau.
  • Metoden 'completeableFuture' er den, som vi eksplicit kan udføre (ved at indstille dens værdi og status).

Forbedringer af Java IO

IO-forbedringer udført i Java 8 inkluderer:

  • Files.list (sti dir): Dette returnerer en jlazily befolket stream, hvis hvert element er posten i biblioteket.
  • Files.lines (sti): Læser alle linjer fra en stream.
  • Files.find (): Søg efter filer i filtræet, der er rodfæstet ved en given startfil, og returnerer en stream, der er befolket med en sti.
  • BufferedReader.lines (): Returnerer en strøm med hvert element som linjerne læses fra BufferedReader.

Diverse forbedringer af Core API

Vi har følgende diverse API-forbedringer:

  • Statisk metode med Initial (leverandørleverandør) af ThreadLocal til let at oprette instans.
  • Interfacet “Comparator” udvides med standard- og statiske metoder til naturlig ordning i omvendt rækkefølge osv.
  • Heltals-, lang- og dobbeltindpakningsklasser har metoderne min (), max () og sum ().
  • Boolsk klasse forbedres med logicalAnd (), logicalOr () og logicalXor () metoder.
  • Flere værktøjsmetoder introduceres i matematikklassen.
  • JDBC-ODBC Bridge er fjernet.
  • PermGen-hukommelsesplads er fjernet.

Konklusion

I denne vejledning har vi diskuteret de vigtigste funktioner, der blev føjet til Java 8-udgivelsen. Da Java 8 er en stor udgivelse fra Java, er det vigtigt, at du kender alle de funktioner og forbedringer, der blev udført som en del af denne udgivelse.

Selvom den nyeste Java-version er 13, er det stadig en god ide at blive fortrolig med Java 8-funktionerne. Alle de funktioner, der er diskuteret i denne vejledning, er stadig til stede i den nyeste version af Java, og vi vil diskutere dem som individuelle emner senere i denne serie.

Vi håber, at denne vejledning hjalp dig med at lære om forskellige Java 8-funktioner !!

Anbefalet læsning

^