Meny

Framstående Java 8-funktioner med kodexempel

  • Huvud
  • Övrig
  • Framstående Java 8-funktioner med kodexempel

prominent java 8 features with code examples

Prova Vårt Instrument För Att Eliminera Problem

En omfattande lista och förklaring av alla de framträdande funktionerna som presenteras i Java 8-version med exempel:

Java 8-release från Oracle var en revolutionerande release av världens främsta utvecklingsplattform. Den inkluderade en enorm uppgradering av Java-programmeringsmodellen som helhet tillsammans med utvecklingen av JVM, Java-språk och bibliotek på ett samordnat sätt.

Denna version innehöll flera funktioner för enkel användning, produktivitet, förbättrad polyglotprogrammering, säkerhet och övergripande förbättrad prestanda.

Java 8-funktioner

Vad du kommer att lära dig:

Funktioner tillagda till Java 8 Release

Bland de stora förändringarna är följande de anmärkningsvärda funktionerna som har lagts till i den här versionen.

  • Funktionella gränssnitt och Lambda Expressions
  • forEach () -metod i Iterabelt gränssnitt
  • Valfri klass,
  • standard- och statiska metoder i gränssnitt
  • Metodreferenser
  • Java Stream API för bulkdataoperationer på samlingar
  • Java Date Time API
  • Förbättringar av samlings-API
  • Förbättringar av samtidighet API
  • Java IO-förbättringar
  • JavaScript-motor för noshörning
  • Base64-kodavkodning
  • Diverse förbättringar av Core API

I denna handledning kommer vi att diskutera var och en av dessa funktioner kort och försöka förklara var och en av dem med hjälp av enkla och enkla exempel.

Funktionella gränssnitt och Lambdauttryck

Java 8 introducerar en kommentar som kallas @FunctionalInterface som vanligtvis är för fel på kompilatornivå. Det används vanligtvis när gränssnittet du använder bryter mot kontrakten för funktionellt gränssnitt.

Alternativt kan du anropa ett funktionellt gränssnitt som SAM-gränssnitt eller Single Abstract Method-gränssnitt. Ett funktionellt gränssnitt tillåter exakt en ”abstrakt metod” som medlem.

Nedan ges ett exempel på funktionellt gränssnitt:

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

Du kan utelämna anteckningen, @FunctionalInterface och ditt funktionella gränssnitt kommer fortfarande att vara giltigt. Vi använder denna kommentar endast för att informera kompilatorn om att gränssnittet kommer att ha en enda abstrakt metod.

Notera: Per definition är standardmetoder icke-abstrakta och du kan lägga till så många standardmetoder i det funktionella gränssnittet som du vill.

För det andra, om ett gränssnitt har en abstrakt metod som åsidosätter en av de offentliga metoderna för 'java.lang.object' så anses det inte som gränssnittets abstrakta metod.

Nedan följer ett giltigt exempel på funktionellt gränssnitt.

@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 }

Ett Lambdauttryck (eller funktion) kan definieras som en anonym funktion (en funktion utan namn och identifierare). Lambda-uttryck definieras exakt på den plats där de behövs, vanligtvis som en parameter för någon annan funktion.

Ur ett annat perspektiv uttrycker Lambda Expressions instanser av Funktionella gränssnitt (beskrivet ovan). Lambda Expressions implementerar den enda abstrakta funktionen som finns i det funktionella gränssnittet och implementerar därmed funktionella gränssnitt.

Den grundläggande syntaxen för ett Lambda-uttryck är:

lambda expression syntax

Ett grundläggande exempel på Lambda-uttrycket är:

exempel på lambdauttryck

Ovanstående uttryck tar två parametrar x och y och returnerar sin summa x + y. Baserat på datatypen x och y kan metoden användas flera gånger på olika platser. Således kommer parametrarna x och y att matcha int eller heltal och sträng, och baserat på kontext kommer det att lägga till två heltal (när parametrarna är int) eller konkata de två strängarna (när parametrarna är en sträng).

Låt oss implementera ett program som visar 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:

lambdauttryck - utdata

Ovanstående program visar användningen av Lambda Expression för att lägga till parametrar och visar deras summa. Sedan använder vi detta för att implementera den abstrakta metoden “abstract_fun” som vi förklarade i gränssnittsdefinitionen. Resultatet av att kalla funktionen ”abstrakt_funktion” är summan av de två heltal som skickats som parametrar medan funktionen anropas.

Vi lär oss mer om Lambda Expressions senare i handledningen.

forEach () Metod i Iterabelt gränssnitt

Java 8 har introducerat en 'forEach' -metod i gränssnittet java.lang.Iterable som kan iterera över elementen i samlingen. “ForEach” är en standardmetod som definieras i Iterable-gränssnittet. Den används av Collection-klasserna som utökar det Iterabla gränssnittet till iterera element.

Metoden “forEach” tar det funktionella gränssnittet som en enda parameter, dvs. du kan skicka Lambda-uttryck som ett argument.

informatica intervju frågor och svar för erfarna

Exempel 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:

för Varje metodutgång

Så vi har en samling ämnen, dvs sublista. Vi visar innehållet i underlistan med metoden forEach som tar Lambda Expression för att skriva ut varje element.

Valfri klass

Java 8 introducerade en valfri klass i paketet “java.util”. ”Valfritt” är en offentlig slutklass och används för att hantera NullPointerException i Java-applikationen. Med valfritt kan du ange alternativa koder eller värden som ska köras. Genom att använda Valfritt behöver du inte använda för många nollkontroller för att undvika nullPointerException.

Du kan använda klassen Optional för att undvika onormal avslutning av programmet och förhindra att programmet kraschar. Den valfria klassen ger metoder som används för att kontrollera förekomsten av värde för en viss variabel.

Följande program visar användningen av klassen Optional.

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:

Valfri klassutgång

I det här programmet använder vi egenskapen “ofNullable” för klassen Optional för att kontrollera om strängen är null. Om så är fallet skrivs lämpligt meddelande ut till användaren.

Standard- och statiska metoder i gränssnitt

I Java 8 kan du lägga till metoder i gränssnittet som inte är abstrakta, dvs. du kan ha gränssnitt med metodimplementering. Du kan använda standard- och statiska nyckelord för att skapa gränssnitt med metodimplementering. Standardmetoder möjliggör främst Lambda Expression-funktionalitet.

Med standardmetoder kan du lägga till ny funktionalitet i dina gränssnitt i dina bibliotek. Detta kommer att säkerställa att koden skriven för de äldre versionerna är kompatibel med dessa gränssnitt (binär kompatibilitet).

Låt oss förstå standardmetoden med ett exempel:

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:

Standardmetod - utdata

Vi har ett gränssnitt med namnet 'interface_default' med metoden default_method () med en standardimplementering. Därefter definierar vi en klass 'derivated_class' som implementerar gränssnittet 'interface_default'.

Observera att vi inte har implementerat några gränssnittsmetoder i den här klassen. Sedan i huvudfunktionen skapar vi ett objekt av klass 'derivated_class' och kallar direkt 'default_method' för gränssnittet utan att behöva definiera det i klassen.

Detta är användningen av standard- och statiska metoder i gränssnittet. Men om en klass vill anpassa standardmetoden kan du tillhandahålla sin egen implementering genom att åsidosätta metoden.

Metodreferenser

Metodreferensfunktionen introducerad i Java 8 är en förkortning för Lambda Expressions att kalla en metod för funktionellt gränssnitt. Så varje gång du använder ett Lambdauttryck för att hänvisa en metod kan du ersätta ditt Lambdauttryck med metodreferens.

Exempel på metodreferens.

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:

Metod Referensutgång

I det här programmet har vi ett gränssnitt 'interface_default' med en abstrakt metod 'display ()'. Därefter finns det en klass 'derivated_class' som har en offentlig metod 'classMethod' som skriver ut ett meddelande.

I huvudfunktionen har vi ett objekt för klassen, och sedan har vi en referens till gränssnittet som refererar till en klassmetod 'classMethod' genom obj1 (klassobjekt). Nu när den abstrakta metodvisningen anropas genom gränssnittsreferens, visas innehållet i classMethod.

Java Stream API för massdataoperationer på samlingar

Stream API är ännu en större förändring som introducerats i Java 8. Stream API används för att bearbeta samlingen av objekt och stöder en annan typ av iteration. En ström är en sekvens av objekt (element) som låter dig pipelera olika metoder för att ge önskat resultat.

En ström är inte en datastruktur och den får sin inmatning från samlingar, matriser eller andra kanaler. Vi kan pipeline olika mellanliggande operationer med Streams och terminaloperationerna returnerar resultatet. Vi kommer att diskutera stream API mer detaljerat i en separat Java-handledning.

Java Date Time API

Java 8 introducerar ett nytt datum-tid-API under paketet java.time.

De viktigaste klasserna bland dem är:

  • Lokal: Förenklat API för datum och tid utan komplexitet i tidszonshantering.
  • Zoned: Specialiserat API för datum och tid för hantering av olika tidszoner.

Datum

Datumklass har blivit föråldrad i Java 8.

Nedan följer de nya klasserna:

  • Klassen LocalDate definierar ett datum. Det har ingen representation för tid eller tidszon.
  • LocalTime klass definierar en tid. Den har ingen representation för datum eller tidszon.
  • Klassen LocalDateTime definierar ett datum-tid. Den har ingen representation av en tidszon.

För att inkludera tidszoninformation med datumfunktionalitet kan du använda Lambda som tillhandahåller tre klasser, dvs. OffsetDate, OffsetTime och OffsetDateTime. Här representeras tidszonsförskjutning med en annan klass - “ZoneId”. Vi kommer att behandla detta ämne i detalj i de senare delarna av denna Java-serie.

JavaScript-motor för noshörning

Java 8 introducerade en mycket förbättrad motor för JavaScript, dvs Nashorn som ersätter den befintliga noshörningen. Nashorn sammanställer koden direkt i minnet och skickar sedan bytkoden till JVM och förbättrar därmed prestandan med tio gånger.

Nashorn introducerar ett nytt kommandoradsverktyg - jjs som kör JavaScript-kod på konsolen.

Låt oss skapa en JavaScript-fil 'sample.js' som innehåller följande kod.

print (‘Hello, World!!’);

Ge följande kommando i konsolen:

C: Java jjs sample.js

Produktion: Hej världen!!

Vi kan också köra JavaScript-program i interaktivt läge och även ge argument till programmen.

Base64-kodavkodning

I Java 8 finns inbyggd kodning och avkodning för Base64-kodning. Klassen för Base64-kodning är java.util.Base64.

Denna klass tillhandahåller tre Base64-koder och avkodare:

  • Grundläggande: I detta mappas utgången till en uppsättning tecken mellan A-Za-z0-9 + /. Ingen radmatning läggs till utgången av kodaren och avkodaren avvisar något annat tecken än ovanstående.
  • URL: Här är utdata URL och filnamn säkert mappas till uppsättningen tecken mellan A-Za-z0-9 + /.
  • MIMA: I denna typ av kodare mappas utgången till ett MIME-vänligt format.

Samling API-förbättringar

Java 8 har lagt till följande nya metoder i Collection API:

  • forEachRemaining (konsumentåtgärd): Detta är en standardmetod och det är för Iterator. Den utför 'åtgärden' för vart och ett av de återstående elementen tills alla element bearbetas eller 'åtgärd' ger ett undantag.
  • Standardmetoden för samling removeIf (Predikatfilter): Detta tar bort alla element i samlingen som uppfyller det givna “filtret”.
  • Spliterator (): Det här är en insamlingsmetod och returnerar spliteratorinstansen som du kan använda för att korsa elementen antingen sekventiellt eller parallellt.
  • Kartsamlingen har ersättningsmetoder (Alla), beräkna () och sammanfoga ().
  • HashMap-klassen med nyckelkollisioner har förbättrats för att förbättra prestanda.

Ändringar / förbättringar av API för samtidighet

Följande är de viktiga förbättringarna i Concurrent API:

  • ConcurrentHashMap förbättras med följande metoder:
    1. beräkna (),
    2. för varje (),
    3. forEachEntry (),
    4. forEachKey (),
    5. forEachValue (),
    6. gå (),
    7. minska () och
    8. Sök ()
  • Metoden 'newWorkStealingPool ()' för exekutörer skapar en arbetsstjälande trådpool. Den använder tillgängliga processorer som målnivå för parallellitet.
  • Metoden ”completeableFuture” är den som vi kan slutföra uttryckligen (genom att ställa in dess värde och status).

Java IO-förbättringar

IO-förbättringar som gjorts i Java 8 inkluderar:

  • Files.list (sökväg dir): Detta returnerar en jlazily befolkad ström, vars varje element är posten i katalogen.
  • Files.lines (sökväg): Läser alla rader från en ström.
  • Files.find (): Sök efter filer i filträdet som är rotad till en given startfil och returnerar en ström befolkad av en sökväg.
  • BufferedReader.lines (): Returnerar en ström med alla element när raderna läses från BufferedReader.

Diverse Core API-förbättringar

Vi har följande diverse API-förbättringar:

  • Statisk metod med Initial (leverantörsleverantör) av ThreadLocal för att enkelt skapa instans.
  • Gränssnittet 'Comparator' utökas med standard- och statiska metoder för naturlig beställning av omvänd ordning etc.
  • Integer-, Long- och Double-wrapper-klasser har min (), max () och sum () -metoder.
  • Boolesk klass förbättras med logicalAnd (), logicalOr () och logicalXor () -metoder.
  • Flera verktygsmetoder introduceras i matematikklassen.
  • JDBC-ODBC Bridge tas bort.
  • PermGen-minnesutrymmet har tagits bort.

Slutsats

I denna handledning har vi diskuterat de viktigaste funktionerna som har lagts till i Java 8-versionen. Eftersom Java 8 är en stor version från Java är det viktigt att du känner till alla funktioner och förbättringar som gjordes som en del av den här versionen.

Även om den senaste Java-versionen är 13 är det fortfarande en bra idé att bekanta sig med Java 8-funktionerna. Alla funktioner som diskuteras i denna handledning finns fortfarande i den senaste versionen av Java och vi kommer att diskutera dem som enskilda ämnen senare i denna serie.

Vi hoppas att den här guiden hjälpte dig att lära dig om olika Java 8-funktioner !!

Rekommenderad läsning

^