Java Streams for begyndere: En introduktion til brug af streams i Java

Java 8 -streams giver udviklere mulighed for at udtrække præcise data fra en stor samling ved hjælp af et sæt foruddefinerede operationer.

Før udgivelsen af Java 8 ville brug af udtrykket 'stream' i Java automatisk blive forbundet med I/O. Imidlertid introducerede Java 8 en strøm, der kan betegnes som et sæt beregningstrin, der er kædet sammen i det, der almindeligvis kaldes en 'stream -pipeline'.

Denne artikel vil introducere dig til Java 8 -streams og demonstrere, hvordan de kan være nyttige i dine projekter.

Hvad er en strøm?

En strøm er en Java -grænseflade, der tager en kilde, udfører et sæt operationer for at udtrække specifikke data og derefter leverer disse data til applikationen til brug. I det væsentlige giver det dig mulighed for at udtrække specialiserede data fra en samling af generaliserede data.

Sådan fungerer streams

En strømpipeline begynder altid med en kilde. Kildetypen afhænger af den type data, du har at gøre med, men to af de mere populære er arrays og samlinger.

For at omdanne samlingen til en indledende strøm skal du tilføje strøm() funktion til kilden. Dette vil placere kilden i strømrørledningen, hvor flere forskellige mellemliggende operationer (f.eks filter() og sortere() ) kan operere på det.

Når alle de nødvendige mellemoperationer er udført, kan du indføre en terminaloperation (f.eks for hver() ), som vil producere de tidligere ekstraherede data fra kilden.

Livet uden vandløb

Java 8 blev udgivet i 2014, men før det havde Java -udviklere stadig brug for at udtrække specialiserede data fra en samling af generelle data.

hvordan kan jeg se, om nogen blokerede mig på snapchat

Lad os sige, at du har en liste over tilfældige tegn, der kombineres med tilfældige tal for at danne unikke strengværdier, men du vil kun have de værdier, der starter med tegnet C, og du vil arrangere resultatet i stigende rækkefølge. Sådan vil du udtrække disse data uden streams.

Relaterede: Hvad du behøver at vide om brug af strenge i Java

Filtrering og sortering af værdier uden strømme Eksempel

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

Du skal også deklarere og initialisere arraylisten, uanset om du bruger streams eller en anden metode til ekstraktion. Det, du ikke skulle gøre, hvis du brugte streams, er at erklære en ny variabel for at indeholde de krævede værdier og heller ikke oprette de andre fem pluslinjer kode i eksemplet ovenfor.

Relaterede: Sådan oprettes og udføres operationer på arrays i Java

Koden ovenfor producerer følgende output i konsollen:

Livet med vandløb

I programmering taler effektivitet om at producere det samme resultat med betydeligt mindre kode. Dette er præcis, hvad en stream -pipeline gør for en programmør. Så næste gang nogen spørger: hvorfor er det vigtigt at bruge streams i dit projekt? Kort sagt: streams understøtter effektiv programmering.

Fortsat med vores eksempel ovenfor, er det sådan, at introduktion af streams transformerer hele programmet.

Filtrering og sortering af værdier med et strømeksempel

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

Koden ovenfor viser, hvor kraftfuld stream -grænsefladen er. Det tager en liste over tilfældige arrayværdier og omdanner det til en strøm ved hjælp af strøm() fungere. Strømmen reduceres derefter til en matrixliste, der indeholder de nødvendige værdier (som er alle værdierne, der starter med C ), bruger filter() fungere.

Som du kan se i eksemplet ovenfor, er C værdier er tilfældigt arrangeret i matrixlisten. Hvis du skulle udskrive strømmen på dette tidspunkt i rørledningen, værdien C15 ville blive udskrevet først. Derfor er sortere() funktion introduceres til strømrørledningen for at omarrangere det nye array i stigende rækkefølge.

Den sidste funktion i strømrørledningen er a for hver() fungere. Dette er en terminalfunktion, der bruges til at stoppe stream -rørledningen og producerer følgende resultater i konsollen:

Stream mellemliggende operationer

Der er en omfattende liste over mellemliggende operationer, der kan bruges i en stream pipeline.

En strømpipeline starter altid med en enkelt kilde og a strøm() funktion, og slutter altid med en enkelt terminaloperation (selvom der er flere forskellige at vælge imellem.) Men mellem disse to sektioner er der en liste over seks mellemliggende operationer, som du kan bruge.

I vores eksempel ovenfor bruges kun to af disse mellemliggende operationer --- filter() og sortere() . Den mellemliggende operation, du vælger, afhænger af de opgaver, du ønsker at udføre.

Hvis nogen af de værdier, der begynder med C i vores array -liste ovenfor, var små, og vi udførte de samme mellemoperationer på dem, ville vi få følgende resultat.

Eksempel på filter- og sorteringsoperationer på små værdier

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

Koden ovenfor vil producere følgende værdier i konsollen:

Det eneste problem med outputtet ovenfor er, at det ikke præcist repræsenterer alle C værdier i vores array -liste. En god måde at rette denne lille fejl på er at introducere en anden mellemliggende operation til strømpipelinen; denne operation er kendt som kort() fungere.

Brug af eksempel på kortfunktion

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

Det kort() funktion transformerer et objekt fra en tilstand til en anden; i vores eksempel ovenfor omdanner det alle små tegn i matrixlisten til store bogstaver.

Placering af kort() funktion lige før filter() funktion henter alle de værdier, der begynder med C fra matrixlisten.

Koden ovenfor producerer følgende resultat i konsollen og repræsenterer alle de C værdier i matrixlisten.

De andre tre mellemliggende operationer, som du kan bruge i dine applikationer, omfatter:

kig ()
begrænse()
springe()

Java 8 -streams letter oprettelsen af effektiv kode

Med Java 8 -streams kan du udtrække ekstra specifikke, relevante data fra en stor kilde med en kodelinje. Så længe du medtager initialen strøm() funktion og en terminaloperatør, kan du bruge enhver kombination af mellemliggende operationer, der giver passende output til dit mål.

hvordan man kan se en livestream på facebook

Hvis du undrer dig over kodelinjen indeholdt i vores filter() fungere; det er kendt som et 'lambda -udtryk'. Lambda -udtryk er en anden funktion, der blev introduceret med Java 8, og den har en masse nuggets, som du kan finde nyttige.

Del Del Tweet E -mail En hurtig introduktion til Java 8 Lambdas

Hvis du er en Java -programmør, og du er interesseret i at lære mere om Java 8 lambdas, vil vi i denne artikel se nærmere på lambda syntaks og brug.

Læs Næste Relaterede emner

Programmering
Java
Kodning Tutorials

Om forfatteren Kadeisha Kean(21 artikler udgivet)

Kadeisha Kean er en softwareudvikler i fuld stak og teknisk/teknologisk forfatter. Hun har den særlige evne til at forenkle nogle af de mest komplekse teknologiske begreber; producerer materiale, der let kan forstås af enhver nybegynder i teknologi. Hun brænder for at skrive, udvikle interessant software og rejse rundt i verden (gennem dokumentarer).

Mere fra Kadeisha Kean

Abonner på vores nyhedsbrev

Tilmeld dig vores nyhedsbrev for at få tekniske tips, anmeldelser, gratis e -bøger og eksklusive tilbud!

Klik her for at abonnere