Java Stream Collector

Java -strømmen er en kildes sekvens av elementer som tillater samlede operasjoner. Elementene i strømmer beregnes etter behov, men de er ikke lagret. På den annen side har JDK Utility -klassen samlerklassen som har andre grunnleggende metoder. Samlerklassen har forhåndskonfigurerte samlere for å utføre de typiske mutable reduksjonsoppgavene. Strøms samlergruppeelementer, basert på en tilstand, reduserer elementene til en enkelt verdi (som Min, Max, Count eller Total) eller akkumulerer elementene i samlinger. Samlerklassen er inkludert i strømklassen, slik at den kan kalles på en strøm etter å ha utført en hvilken som helst filtrerings- eller kartleggingsoperasjon. Det tar en samler å legge elementene fra strømmen til en utpekt samling.

Eksempel 1:

Collect () -metoden brukes til å generere listen i følgende eksempel. Samlerimplementeringen som oppretter en ny liste fra inngangselementene, returneres av samlerne.tolist () -metode.

Importer Java.util.strøm.Samlere;
Importer Java.util.Liste;
Importer Java.util.ArrayList;
klasse parfyme
int pid;
Streng pname;
FLOAT PPRICE;
offentlig parfyme (int pid, streng pname, float pprice)
dette.PID = PID;
dette.PNAME = PNAME;
dette.pPrice = pprice;


offentlige klasse samlere1
public static void main (String [] args)
ListPerFumesList = new ArrayList ();
PerfumesList.Legg til (ny parfyme (1, "Garden of Roses.", 5000F));
PerfumesList.Legg til (ny parfyme (2, "Earthy Wonderland", 4000F));
PerfumesList.Legg til (ny parfyme (3, "Berry Mellow.", 18000f));
ListPerFumesPricelist =
PerfumesList.strøm()
.Kart (i-> i.pprice)
.samle (samlere.ramse opp());
System.ute.Println (PerfumesPricelist);

Vi definerer en "parfymer" -klasse der attributtene er erklært som "pname", "pid" og "pprice". Deretter kaller vi disse attributtene inne i konstruktøren av "parfymer" -funksjonen som en parameter og gir en henvisning til gjeldende attributter i denne funksjonen ved å bruke "dette" nøkkelordet. Etter dette konstruerer vi "Collector1" hovedklassen i programmet der hovedprogrammet for dette eksemplet er distribuert. Her setter vi listegrensesnittet for "parfymer" -klassen for å opprette listen i den deklarerte "parfymerlist" -variabelen. Listen inkluderer de forskjellige verdiene for parfyme -ID, navn og pris som er lagt til via add () -funksjon. Deretter genererer vi "PerfumePricelist" -listen der "Perfumelist" kalles med Stream () -metoden for å generere strømmen av parfymeverdier. Etter det bruker vi MAP () -metoden for å få prislisten over parfymer. Collect -klassen er distribuert som tar samlerne.Tolist () for å samle prisene på parfymerlisten og skrive ut listen som bare inneholder prisene.

Prislisten over klassens parfymer hentes ved hjelp av samlerne.tolist () -metode.

Eksempel 2:

Java Collector -klassen gir forskjellige operasjoner for reduksjon. Java Collector -klassen er brukt til å kombinere de flere elementene i et tegn eller strenggruppe i et spesifikt objekt. Denne teknikken oppnår dette via strømmen. Samlerklassen inkluderer flere sammenføyning av metode.

Importer Java.util.Liste;
Importer Java.util.strøm.Samlere;
Offentlige klasse samlere2
public static void main (String [] args)
var my venners = liste.av ("William", "James", "Noah", "Oliver",
"Lucas", "Liam", "Benjamin");
var joinlist = My Friends.strøm().samle (samlere.bli med (","));
System.ute.printf ("Ble in String List: %s", joinlist);

Vi har en variabel erklæring "MyFriends" som kalles listen.av () metode for å ha en enkel uforanderlig implementering av listeklassen. Listen er utstyrt med de forskjellige strengelementene. Etter det erklærer vi en "JoinList" -variabel som først oppretter strømmen av "My Friends" -listen. Deretter påkaller Collect () -metoden Collectors Joining () -metoden. Samlerne.sammenføyning () -metoden blir med på listen i form av en streng ved hjelp av komma "", som blir gitt som et argument. Den sammenføyede listen over strengen skrives deretter ut på konsollen.

Utgangen som viser den spesifiserte listen er forbundet med samlerne.sammenføyet () -metode.

Eksempel 3:

Den statiske metoden for samlerklassen SummarizingInt () Returnerer statistikken over resultatene oppnådd etter at et sett med inngangsverdier er gitt til den oppgitte TOINTFunction () implementeringen.

Importer Java.util.Matriser;
Importer Java.util.Insummarystatistics;
Importer Java.util.Liste;
Importer Java.util.strøm.Samlere;
Importer Java.util.strøm.Strøm;
offentlig klasse samlere3
public static void main (String [] args)

ListNumList = Arrays.ASList (13, 25, 18, 18);
System.ute.println ("nummer ist -" + numlist);
StreamNumStream = numlist.strøm();
IntSummaryStatisticsNumSummary = numstream.samle (samlere.OppsummeringInt (i -> i));
System.ute.Println ("Number Stream Summary Statistics -" + numsummary);

Vi erklærer listen "numlist" -klasseobjekt der utvalget av heltall listen er spesifisert ved hjelp av ASList () -metoden. Listen over heltallsarray vises med utskriftserklæringen. Etter dette oppretter vi strømmen av den liste -arrayen ved å påkalle strømmen () -metoden med "numlist" i "numstream" -variabelen til strømklassen. Deretter kaller vi IntSummaryStatistics -klassen og erklærer "NumSummary" -objektet der Collect () -metoden får sammendraget av matriselisten fra SummarizingInt () -metoden og utskrifter som sammendrag av utførelsen av programmet.

Den statistiske sammendraget av den forrige array -listen vises i det følgende. Det gir summen, minimumsverdien, maksimal verdi og gjennomsnittsverdi.

Eksempel 4:

Javas GroupingBy () -metode i samlerklassen brukes til å gruppere elementene i henhold til et attributt og lagre dataene i et kartobjekt. Dessuten kan de totale elementene som er gitt som en parameter i strømmen også telles ved hjelp av telling () -metoden til samlere som sendes innenfor gruppen () -metoden. Funksjonen returnerer en samler som godtar varene av Type T og samler antall innkommende elementer. Resultatet fra telling () -metoden er null hvis det ikke er noen elementer.

Importer Java.util.Matriser;
Importer Java.util.Liste;
Importer Java.util.Kart;
Importer Java.util.funksjon.Funksjon;
Importer Java.util.strøm.Samlere;
offentlige klasse samlere4
public static void main (String [] args)
Liste byer =
Matriser.ASList ("Phoenix", "Houston",
"New York", "Phoenix", "San Diego", "Houston");
MapMyMap =
Byer.strøm().samle inn(
Samlere.GroupingBy (
Funksjon.identitet (), samlere.telling ()));
System.ute.println (MyMap);

Vi oppretter matriselisten med ASList () -metoden og setter inn navnene på unike og gjentatte byer. Denne listen er erklært i "byer" -variabelen i listeklassen. Etter det har vi et kartgrensesnitt som erklærer “MyMap” -objektet. Gjennom dette kartgrensesnittet får vi strømmen av medfølgende liste. Deretter bruker vi Collect () -metoden som videre bruker Collector Class GroupingBy () -metoden. GroupingBy () metodegrupper elementene på listen ved først å identifisere dem ved å bruke funksjonen.Identifiser () Metode. Deretter teller det antall gitte elementer som bruker telling () -metoden i samlerklassen. De grupperte elementene etter behandling gjennom Collector Class -metodene vises av utskriftserklæringen.

Følgende liste er formen til gruppen. Elementet som gjentas i listen er gruppert med verdien av “2”. Enkeltelementet har verdien av “1”.

Eksempel 5:

Collectors -klassen inneholder en annen metodedefinisjon for CollectingOndthen (). Den statiske samlingen og () -metoden i samlerklassen produserer først resultatene av samlerens drift. Deretter utføres den andre ekstra etterbehandlingstransformasjonen.

Importer Java.util.Samlinger;
Importer Java.util.Liste;
Importer Java.util.strøm.Samlere;
Importer Java.util.strøm.Strøm;
offentlige klasse samlere5
public static void main (String [] args)
StreamStreamElements = Stream.av ("en", "to", "tre");
ListSynClist = StreamElements.samle (samlere.samler og (
Samlere.Tolist (), Collections :: SynchronizedList));
System.ute.println (synklist);

Strømmen av strengen er definert i "streamelements" -variabelen til strømklassen. Vi gir deretter "Synclist" -listeobjektet for listesynkronisering. Samlemetoden brukes på "streamelements" -strømmen. Collect () -metoden inkluderer CollectingAndThen () -metoden som videreføres med Tolist () -metoden. Vi krever imidlertid en uforanderlig liste. Så vi bruker ModifiableSet () -metoden på den genererte listen for å returnere en umodifiserbar representasjon av listen. Deretter skriver vi ut den umodifiserbare listen til konsollen.

Den forrige programutgangen utføres i følgende Java -konsollbilde:

Konklusjon

Java Stream Collect () -metoden brukes hovedsakelig for å legge strømelementene til samlinger. Elementene i strømmen blir behandlet til en skiftende reduksjonsprosedyre. Både sekvensielle og samtidige reduksjonsprosesser er mulig. Når det gjelder en parallell strøm, håndterer den synkronisering. Samlerklassen tilbyr mange samlerimplementeringer for å hjelpe oss. Noen få av metodene fra samlerklassen implementeres i denne artikkelen.