Collezionista Java Stream

Il flusso Java è una sequenza di elementi della fonte che consente operazioni aggregate. Gli elementi nei flussi sono calcolati come richiesto ma non sono archiviati. D'altra parte, la classe Utility JDK ha la classe Collector che ha altri metodi fondamentali. La classe Collectors ha collezionisti preconfigurati per svolgere le tipiche attività di riduzione mutabile. Gli elementi del gruppo di collettori di flusso, basati su una condizione, riducono gli elementi a un singolo valore (come min, max, conteggio o totale) o accumulano gli elementi in raccolte. La classe Collectors è inclusa nella classe di flusso in modo che possa essere chiamata su un flusso dopo aver eseguito qualsiasi operazione di filtraggio o mappatura. Ci vuole un collezionista per aggiungere gli elementi dal flusso a una collezione designata.

Esempio 1:

Il metodo Collect () viene utilizzato per generare l'elenco nel seguente esempio. L'implementazione del collettore che crea un nuovo elenco dagli elementi di input viene restituita dai collezionisti.Metodo Tolist ().

Importa Java.util.flusso.Collezionisti;
Importa Java.util.Elenco;
Importa Java.util.Lista di array;
Profume di classe
int pid;
String pname;
fluttuare pprice;
public profumo (int pid, string pname, float pprice)
Questo.pid = pid;
Questo.pname = pname;
Questo.pprice = pprice;


collezionisti di classe pubblica1
public static void main (string [] args)
ListPerFumesList = new ArrayList ();
Profumeslist.Aggiungi (nuovo profumo (1, "Garden of Roses.", 5000f));
Profumeslist.Aggiungi (nuovo profumo (2, "terreno terrestre", 4000f));
Profumeslist.Aggiungi (nuovo profumo (3, "Berry Mellow.", 18000f));
ListPerFumesPricelist =
Profumeslist.flusso()
.mappa (i-> i.pprice)
.Raccogli (collezionisti.elencare());
Sistema.fuori.println (profumespricelist);

Definiamo una classe "profumi" in cui i suoi attributi sono dichiarati come "pname", "pid" e "pprice". Quindi, chiamiamo questi attributi all'interno del costruttore della funzione "profumi" come parametro e diamo un riferimento agli attributi correnti in questa funzione usando la parola chiave "questa". Successivamente, costruiamo la classe principale "Collector1" del programma in cui viene distribuito il programma principale di questo esempio. Qui, impostiamo l'interfaccia dell'elenco per la classe "profumi" per creare l'elenco nella variabile "profumeslist" dichiarata. L'elenco include i diversi valori per l'ID, il nome e il prezzo del profumo che vengono aggiunti tramite Add (). Successivamente, generiamo l'elenco "profumopricelista" in cui il "profumelista" viene chiamato con il metodo Stream () per generare il flusso di valori di profumo. Successivamente, utilizziamo il metodo Map () per ottenere il listino dei prezzi dei profumi. La classe di raccolta viene distribuita che prende i collezionisti.tolist () per raccogliere i prezzi dell'elenco dei profumi e stampare quell'elenco che contiene solo i prezzi.

Il listino dei prezzi dei profumi di classe viene recuperato usando i collezionisti.Metodo Tolist ().

Esempio 2:

La classe Java Collector offre operazioni diverse per la riduzione. Il metodo di giunzione () della classe collezionista Java viene utilizzato per combinare i vari elementi di un carattere o un array di stringhe in un oggetto specifico. Questa tecnica lo realizza attraverso il flusso. La classe Collector include diversi sovraccarichi del metodo di giunzione.

Importa Java.util.Elenco;
Importa Java.util.flusso.Collezionisti;
collezionisti di classe pubblica 2
public static void main (string [] args)
VAR MYFriends = elenco.di ("William", "James", "Noah", "Oliver",
"Lucas", "Liam", "Benjamin");
var joinlist = myfriends.flusso().Raccogli (collezionisti.unirsi a (","));
Sistema.fuori.printf ("elenco di stringhe unite: %s", joinlist);

Abbiamo una Dichiarazione variabile "MyFriends" che si chiama elenco.di () metodo per avere una semplice implementazione immutabile della classe di elenco. L'elenco è fornito con i diversi elementi della stringa. Successivamente, dichiariamo una variabile "joinlist" che crea prima il flusso dell'elenco "MyFriends". Quindi, il metodo Collect () invoca il metodo dei collezionisti (). I collezionisti.Il metodo di joining () si unisce all'elenco sotto forma di una stringa usando la virgola ", che viene superata come argomento. L'elenco unito della stringa viene quindi stampato sulla console.

L'output che mostra l'elenco specificato è unita dai collezionisti.Metodo uniti ().

Esempio 3:

Il metodo statico della classe dei collezionisti SummazingInT () restituisce le statistiche dei risultati ottenuti dopo che un insieme di valori di input è stato dato all'implementazione fornita da TOintFunction ().

Importa Java.util.Array;
Importa Java.util.Intsummarystatistics;
Importa Java.util.Elenco;
Importa Java.util.flusso.Collezionisti;
Importa Java.util.flusso.Flusso;
collezionisti di classe pubblica 3
public static void main (string [] args)

ListNumList = array.Aslist (13, 25, 18, 18);
Sistema.fuori.println ("numero ist -" + numlist);
StreamNumStream = numlist.flusso();
InsummaryStatisticsNumsummary = numstream.Raccogli (collezionisti.riassumizingInt (i -> i));
Sistema.fuori.println ("Statistiche di riepilogo del flusso di numeri -" + numsummary);

Dichiariamo l'elenco Oggetto di classe "Numlist" in cui è specificato l'elenco di array di numeri interi utilizzando il metodo Aslist (). L'elenco dell'array interi viene visualizzato con l'istruzione di stampa. Successivamente, creiamo il flusso di quell'array di elenco invocando il metodo Stream () con il "numlist" nella variabile "numstream" della classe di flusso. Successivamente, chiamiamo la classe IntSummaryStatistics e dichiariamo l'oggetto "numsummary" in cui il metodo collection () ottiene il riepilogo dell'elenco di array dal metodo SummazingInT () e stampa quel riepilogo all'esecuzione del programma.

Il riepilogo statistico dell'elenco di array precedente viene visualizzato nel seguente. Emette la somma, il valore minimo, il valore massimo e il valore medio.

Esempio 4:

Il metodo Groupingby () di Java's GroupBy () viene utilizzato per raggruppare gli articoli in base a un attributo e archiviare i dati in un oggetto MAP. Inoltre, gli elementi totali che vengono dati come parametro nel flusso possono anche essere contati usando il metodo di conteggio () dei collezionisti che viene passato all'interno del metodo GroupingBy (). La funzione restituisce un collettore che accetta gli elementi di tipo T e raccoglie il numero di elementi in arrivo. Il risultato dal metodo di conteggio () è zero se non ci sono elementi.

Importa Java.util.Array;
Importa Java.util.Elenco;
Importa Java.util.Carta geografica;
Importa Java.util.funzione.Funzione;
Importa Java.util.flusso.Collezionisti;
collezionisti di classe pubblica 4
public static void main (string [] args)
Elenca le città =
Array.Aslist ("Phoenix", "Houston",
"New York", "Phoenix", "San Diego", "Houston");
MapMyMap =
Città.flusso().raccogliere(
Collezionisti.raggruppamento (
Funzione.Identity (), collezionisti.conteggio()));
Sistema.fuori.println (mymap);

Creiamo l'elenco di array con il metodo Aslist () e inseriamo i nomi di città univoci e ripetute. Questo elenco è dichiarato nella variabile "Cities" della classe di elenco. Successivamente, abbiamo un'interfaccia mappa che dichiara l'oggetto "mymap". Attraverso questa interfaccia mappa, otteniamo il flusso dell'elenco fornito. Quindi, utilizziamo il metodo Collect () che impiega ulteriormente il metodo GroupBy () Classe Collector (). Il metodo GroupingBy () raggruppa gli elementi dell'elenco identificandoli prima usando la funzione.Identifica () metodo. Quindi, conta il numero di elementi dati usando il metodo di conteggio () della classe collezionista. Gli elementi raggruppati dopo l'elaborazione tramite i metodi di classe collettore sono visualizzati dall'istruzione di stampa.

Il seguente elenco è la forma del gruppo. L'elemento che viene ripetuto nell'elenco è raggruppato con il valore di "2". Il singolo elemento ha il valore di "1".

Esempio 5:

La classe Collectors contiene un'altra definizione di metodo per il collezionismo e il resto (). Il metodo statico di raccolta e il metodo della classe collezionista produce per la prima volta i risultati del funzionamento del collettore. Quindi, viene eseguita l'altra trasformazione di finitura aggiuntiva.

Importa Java.util.Collezioni;
Importa Java.util.Elenco;
Importa Java.util.flusso.Collezionisti;
Importa Java.util.flusso.Flusso;
collezionisti di classe pubblica5
public static void main (string [] args)
StreamStreamElements = Stream.di ("one", "due", "tre");
ListSynclist = flusso.Raccogli (collezionisti.Collezionamento e3
Collezionisti.tolist (), collezioni :: synchronizedlist));
Sistema.fuori.println (sinclist);

Il flusso della stringa è definito nella variabile "streamelements" della classe di flusso. Forniamo quindi l'oggetto elenco "Syncrist" per la sincronizzazione dell'elenco. Il metodo di raccolta viene applicato al flusso di "streamelements". Il metodo Collect () include il metodo Collecting andthen () che viene ulteriormente utilizzato con il metodo Tolist (). Tuttavia, abbiamo bisogno di un elenco immutabile. Pertanto, utilizziamo il metodo non modifiableceSet () nell'elenco generato per restituire una rappresentazione non modificabile dell'elenco. Quindi, stampiamo l'elenco non modificabile sulla console.

L'output del programma precedente viene eseguito nella seguente immagine della console Java:

Conclusione

Il metodo Java Stream Collect () viene utilizzato principalmente per aggiungere gli elementi del flusso alle raccolte. Gli articoli nel flusso vengono elaborati in una procedura di riduzione modificabile. Sono possibili processi di riduzione sia sequenziali che simultanei. Nel caso di un flusso parallelo, gestisce la sincronizzazione. La classe Collectors offre numerose implementazioni di collezionisti per aiutarci. Alcuni dei metodi della classe Collector sono implementati in questo articolo.