Stream ble introdusert i Java 8 Stream API brukes til å behandle samlinger av objekter. En strøm i Java er en sekvens av objekter som støtter ulike metoder som kan pipelineres for å produsere ønsket resultat. 

Bruk av Stream i Java

Bruken av Stream i Java er nevnt nedenfor:

• Stream API er en måte å uttrykke og behandle samlinger av objekter på.
• Gjør oss i stand til å utføre operasjoner som filtrering av kartlegging, reduksjon og sortering.

Hvordan lage en Java Stream

Java Stream Creation er et av de mest grunnleggende trinnene før du vurderer funksjonene til Java Stream. Nedenfor er syntaksen gitt for å deklarere en Java Stream.

numpy unik

Syntaks

Strømstrøm;

Her er T enten et klasseobjekt eller datatype avhengig av erklæringen.

Java Stream-funksjoner

Funksjonene til Java-strømmer er nevnt nedenfor:

• En strøm er ikke en datastruktur; den tar bare innspill fra Collections Arrays eller I/O-kanaler.
• Strømmer endrer ikke de opprinnelige dataene; de produserer kun resultater ved å bruke metodene deres.
• Mellomliggende operasjoner (som filterkart osv.) er late og returnerer en annen Stream slik at du kan lenke dem sammen.
• En terminaloperasjon (som collect forEach count) avslutter strømmen og gir det endelige resultatet.

Ulike operasjoner på strømmer

Det er to typer operasjoner i strømmer:

1. Mellomliggende operasjoner
2. Terminaldrift

Mellomliggende operasjoner

Mellomliggende operasjoner er typene operasjoner der flere metoder er lenket etter hverandre.

Kjennetegn på mellomoperasjoner

• Metoder er lenket sammen.
• Mellomoperasjoner forvandler en bekk til en annen strøm.
• Det muliggjør konseptet med filtrering der én metode filtrerer data og sender dem til en annen metode etter behandling.

Viktige mellomoperasjoner

Det er noen få mellomoperasjoner nevnt nedenfor:

1. kart() : Kartmetoden brukes til å returnere en strøm som består av resultatene av å bruke den gitte funksjonen på elementene i denne strømmen.

Syntaks:

Strømkart(Funksjonkartlegger)

2. filter() : Filtermetoden brukes til å velge elementer i henhold til predikatet som ble sendt som argument.

Syntaks:

Strømfilter(Predikatpredikat)

3. sortert() : Den sorterte metoden brukes til å sortere strømmen.

Syntaks:

Strømsortert()
Strømsortert(Komparatorkomparator)

4. flatMap(): FlatMap-operasjonen i Java Streams brukes til å flate ut en strøm av samlinger til en enkelt strøm av elementer.

Syntaks:

StrømflatMap(Funksjon> kartlegger)

5. distinkt() : Fjerner dupliserte elementer. Den returnerer en strøm som består av de distinkte elementene (i henhold til Object.equals(Object)).

Syntaks:

Strømdistinkt()

java med swing

6. kikk() : Utfører en handling på hvert element uten å endre strømmen. Den returnerer en strøm som består av elementene i denne strømmen som i tillegg utfører den angitte handlingen på hvert element etter hvert som elementene forbrukes fra den resulterende strømmen.

Syntaks:

Strømtitt (Forbrukerhandling)

Java-program som demonstrerer bruken av alle mellomoperasjonene:

import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.stream.Collectors; public class StreamIntermediateOperationsExample {  public static void main(String[] args) {  // List of lists of names  List<List<String>> listOfLists = Arrays.asList(  Arrays.asList('Reflection' 'Collection' 'Stream')  Arrays.asList('Structure' 'State' 'Flow')  Arrays.asList('Sorting' 'Mapping' 'Reduction' 'Stream')  );  // Create a set to hold intermediate results  Set<String> intermediateResults = new HashSet<>();  // Stream pipeline demonstrating various intermediate operations  List<String> result = listOfLists.stream()  .flatMap(List::stream)   .filter(s -> s.startsWith('S'))   .map(String::toUpperCase)   .distinct()   .sorted()   .peek(s -> intermediateResults.add(s))  .collect(Collectors.toList());   // Print the intermediate results  System.out.println('Intermediate Results:');  intermediateResults.forEach(System.out::println);  // Print the final result  System.out.println('Final Result:');  result.forEach(System.out::println);  } } 

Intermediate Results: STRUCTURE STREAM STATE SORTING Final Result: SORTING STATE STREAM STRUCTURE 

Forklaring:

• ListOfLists opprettes som en liste som inneholder andre lister med strenger.
• flatMap(Liste::stream): Flater sammen de nestede listene til en enkelt strøm av strenger.
• filter(er -> s.startsWith('S')) : Filtrerer strengene til bare å inkludere de som begynner med 'S'.
• map(String::toUpperCase) : Konverterer hver streng i strømmen til store bokstaver.
• distinkt() : Fjerner eventuelle dupliserte strenger.
• sortert() : Sorterer de resulterende strengene alfabetisk.
• kikk(...): Legger til hvert behandlet element til intermediateResults-settet for mellomliggende inspeksjon.
• collect(Collectors.toList()): Samler de endelig behandlede strengene til en liste kalt resultat.

Programmet skriver ut de mellomliggende resultatene som er lagret i settet for mellomresultater. Til slutt skriver den ut resultatlisten som inneholder de fullstendig behandlede strengene etter alle strømoperasjoner.

Terminaldrift

Terminaloperasjoner er typen operasjoner som returnerer resultatet. Disse operasjonene behandles ikke videre, bare returnerer en endelig resultatverdi.

Viktige terminaloperasjoner

1. samle() : Samlemetoden brukes til å returnere resultatet av mellomoperasjonene utført på strømmen.

Syntaks:

R collect(Collectorsamler)

2. forHver() : ForEach-metoden brukes til å iterere gjennom hvert element i strømmen.

Syntaks:

void forEach(Consumerhandling)

3. reduser(): Reduseringsmetoden brukes til å redusere elementene i en strøm til en enkelt verdi. Reduseringsmetoden tar en BinaryOperator som parameter.

Syntaks:

T reduser(T identitet BinaryOperatorakkumulator)
Valgfriredusere(BinaryOperatorakkumulator)

4. telle() : Returnerer antallet elementer i strømmen.

Syntaks:

lang telling()

5. findFirst() : Returnerer det første elementet i strømmen hvis det finnes.

Syntaks:

ValgfrifindFirst()

js global variabel

6. allMatch() : Sjekker om alle elementene i strømmen samsvarer med et gitt predikat.

Syntaks:

boolsk allMatch(Predikatpredikat)

7. Anymatch () : Sjekker om noe element i strømmen samsvarer med et gitt predikat.

Syntaks:

Boolsk Anymatch (Predikatpredikat)

Her er ans variabel tildelt 0 som startverdi og i legges til den.

Note: Intermediate Operations kjører basert på konseptet Lazy Evaluation som sikrer at hver metode returnerer en fast verdi (Terminal-operasjon) før du går til neste metode.

Java-program som bruker alle terminaloperasjoner:

import java.util.*; import java.util.stream.Collectors; public class StreamTerminalOperationsExample {  public static void main(String[] args) {  // Sample data  List<String> names = Arrays.asList(  'Reflection' 'Collection' 'Stream'  'Structure' 'Sorting' 'State'  );  // forEach: Print each name  System.out.println('forEach:');  names.stream().forEach(System.out::println);  // collect: Collect names starting with 'S' into a list  List<String> sNames = names.stream()  .filter(name -> name.startsWith('S'))  .collect(Collectors.toList());  System.out.println('ncollect (names starting with 'S'):');  sNames.forEach(System.out::println);  // reduce: Concatenate all names into a single string  String concatenatedNames = names.stream().reduce(  ''  (partialString element) -> partialString + ' ' + element  );  System.out.println('nreduce (concatenated names):');  System.out.println(concatenatedNames.trim());  // count: Count the number of names  long count = names.stream().count();  System.out.println('ncount:');  System.out.println(count);  // findFirst: Find the first name  Optional<String> firstName = names.stream().findFirst();  System.out.println('nfindFirst:');  firstName.ifPresent(System.out::println);  // allMatch: Check if all names start with 'S'  boolean allStartWithS = names.stream().allMatch(  name -> name.startsWith('S')  );  System.out.println('nallMatch (all start with 'S'):');  System.out.println(allStartWithS);  // anyMatch: Check if any name starts with 'S'  boolean anyStartWithS = names.stream().anyMatch(  name -> name.startsWith('S')  );  System.out.println('nanyMatch (any start with 'S'):');  System.out.println(anyStartWithS);  } } 

Produksjon:

Forklaring:

• Navnelisten opprettes med eksempelstrenger.
• for hver: Skriver ut hvert navn i listen.
• samle : Filtrerer navn som begynner med 'S' og samler dem inn i en ny liste.
• redusere : Sammenslår alle navn til en enkelt streng.
• telle : Teller totalt antall navn.
• finn først : Finner og skriver ut fornavnet i listen.
• allMatch : Sjekker om alle navn begynner med 'S'.
• uheldig : Sjekker om et navn begynner med 'S'.

Programmet skriver ut navn på hvert navn som starter med 'S' sammenkoblede navn, antall navn, fornavn, enten alle navn starter med 'S' og om et navn begynner med 'S'.

Fordelen med Java Stream

Det er noen fordeler som vi bruker Stream i Java som nevnt nedenfor:

• Ingen lagring
• Pipeline av funksjoner
• Latskap
• Kan være uendelig
• Kan parallelliseres
• Kan opprettes fra samlingsarrayer Filer Linjer Metoder i Stream IntStream etc.

Real-World Use Cases av Java Streams

Strømmer er mye brukt i moderne Java-applikasjoner for:

• Databehandling
• For behandling av JSON/XML-svar
• For databaseoperasjoner
• Samtidig behandling