Meniu

Caracteristici prominente Java 8 cu exemple de cod

  • Principal
  • Alte
  • Caracteristici prominente Java 8 cu exemple de cod

prominent java 8 features with code examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

O listă cuprinzătoare și explicații ale tuturor caracteristicilor proeminente introduse în versiunea Java 8 cu exemple:

Versiunea Java 8 de la Oracle a fost o versiune revoluționară a platformei de dezvoltare # 1 din lume. Acesta a inclus un upgrade imens la modelul de programare Java în ansamblu, împreună cu evoluția JVM, a limbajului Java și a bibliotecilor într-o manieră coordonată.

Această versiune a inclus mai multe funcții pentru ușurința în utilizare, productivitate, programare îmbunătățită poliglotă, securitate și performanță generală îmbunătățită.

Caracteristici Java 8

Ce veți învăța:

Funcții adăugate la lansarea Java 8

Printre modificările majore, următoarele sunt caracteristicile notabile care au fost adăugate la această versiune.

  • Interfețe funcționale și Lambda Expressions
  • pentru fiecare metodă () în interfața Iterable
  • Clasa opțională,
  • metode implicite și statice în interfețe
  • Referințe metode
  • API Java Stream pentru operațiuni de date în bloc pe colecții
  • API Java Date Time
  • Îmbunătățiri API de colecție
  • Îmbunătățiri ale API-ului simultan
  • Îmbunătățiri IO Java
  • Motor JavaScript rinocer
  • Decodare codificare Base64
  • Diverse îmbunătățiri API Core

În acest tutorial, vom discuta pe scurt fiecare dintre aceste caracteristici și vom încerca să explicăm fiecare dintre ele cu ajutorul unor exemple simple și ușoare.

Interfețe funcționale și expresii Lambda

Java 8 introduce o adnotare cunoscută sub numele de @FunctionalInterface, care este de obicei pentru erori la nivel de compilator. Este de obicei utilizat atunci când interfața pe care o utilizați încalcă contractele interfeței funcționale.

Alternativ, puteți apela o interfață funcțională ca interfață SAM sau interfață Single Abstract Method. O interfață funcțională permite exact o „metodă abstractă” ca membru.

Mai jos este prezentat un exemplu de interfață funcțională:

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

Puteți omite adnotarea, @FunctionalInterface și interfața dvs. funcțională va fi în continuare una validă. Folosim această adnotare numai pentru a informa compilatorul că interfața va avea o singură metodă abstractă.

Notă: Prin definiție, metodele implicite sunt non-abstracte și puteți adăuga câte metode implicite doriți în interfața funcțională.

În al doilea rând, dacă o interfață are o metodă abstractă care suprascrie una dintre metodele publice ale „java.lang.object”, atunci nu este considerată metoda abstractă a interfeței.

Dat mai jos este un exemplu valid de interfață funcțională.

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

O Expresie Lambda (sau funcție) poate fi definită ca o funcție anonimă (o funcție fără nume și un identificator). Expresiile Lambda sunt definite exact în locul în care sunt necesare, de obicei ca parametru pentru o altă funcție.

Dintr-o perspectivă diferită, Expresiile Lambda exprimă cazuri de Interfețe funcționale (descris mai sus). Expresiile Lambda implementează singura funcție abstractă prezentă în interfața funcțională și astfel implementează interfețe funcționale.

Sintaxa de bază a unei expresii Lambda este:

sintaxa expresiei lambda

Un exemplu de bază al expresiei Lambda este:

exemplu de expresie lambda

Expresia de mai sus ia doi parametri x și y și îi returnează suma x + y. Pe baza tipului de date x și y, metoda poate fi utilizată de mai multe ori în diferite locuri. Astfel, parametrii x și y se vor potrivi int sau Integer și șir, iar pe baza contextului, va adăuga două numere întregi (când parametrii sunt int) sau concatează cele două șiruri (când parametrii sunt un șir).

Să implementăm un program care să demonstreze expresiile Lambda.

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(); } }

Ieșire:

expresie lambda - ieșire

Programul de mai sus arată utilizarea Lambda Expression pentru a adăuga parametrii și afișează suma acestora. Apoi îl folosim pentru a implementa metoda abstractă „abstract_fun” pe care am declarat-o în definiția interfeței. Rezultatul apelării funcției „abstract_fun” este suma celor două numere întregi trecute ca parametri în timpul apelării funcției.

Vom afla mai multe despre Lambda Expressions mai târziu în tutorial.

forEach () Method In Iterable Interface

Java 8 a introdus o metodă „pentru fiecare” în interfața java.lang.Iterable care poate itera peste elementele din colecție. „ForEach” este o metodă implicită definită în interfața Iterable. Este folosit de clasele de colecție care extind interfața Iterable pentru a itera elemente.

Metoda „pentru fiecare” ia Interfața funcțională ca un singur parametru, adică puteți trece Lambda Expression ca argument.

Exemplu al metodei 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)); } }

Ieșire:

pentru Fiecare metodă de ieșire

Deci, avem o colecție de subiecte, adică subList. Afișăm conținutul sub-listului folosind metoda forEach care necesită Expresia Lambda pentru a imprima fiecare element.

Clasa opțională

Java 8 a introdus o clasă opțională în pachetul „java.util”. „Opțional” este o clasă publică finală și este folosit pentru a face față NullPointerException în aplicația Java. Folosind opțional, puteți specifica codul sau valorile alternative de rulat. Utilizând opțional, nu trebuie să utilizați prea multe verificări nule pentru a evita nullPointerException.

Puteți utiliza clasa opțională pentru a evita încetarea anormală a programului și pentru a preveni blocarea programului. Clasa opțională oferă metode care sunt utilizate pentru a verifica prezența valorii pentru o anumită variabilă.

Următorul program demonstrează utilizarea clasei opționale.

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'); } }

Ieșire:

Ieșire opțională de clasă

În acest program, folosim proprietatea „ofNullable” din clasa Optional pentru a verifica dacă șirul este nul. Dacă este, mesajul corespunzător este imprimat utilizatorului.

Metode implicite și statice în interfețe

În Java 8, puteți adăuga metode în interfață care nu sunt abstracte, adică puteți avea interfețe cu implementarea metodei. Puteți utiliza cuvântul cheie implicit și static pentru a crea interfețe cu implementarea metodei. Metodele implicite permit în principal funcționalitatea Lambda Expression.

Folosind metode implicite puteți adăuga funcționalități noi la interfețele din bibliotecile dvs. Acest lucru se va asigura că codul scris pentru versiunile mai vechi este compatibil cu acele interfețe (compatibilitate binară).

ce este un site de partajare de fișiere

Să înțelegem metoda implicită cu un exemplu:

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(); } }

Ieșire:

Metoda implicită - ieșire

Avem o interfață numită „interface_default” cu metoda default_method () cu o implementare implicită. Apoi, definim o clasă „derivată_clasă” care implementează interfața „interfață_defaultă”.

Rețineți că nu am implementat nicio metodă de interfață în această clasă. Apoi, în funcția principală, creăm un obiect al clasei „derivat_clasă” și apelăm direct „metoda implicită” a interfeței fără a fi nevoie să-l definim în clasă.

Aceasta este utilizarea metodelor implicite și statice în interfață. Cu toate acestea, dacă o clasă dorește să personalizeze metoda implicită, atunci puteți furniza propria implementare prin suprascrierea metodei.

Referințe metode

Funcția de referință a metodei introdusă în Java 8 este o notație abreviere pentru Lambda Expressions pentru a apela o metodă de interfață funcțională. Deci, de fiecare dată când utilizați o expresie Lambda pentru a face referire la o metodă, puteți înlocui expresia Lambda cu referința la metodă.

Exemplu de referință pentru metodă.

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(); } }

Ieșire:

Metoda de ieșire de referință

În acest program, avem o interfață „interface_default” cu o metodă abstractă „display ()”. Apoi, există o clasă „derivată_clasă” care are o metodă publică „clasăMetodă” care tipărește un mesaj.

În funcția principală, avem un obiect pentru clasă și apoi avem o referință la interfața care face referire la o metodă de clasă „classMethod” prin obiect1 (obiect de clasă). Acum, când afișarea metodei abstracte este apelată prin referința interfeței, atunci sunt afișate conținutul claseiMetodă.

API Java Stream pentru operațiuni de date în bloc pe colecții

API-ul Stream este încă o altă schimbare majoră introdusă în Java 8. Stream API este utilizat pentru procesarea colecției de obiecte și acceptă un tip diferit de iterație. Un flux este o secvență de obiecte (elemente) care vă permite să conductați diferite metode pentru a produce rezultatele dorite.

Un flux nu este o structură de date și își primește intrarea din colecții, tablouri sau alte canale. Putem canaliza diverse operațiuni intermediare folosind Stream-uri, iar operațiunile terminale returnează rezultatul. Vom discuta API-ul fluxului mai detaliat într-un tutorial Java separat.

API Java Date Time

Java 8 introduce un nou API data-oră sub pachetul java.time.

Cele mai importante clase dintre ele sunt:

  • Local: API simplificat pentru dată și oră, fără o complexitate de gestionare a fusului orar.
  • Zonat: API de dată-oră specializat pentru a face față diferitelor fusuri orare.

Datele

Clasa de dată a devenit învechită în Java 8.

În continuare sunt prezentate noile clase:

  • Clasa LocalDate definește o dată. Nu are nicio reprezentare pentru oră sau fus orar.
  • Ora locală clasă definește un timp. Nu are nicio reprezentare pentru dată sau fus orar.
  • Clasa LocalDateTime definește o dată-oră. Nu are nicio reprezentare a unui fus orar.

Pentru a include informații despre fusul orar cu funcționalitatea datei, puteți utiliza Lambda care oferă 3 clase, adică OffsetDate, OffsetTime și OffsetDateTime. Aici decalajul fusului orar este reprezentat folosind o altă clasă - „ZoneId”. Vom acoperi acest subiect în detaliu în părțile ulterioare ale acestei serii Java.

Motor JavaScript rinocer

Java 8 a introdus un motor mult îmbunătățit pentru JavaScript, adică Nashorn care înlocuiește Rhino-ul existent. Nashorn compilează direct codul în memorie și apoi trece bytecode-ul către JVM, îmbunătățind astfel performanța de 10 ori.

Nashorn introduce un nou instrument de linie de comandă - jjs care execută codul JavaScript la consolă.

Permiteți-ne să creăm un fișier JavaScript „sample.js” care conține următorul cod.

print (‘Hello, World!!’);

Dați următoarea comandă în consolă:

C: Java jjs sample.js

Ieșire: Salut Lume!!

De asemenea, putem rula programe JavaScript în modul interactiv și, de asemenea, putem oferi argumente programelor.

Decodare codificare Base64

În Java 8 există codificare și decodificare încorporate pentru codificarea Base64. Clasa pentru codificarea Base64 este java.util.Base64.

Această clasă oferă trei codificări și decodoare Base64:

  • De bază: În aceasta, ieșirea este mapată la un set de caractere între A-Za-z0-9 + /. Nici o alimentare de linie nu este adăugată la ieșire de către codificator și decodificatorul respinge orice alt caracter decât cel de mai sus.
  • URL: Aici ieșirea este adresa URL, iar numele fișierului sigur este mapat la setul de caractere între A-Za-z0-9 + /.
  • MIMA: În acest tip de codificator, ieșirea este mapată într-un format MIME friendly.

Îmbunătățiri API de colecție

Java 8 a adăugat următoarele metode noi la API-ul de colecție:

  • forEachRemaining (acțiunea consumatorului): Aceasta este o metodă implicită și este pentru Iterator. Efectuează „acțiunea” pentru fiecare dintre elementele rămase până când toate elementele sunt procesate sau „acțiunea” aruncă o excepție.
  • Metoda implicită pentru colectarea removeIf (Filtru predicat): Aceasta elimină toate elementele din colecție care satisfac „filtrul” dat.
  • Spliterator (): Aceasta este o metodă de colectare și returnează instanța spliterator pe care o puteți utiliza pentru a parcurge elementele fie în mod secvențial, fie în mod paralel.
  • Colecția de hărți are metode replaceAll (), compute () și merge ().
  • Clasa HashMap cu coliziuni cheie a fost îmbunătățită pentru a spori performanța.

Modificări / îmbunătățiri ale API-ului simultan

Următoarele sunt îmbunătățirile importante în API-ul concurent:

  • ConcurrentHashMap este îmbunătățit cu următoarele metode:
    1. calculează (),
    2. pentru fiecare (),
    3. forEachEntry (),
    4. forEachKey (),
    5. forEachValue (),
    6. merge (),
    7. reduce () și
    8. căutare ()
  • Metoda „newWorkStealingPool ()” pentru executanți creează un pool de fire de furt de lucru. Folosește procesoarele disponibile ca nivel țintă de paralelism.
  • Metoda „completableFuture” este cea pe care o putem completa în mod explicit (prin setarea valorii și stării sale).

Îmbunătățiri Java IO

Îmbunătățirile IO realizate în Java 8 includ:

  • Files.list (direcție cale): Aceasta returnează un flux cu populație slabă, al cărui fiecare element este intrarea din director.
  • Files.lines (calea căii): Citește toate liniile dintr-un flux.
  • Files.find (): Căutați fișiere în arborele de fișiere înrădăcinat într-un anumit fișier de pornire și returnează un flux populat de o cale.
  • BufferedReader.lines (): Returnează un flux cu fiecare element al acestuia pe măsură ce liniile citite din BufferedReader.

Diverse îmbunătățiri ale API-ului principal

Avem următoarele îmbunătățiri API diferite:

  • Metoda statică cu Initial (Furnizor furnizor) de ThreadLocal pentru a crea instanță cu ușurință.
  • Interfața „Comparator” este extinsă cu metodele implicite și statice pentru ordonare naturală ordine inversă etc.
  • Clasele de înveliș întreg, lung și dublu au metode min (), max () și sum ().
  • Clasa booleană este îmbunătățită cu metode logicAnd (), logicOr () și logicXor ().
  • În clasa Matematică sunt introduse mai multe metode de utilitate.
  • Podul JDBC-ODBC este eliminat.
  • Spațiul de memorie PermGen este eliminat.

Concluzie

În acest tutorial, am discutat despre caracteristicile majore care au fost adăugate la versiunea Java 8. Deoarece Java 8 este o versiune majoră de la Java, este important să cunoașteți toate caracteristicile și îmbunătățirile care au fost făcute ca parte a acestei versiuni.

Deși cea mai recentă versiune Java este 13, este încă o idee bună să vă familiarizați cu caracteristicile Java 8. Toate caracteristicile discutate în acest tutorial sunt încă prezente în cea mai recentă versiune de Java și le vom discuta ca subiecte individuale mai târziu în această serie.

Sperăm că acest tutorial v-a ajutat să aflați mai multe caracteristici Java 8 !!

Lectură recomandată

^