Home-theater-designers
I flussi Java 8 consentono agli sviluppatori di estrarre dati precisi da una vasta raccolta, utilizzando una serie di operazioni predefinite.
Prima del rilascio di Java 8, l'uso del termine 'stream' in Java veniva automaticamente associato all'I/O. Tuttavia, Java 8 ha introdotto un flusso che può essere definito un insieme di passaggi computazionali concatenati in quella che viene comunemente definita 'conduttura di flusso'.
Questo articolo ti introdurrà ai flussi Java 8 e dimostrerà come possono essere utili nei tuoi progetti.
Che cos'è un flusso?
Un flusso è un'interfaccia Java che prende un'origine, esegue una serie di operazioni per estrarre dati specifici, quindi fornisce tali dati all'applicazione per l'uso. In sostanza, consente di estrarre dati specializzati da una raccolta di dati generalizzati.
Come funzionano gli stream
Una pipeline di flusso inizia sempre con un'origine. Il tipo di origine dipende dal tipo di dati con cui hai a che fare, ma due dei più popolari sono gli array e le raccolte.
Per trasformare la raccolta in un flusso iniziale, dovrai aggiungere il flusso() funzione alla fonte. Ciò posizionerà la sorgente nella pipeline del flusso in cui diverse operazioni intermedie (come ad esempio filtro() e ordinare() ) può operare su di esso.
Dopo che tutte le operazioni intermedie richieste sono state eseguite, è possibile introdurre un'operazione terminale (come per ciascuno() ), che produrrà i dati precedentemente estratti dalla fonte.
La vita senza flussi
Java 8 è stato rilasciato nel 2014, ma prima gli sviluppatori Java avevano ancora bisogno di estrarre dati specializzati da una raccolta di dati generali.
cos'è la modalità aereo su un telefono cellulare?
Supponiamo che tu abbia un elenco di caratteri casuali che vengono combinati con numeri casuali per formare valori di stringa univoci, ma desideri solo i valori che iniziano con il carattere C e vuoi disporre il risultato in ordine crescente. Questo è il modo in cui estrarresti quei dati senza flussi.
Imparentato: Cosa devi sapere sull'uso delle stringhe in Java
Esempio di filtraggio e ordinamento dei valori senza flussi
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
//declare and initialize the array list
List randomValues = Arrays.asList(
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',
'B11', 'B12', 'C13', 'B14', 'B15', 'B16',
'F12', 'E13', 'C11', 'C14', 'A15', 'C16',
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'
);
//declare the array list will store needed values
List requiredValues = new ArrayList();
//extracting the required values and storing them in reqquiredValues
randomValues.forEach(value -> {
if(value.startsWith('C')) {
requiredValues.add(value);
}
});
//sort the requiredValues in ascending order
requiredValues.sort((String value1, String value2) -> value1.compareTo(value2));
//print each value to the console
requiredValues.forEach((String value) -> System.out.println(value));
}
}
Dovrai anche dichiarare e inizializzare l'elenco degli array se stai usando i flussi o qualche altro metodo di estrazione. Quello che non avresti bisogno di fare se stessi usando i flussi è dichiarare una nuova variabile per contenere i valori richiesti, né creare le altre cinque righe di codice in più nell'esempio sopra.
Imparentato: Come creare ed eseguire operazioni su array in Java
Il codice sopra produce il seguente output nella console:
C11
C12
C13
C14
C15
C16
La vita con i flussi
Nella programmazione, l'efficienza significa produrre lo stesso risultato con una quantità significativamente inferiore di codice. Questo è esattamente ciò che fa una pipeline di flusso per un programmatore. Quindi la prossima volta che qualcuno chiede: perché è importante utilizzare gli stream nel tuo progetto? In poche parole: i flussi supportano una programmazione efficiente.
Continuando con il nostro esempio sopra, ecco come l'introduzione di flussi trasforma l'intero programma.
Filtraggio e ordinamento dei valori con un esempio di flusso
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
//declare and initialize the array list
List randomValues = Arrays.asList(
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',
'B11', 'B12', 'C13', 'B14', 'B15', 'B16',
'F12', 'E13', 'C11', 'C14', 'A15', 'C16',
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'
);
//retrieves only values that start with C, sort them, and print them to the console.
randomValues.stream().filter(value->value.startsWith('C')).sorted().forEach(System.out::println);
}
}
Il codice sopra mostra quanto sia potente l'interfaccia del flusso. Prende un elenco di valori di array casuali e lo trasforma in un flusso usando il flusso() funzione. Il flusso viene quindi ridotto a un elenco di array che contiene i valori richiesti (che sono tutti i valori che iniziano con C ), usando il filtro() funzione.
Come puoi vedere nell'esempio sopra, il C i valori sono disposti casualmente nell'elenco degli array. Se dovessi stampare il flusso a questo punto della pipeline, il valore C15 verrebbe stampato per primo. quindi, il ordinare() viene introdotta la funzione nella pipeline del flusso per riorganizzare il nuovo array in ordine crescente.
La funzione finale nella pipeline del flusso è a per ciascuno() funzione. Questa è una funzione terminale utilizzata per interrompere la pipeline del flusso e produce i seguenti risultati nella console:
C11
C12
C13
C14
C15
C16
Operazioni intermedie in streaming
È disponibile un ampio elenco di operazioni intermedie che possono essere usate in una pipeline di flusso.
Una pipeline di flusso inizia sempre con una singola fonte e un flusso() funzione e termina sempre con una singola operazione terminale (sebbene ce ne siano diverse tra cui scegliere). Ma tra queste due sezioni c'è un elenco di sei operazioni intermedie che è possibile utilizzare.
Nel nostro esempio sopra, vengono utilizzate solo due di queste operazioni intermedie --- filtro() e ordinare() . L'operazione intermedia che scegli dipenderà dalle attività che desideri eseguire.
Se uno qualsiasi dei valori che iniziano con C nel nostro elenco di array sopra fosse in minuscolo e eseguissimo le stesse operazioni intermedie su di essi, otterremmo il seguente risultato.
Esecuzione di operazioni di filtro e ordinamento su valori minuscoli Esempio
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
//declare and initialize the array list
List randomValues = Arrays.asList(
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',
'B11', 'B12', 'c13', 'B14', 'B15', 'B16',
'F12', 'E13', 'C11', 'C14', 'A15', 'c16',
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'
);
//retrieves only values that start with C, sort them, and print them to the console.
randomValues.stream().filter(value->value.startsWith('C')).sorted().forEach(System.out::println);
}
}
Il codice sopra produrrà i seguenti valori nella console:
C11
C12
C14
C15
L'unico problema con l'output sopra è che non rappresenta accuratamente tutti i C valori nella nostra lista di array. Un buon modo per correggere questo piccolo errore consiste nell'introdurre un'altra operazione intermedia nella pipeline del flusso; questa operazione è nota come carta geografica() funzione.
Utilizzo dell'esempio della funzione mappa
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
//declare and initialize the array list
List randomValues = Arrays.asList(
'E11', 'D12', 'A13', 'F14', 'C15', 'A16',
'B11', 'B12', 'c13', 'B14', 'B15', 'B16',
'F12', 'E13', 'C11', 'C14', 'A15', 'c16',
'F11', 'C12', 'D13', 'E14', 'D15', 'D16'
);
//transforms all lower case characters to upper case,
//retrieves only values that start with C, sort them, and print them to the console.
randomValues.stream().map(String::toUpperCase).filter(value->value.startsWith('C')).sorted().forEach(System.out::println);
}
}
Il carta geografica() la funzione trasforma un oggetto da uno stato all'altro; nel nostro esempio sopra trasforma tutti i caratteri minuscoli nell'elenco dell'array in caratteri maiuscoli.
Posizionando il carta geografica() funzione appena prima del filtro() la funzione recupera tutti i valori che iniziano con C dall'elenco degli array.
Il codice sopra produce il seguente risultato nella console, rappresentando con successo tutti i C valori nell'elenco degli array.
C11
C12
C13
C14
C15
C16
Le altre tre operazioni intermedie che puoi utilizzare nelle tue applicazioni includono:
- sbirciare()
- limite()
- Salta()
I flussi Java 8 facilitano la creazione di codice efficiente
Con i flussi Java 8 puoi estrarre dati extra specifici e rilevanti da una grande fonte con una riga di codice. Finché includi l'iniziale flusso() funzione e un operatore terminale, è possibile utilizzare qualsiasi combinazione di operazioni intermedie che forniscano risultati adeguati al proprio obiettivo.
puoi essere invisibile su facebook?
Se ti stai chiedendo quale sia la riga di codice racchiusa all'interno del nostro filtro() funzione; è nota come 'espressione lambda'. Le espressioni lambda sono un'altra funzionalità introdotta con Java 8 e ha molte pepite che potresti trovare utili.
Condividere Condividere Tweet E-mail Una rapida introduzione a Java 8 LambdasSe sei un programmatore Java e sei interessato a saperne di più sui lambda Java 8, in questo articolo daremo un'occhiata più da vicino alla sintassi e all'utilizzo di lambda.
Leggi Avanti Argomenti correlati- Programmazione
- Giava
- Tutorial sulla programmazione
Kadeisha Kean è uno sviluppatore software full-stack e scrittore tecnico/tecnologico. Ha la spiccata capacità di semplificare alcuni dei concetti tecnologici più complessi; producendo materiale che può essere facilmente compreso da qualsiasi principiante della tecnologia. È appassionata di scrivere, sviluppare software interessanti e viaggiare per il mondo (attraverso documentari).
Altro da Kadeisha KeanIscriviti alla nostra Newsletter
Iscriviti alla nostra newsletter per suggerimenti tecnici, recensioni, ebook gratuiti e offerte esclusive!
Clicca qui per iscriverti