Menu

Funzionalità di Java 8 prominenti con esempi di codice

prominent java 8 features with code examples

Prova Il Nostro Strumento Per Eliminare I Problemi

Un elenco completo e una spiegazione di tutte le caratteristiche principali introdotte nella versione Java 8 con esempi:

La versione Java 8 di Oracle è stata una versione rivoluzionaria della piattaforma di sviluppo numero 1 al mondo. Comprendeva un enorme aggiornamento al modello di programmazione Java nel suo insieme insieme all'evoluzione della JVM, del linguaggio Java e delle librerie in modo coordinato.

Questa versione includeva diverse funzionalità per facilità d'uso, produttività, programmazione Polyglot migliorata, sicurezza e prestazioni complessivamente migliorate.

Funzionalità di Java 8

Cosa imparerai:

Funzionalità aggiunte alla versione Java 8

Tra le principali modifiche, le seguenti sono le caratteristiche notevoli che sono state aggiunte a questa versione.

  • Interfacce funzionali ed espressioni lambda
  • metodo forEach () nell'interfaccia Iterable
  • Classe opzionale,
  • metodi predefiniti e statici in Interfaces
  • Riferimenti al metodo
  • API Java Stream per operazioni di dati in blocco sulle raccolte
  • API Java Date Time
  • Miglioramenti all'API di raccolta
  • Miglioramenti dell'API di concorrenza
  • Java IO improvements
  • Motore JavaScript Rhinoceros
  • Base64 Encode Decode
  • Miglioramenti vari dell'API Core

In questo tutorial, discuteremo brevemente ciascuna di queste funzionalità e proveremo a spiegarle ciascuna con l'aiuto di esempi semplici e facili.

Interfacce funzionali ed espressioni Lambda

Java 8 introduce un'annotazione nota come @FunctionalInterface che di solito è per errori a livello di compilatore. Viene tipicamente utilizzato quando l'interfaccia che stai utilizzando viola i contratti dell'interfaccia funzionale.

In alternativa, è possibile chiamare un'interfaccia funzionale come interfaccia SAM o interfaccia Single Abstract Method. Un'interfaccia funzionale consente esattamente un 'metodo astratto' come membro.

Di seguito viene fornito un esempio di interfaccia funzionale:

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

Puoi omettere l'annotazione, @FunctionalInterface e la tua interfaccia funzionale sarà ancora valida. Usiamo questa annotazione solo per informare il compilatore che l'interfaccia avrà un unico metodo astratto.

Nota: Per definizione, i metodi predefiniti sono Non astratti e puoi aggiungere tutti i metodi predefiniti nell'interfaccia funzionale che desideri.

In secondo luogo, se un'interfaccia ha un metodo astratto che sovrascrive uno dei metodi pubblici di 'java.lang.object', allora non è considerato come il metodo astratto dell'interfaccia.

cos'è la funzione amico in c ++

Di seguito è riportato un valido esempio di interfaccia funzionale.

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

Un'espressione (o funzione) Lambda può essere definita come una funzione anonima, (una funzione senza nome e un identificatore). Le espressioni lambda sono definite esattamente nel punto in cui sono necessarie, solitamente come parametro di qualche altra funzione.

Da una prospettiva diversa, le espressioni Lambda esprimono istanze di Interfacce funzionali (descritto sopra). Le Lambda Expressions implementano l'unica funzione astratta presente nell'interfaccia funzionale e quindi implementano interfacce funzionali.

La sintassi di base di un'espressione Lambda è:

sintassi delle espressioni lambda

Un esempio di base dell'espressione Lambda è:

esempio di espressione lambda

L'espressione precedente accetta due parametri x e y e restituisce la sua somma x + y. In base al tipo di dati di x e y, il metodo può essere utilizzato più volte in vari punti. Pertanto i parametri x e y corrisponderanno a int o Integer e stringa e, in base al contesto, aggiungerà due interi (quando i parametri sono int) o concatenerà le due stringhe (quando i parametri sono una stringa).

Implementiamo un programma che dimostri 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(); } }

Produzione:

espressione lambda - output

Il programma sopra mostra l'uso di Lambda Expression per l'aggiunta ai parametri e visualizza la loro somma. Quindi lo usiamo per implementare il metodo astratto 'abstract_fun' che abbiamo dichiarato nella definizione dell'interfaccia. Il risultato della chiamata della funzione 'abstract_fun' è la somma dei due numeri interi passati come parametri durante la chiamata della funzione.

Impareremo di più sulle espressioni Lambda più avanti nel tutorial.

Metodo forEach () nell'interfaccia Iterable

Java 8 ha introdotto un metodo 'forEach' nell'interfaccia java.lang.Iterable che può iterare sugli elementi nella raccolta. 'ForEach' è un metodo predefinito definito nell'interfaccia Iterable. Viene utilizzato dalle classi Collection che estendono l'interfaccia Iterable per iterare gli elementi.

Il metodo 'forEach' accetta l'interfaccia funzionale come un singolo parametro, ovvero puoi passare Lambda Expression come argomento.

Esempio del metodo 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)); } }

Produzione:

forEach metodo di output

Quindi abbiamo una raccolta di argomenti, ad esempio subList. Visualizziamo il contenuto della subList utilizzando il metodo forEach che utilizza Lambda Expression per stampare ogni elemento.

Classe opzionale

Java 8 ha introdotto una classe opzionale nel pacchetto 'java.util'. 'Optional' è una classe finale pubblica e viene utilizzata per gestire NullPointerException nell'applicazione Java. Utilizzando Facoltativo, è possibile specificare codice o valori alternativi da eseguire. Utilizzando Opzionale non è necessario utilizzare troppi controlli null per evitare nullPointerException.

È possibile utilizzare la classe Optional per evitare la chiusura anomala del programma e impedire che il programma si blocchi. La classe Optional fornisce metodi che vengono utilizzati per verificare la presenza di valore per una particolare variabile.

Il seguente programma dimostra l'uso della classe 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'); } }

Produzione:

Output di classe opzionale

In questo programma, usiamo la proprietà 'ofNullable' della classe Optional per verificare se la stringa è nulla. In tal caso, all'utente viene stampato il messaggio appropriato.

Metodi predefiniti e statici nelle interfacce

In Java 8, puoi aggiungere metodi nell'interfaccia che non sono astratti, ad esempio puoi avere interfacce con l'implementazione del metodo. È possibile utilizzare le parole chiave Default e Static per creare interfacce con l'implementazione del metodo. I metodi predefiniti abilitano principalmente la funzionalità Lambda Expression.

Utilizzando metodi predefiniti è possibile aggiungere nuove funzionalità alle interfacce nelle librerie. Ciò garantirà che il codice scritto per le versioni precedenti sia compatibile con quelle interfacce (compatibilità binaria).

Comprendiamo il metodo predefinito con un esempio:

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

Produzione:

Metodo predefinito: output

Abbiamo un'interfaccia chiamata 'interface_default' con il metodo default_method () con un'implementazione predefinita. Successivamente, definiamo una classe 'derivata_class' che implementa l'interfaccia 'interfaccia_default'.

Notare che non abbiamo implementato alcun metodo di interfaccia in questa classe. Quindi nella funzione main, creiamo un oggetto di classe 'derivato_class' e chiamiamo direttamente il 'metodo_predefinito' dell'interfaccia senza doverlo definire nella classe.

Questo è l'uso dei metodi predefiniti e statici nell'interfaccia. Tuttavia, se una classe desidera personalizzare il metodo predefinito, è possibile fornire la propria implementazione sovrascrivendo il metodo.

Riferimenti al metodo

La funzionalità di riferimento del metodo introdotta in Java 8 è una notazione abbreviata per Lambda Expressions per chiamare un metodo di interfaccia funzionale. Pertanto, ogni volta che utilizzi un'espressione Lambda per fare riferimento a un metodo, puoi sostituire la tua espressione Lambda con il riferimento al metodo.

Esempio di riferimento al metodo.

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

Produzione:

Output di riferimento del metodo

In questo programma, abbiamo un'interfaccia 'interface_default' con un metodo astratto 'display ()'. Successivamente, c'è una classe 'derivata_class' che ha un metodo pubblico 'classMethod' che stampa un messaggio.

Nella funzione main, abbiamo un oggetto per la classe, quindi abbiamo un riferimento all'interfaccia che fa riferimento a un metodo di classe 'classMethod' tramite obj1 (oggetto di classe). Ora, quando la visualizzazione del metodo astratto viene chiamata tramite riferimento all'interfaccia, vengono visualizzati i contenuti di classMethod.

API Java Stream per operazioni di dati in blocco sulle raccolte

L'API Stream è un'altra importante modifica introdotta in Java 8. L'API Stream viene utilizzata per elaborare la raccolta di oggetti e supporta un diverso tipo di iterazione. Un flusso è una sequenza di oggetti (elementi) che consente di pipeline diversi metodi per produrre i risultati desiderati.

Uno stream non è una struttura dati e riceve il suo input da raccolte, array o altri canali. Possiamo pipeline varie operazioni intermedie usando Streams e le operazioni terminali restituiscono il risultato. Discuteremo l'API di flusso in modo più dettagliato in un tutorial Java separato.

API Java Date Time

Java 8 introduce una nuova API data-ora nel pacchetto java.time.

Le classi più importanti tra loro sono:

  • Locale: API data-ora semplificata senza complessità di gestione del fuso orario.
  • Suddiviso in zone: API data-ora specializzata per gestire vari fusi orari.

Date

La classe Date è diventata obsoleta in Java 8.

Di seguito sono riportate le nuove classi introdotte:

  • La classe LocalDate definisce una data. Non ha alcuna rappresentazione per l'ora o il fuso orario.
  • Il LocalTime classe definisce un tempo. Non ha alcuna rappresentazione per data o fuso orario.
  • La classe LocalDateTime definisce una data-ora. Non ha la rappresentazione di un fuso orario.

Per includere le informazioni sul fuso orario con la funzionalità della data, puoi utilizzare Lambda che fornisce 3 classi, ovvero OffsetDate, OffsetTime e OffsetDateTime. Qui l'offset del fuso orario è rappresentato utilizzando un'altra classe - 'ZoneId'. Tratteremo questo argomento in dettaglio nelle parti successive di questa serie Java.

Motore JavaScript Rhinoceros

Java 8 ha introdotto un motore molto migliorato per JavaScript, ad esempio Nashorn, che sostituisce Rhino esistente. Nashorn compila direttamente il codice in memoria e quindi passa il bytecode a JVM migliorando così le prestazioni di 10 volte.

Nashorn introduce un nuovo strumento da riga di comando: jjs che esegue il codice JavaScript dalla console.

Creiamo un file JavaScript 'sample.js' che contenga il codice seguente.

print (‘Hello, World!!’);

Dare il seguente comando nella console:

C: Java jjs sample.js

Produzione: Ciao mondo!!

Possiamo anche eseguire programmi JavaScript in modalità interattiva e fornire argomenti ai programmi.

Base64 Encode Decode

In Java 8 è incorporata la codifica e la decodifica per la codifica Base64. La classe per la codifica Base64 è java.util.Base64.

Questa classe fornisce tre codifiche e decodificatori Base64:

  • Di base: In questo, l'output viene mappato su un set di caratteri compreso tra A-Za-z0-9 + /. Nessun avanzamento riga viene aggiunto all'uscita dal codificatore e il decodificatore rifiuta qualsiasi carattere diverso da quanto sopra.
  • URL: Qui l'output è l'URL e il nome del file sicuro è mappato al set di caratteri compreso tra A-Za-z0-9 + /.
  • MIMO: In questo tipo di codificatore, l'output è mappato in un formato compatibile con MIME.

Miglioramenti all'API di raccolta

Java 8 ha aggiunto i seguenti nuovi metodi all'API di raccolta:

  • forEachRemaining (azione consumatore): questo è un metodo predefinito ed è per l'iteratore. Esegue l ''azione' per ciascuno degli elementi rimanenti fino a quando tutti gli elementi vengono elaborati o 'azione' genera un'eccezione.
  • Il metodo predefinito per la raccolta removeIf (filtro predicato): rimuove tutti gli elementi nella raccolta che soddisfano il 'filtro' specificato.
  • Spliterator (): questo è un metodo di raccolta e restituisce un'istanza di spliterator che è possibile utilizzare per attraversare gli elementi in modo sequenziale o parallelo.
  • La raccolta di mappe ha i metodi replaceAll (), compute () e merge ().
  • La classe HashMap con le collisioni di chiavi è stata migliorata per migliorare le prestazioni.

Modifiche / miglioramenti all'API di concorrenza

Di seguito sono riportati gli importanti miglioramenti in Concurrent API:

  • ConcurrentHashMap è stato migliorato con i seguenti metodi:
    1. compute (),
    2. per ciascuno (),
    3. forEachEntry (),
    4. forEachKey (),
    5. forEachValue (),
    6. go (),
    7. reduce () e
    8. ricerca ()
  • Il metodo 'newWorkStealingPool ()' per gli esecutori crea un pool di thread che ruba il lavoro. Utilizza i processori disponibili come livello di parallelismo di destinazione.
  • Il metodo 'completableFuture' è quello che possiamo completare esplicitamente (impostandone il valore e lo stato).

Java IO Improvements

I miglioramenti dell'IO realizzati in Java 8 includono:

  • Files.list (percorso dir): Ciò restituisce un flusso popolato in modo divertente, il cui ogni elemento è la voce nella directory.
  • Files.lines (percorso percorso): Legge tutte le righe da un flusso.
  • Files.find (): Cerca i file nella struttura ad albero dei file radicati in un dato file iniziale e restituisce un flusso popolato da un percorso.
  • BufferedReader.lines (): Restituisce un flusso con ogni suo elemento come le righe lette da BufferedReader.

Miglioramenti vari dell'API principale

Abbiamo i seguenti vari miglioramenti all'API:

  • Metodo statico con Iniziale (fornitore del fornitore) di ThreadLocal per creare facilmente un'istanza.
  • L'interfaccia 'Comparator' è estesa con i metodi predefiniti e statici per l'ordine naturale inverso, ecc.
  • Le classi wrapper Integer, Long e Double hanno metodi min (), max () e sum ().
  • La classe booleana è migliorata con i metodi LogicAnd (), LogicOr () e LogicXor ().
  • Diversi metodi di utilità vengono introdotti nella classe Math.
  • JDBC-ODBC Bridge viene rimosso.
  • Lo spazio di memoria di PermGen viene rimosso.

Conclusione

In questo tutorial, abbiamo discusso le principali funzionalità aggiunte alla versione Java 8. Poiché Java 8 è una versione principale di Java, è importante conoscere tutte le funzionalità e i miglioramenti apportati come parte di questa versione.

Sebbene l'ultima versione di Java sia la 13, è comunque una buona idea acquisire familiarità con le funzionalità di Java 8. Tutte le funzionalità discusse in questo tutorial sono ancora presenti nell'ultima versione di Java e le discuteremo come singoli argomenti più avanti in questa serie.

Speriamo che questo tutorial ti abbia aiutato a conoscere le varie funzionalità di Java 8 !!

Lettura consigliata

^