Java -strømmer for nybegynnere: En introduksjon til bruk av strømmer i Java

Java 8 -strømmer lar utviklere trekke ut presise data fra en stor samling, ved hjelp av et sett med forhåndsdefinerte operasjoner.

Før utgivelsen av Java 8 vil bruk av begrepet 'strøm' i Java automatisk bli assosiert med I/O. Imidlertid introduserte Java 8 en strøm som kan refereres til som et sett med beregningstrinn som er lenket sammen i det som vanligvis kalles en 'strømrørledning'.

Denne artikkelen vil introdusere deg for Java 8 -strømmer og demonstrere hvordan de kan være nyttige i prosjektene dine.

Hva er en bekk?

En strøm er et Java -grensesnitt som tar en kilde, utfører et sett med operasjoner for å trekke ut spesifikke data, og deretter gir disse dataene til applikasjonen for bruk. I hovedsak lar den deg trekke ut spesialiserte data fra en samling av generaliserte data.

Hvordan strømmer fungerer

En strømrørledning begynner alltid med en kilde. Kildetypen er avhengig av typen data du har å gjøre med, men to av de mer populære er matriser og samlinger.

For å omdanne samlingen til en innledende strøm må du legge til strøm() funksjon til kilden. Dette vil plassere kilden i strømrørledningen hvor flere forskjellige mellomoperasjoner (for eksempel filter() og sortere() ) kan operere på den.

Etter at alle nødvendige mellomoperasjoner er utført, kan du innføre en terminaloperasjon (for eksempel for hver() ), som vil produsere de tidligere ekstraherte dataene fra kilden.

Livet uten bekker

Java 8 ble utgitt i 2014, men før det trengte Java -utviklere fremdeles å trekke ut spesialiserte data fra en samling generelle data.

hvordan koble bluetooth -hodetelefoner til xbox one s

La oss si at du har en liste over tilfeldige tegn som er kombinert med tilfeldige tall for å danne unike strengverdier, men du vil bare ha verdiene som starter med tegnet C, og du vil ordne resultatet i stigende rekkefølge. Slik vil du trekke ut dataene uten strømmer.

I slekt: Hva du trenger å vite om bruk av strenger i Java

Filtrering og sortering av verdier uten strømmer 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 må også deklarere og initialisere matriselisten enten du bruker strømmer eller en annen metode for ekstraksjon. Det du ikke trenger å gjøre hvis du bruker strømmer, er å deklarere en ny variabel for å holde de nødvendige verdiene, og heller ikke opprette de andre fem pluss kodelinjene i eksemplet ovenfor.

I slekt: Hvordan lage og utføre operasjoner på matriser i Java

Koden ovenfor gir følgende utgang i konsollen:

Livet med bekker

I programmering snakker effektivitet om å produsere det samme resultatet med betydelig mindre kode. Dette er nøyaktig hva en strømrørledning gjør for en programmerer. Så neste gang noen spør: hvorfor er det viktig å bruke bekker i prosjektet ditt? Enkelt sagt: bekker støtter effektiv programmering.

Fortsetter med vårt eksempel ovenfor, er dette hvordan innføring av strømmer transformerer hele programmet.

Filtrering og sortering av verdier 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 kraftig strømgrensesnittet er. Den tar en liste over tilfeldige matrisverdier og forvandler den til en strøm ved hjelp av strøm() funksjon. Strømmen reduseres deretter til en matriseliste som inneholder de nødvendige verdiene (som er alle verdiene som starter med C ), bruker filter() funksjon.

Som du kan se i eksemplet ovenfor, er C verdier er tilfeldig arrangert i matriselisten. Hvis du skulle skrive ut strømmen på dette tidspunktet i rørledningen, verdien C15 vil bli skrevet ut først. derfor sortere() funksjon blir introdusert til strømrørledningen for å omorganisere den nye matrisen i stigende rekkefølge.

Den siste funksjonen i strømrørledningen er a for hver() funksjon. Dette er en terminalfunksjon som brukes til å stoppe strømrørledningen og gir følgende resultater i konsollen:

Stream mellomliggende operasjoner

Det er en omfattende liste over mellomoperasjoner som kan brukes i en strømrørledning.

En strømrørledning starter alltid med en enkelt kilde og a strøm() funksjon, og ender alltid med en enkelt terminaloperasjon (selv om det er flere forskjellige å velge mellom.) Men mellom disse to seksjonene er en liste over seks mellomoperasjoner som du kan bruke.

I vårt eksempel ovenfor brukes bare to av disse mellomoperasjonene --- filter() og sortere() . Den mellomliggende operasjonen du velger vil avhenge av oppgavene du ønsker å utføre.

Hvis noen av verdiene som begynner med C i matriselisten ovenfor var små bokstaver, og vi utførte de samme mellomoperasjonene på dem, ville vi få følgende resultat.

Eksempel på filter- og sorteringsoperasjoner på små verdier

  
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 produsere følgende verdier i konsollen:

Det eneste problemet med utdataene ovenfor er at det ikke nøyaktig representerer alle C verdier i vår matriseliste. En god måte å fikse denne lille feilen på er å introdusere en annen mellomoperasjon til strømrørledningen; denne operasjonen er kjent som kart() funksjon.

Bruke eksempel på kartfunksjon

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

De kart() funksjon transformerer et objekt fra en tilstand til en annen; i vårt eksempel ovenfor forvandler det alle små tegn i matriselisten til store bokstaver.

Plassering av kart() fungerer like før filter() funksjon henter alle verdiene som begynner med C fra matriselisten.

Koden ovenfor gir følgende resultat i konsollen, og representerer alle C verdier i matriselisten.

De tre andre mellomoperasjonene du kan bruke i programmene dine inkluderer:

kikk ()
grense()
hopp over ()

Java 8 -strømmer letter opprettelsen av effektiv kode

Med Java 8 -strømmer kan du trekke ut ekstra spesifikke, relevante data fra en stor kilde med en kodelinje. Så lenge du tar med initialen strøm() funksjon og en terminaloperatør, kan du bruke en hvilken som helst kombinasjon av mellomoperasjoner som gir passende utganger for målet ditt.

hvordan du kan øke lagringsplassen på mac

Hvis du lurer på kodelinjen som er inkludert i vår filter() funksjon; det er kjent som et 'lambda -uttrykk'. Lambda -uttrykk er en annen funksjon som ble introdusert med Java 8, og den har mange nuggets som du kan synes er nyttige.

Dele Dele kvitring E -post En rask introduksjon til Java 8 Lambdas

Hvis du er en Java -programmerer og er interessert i å lære mer om Java 8 lambdas, vil vi i denne artikkelen se nærmere på lambda syntaks og bruk.

Les neste Relaterte temaer

Programmering
Java
Opplæringsprogrammer for koding

Om forfatteren Kadeisha Kean(21 artikler publisert)

Kadeisha Kean er en fullstabel programvareutvikler og teknisk/teknologisk skribent. Hun har den særegne evnen til å forenkle noen av de mest komplekse teknologiske konseptene; produsere materiale som lett kan forstås av enhver nybegynner i teknologi. Hun brenner for å skrive, utvikle interessant programvare og reise verden rundt (gjennom dokumentarer).

Mer fra Kadeisha Kean

Abonner på vårt nyhetsbrev

Bli med i vårt nyhetsbrev for tekniske tips, anmeldelser, gratis ebøker og eksklusive tilbud!

Klikk her for å abonnere