streamalism.org

1. Introduksjon

I denne raske opplæringen viser vi forskjellige måter å beregne summen av heltall,ved hjelp av Stream API.

For enkelhets skyld vil vi bruke heltall i eksemplene våre. Imidlertid kan vi bruke de samme metodene til lengsler og dobler også.

2. Bruke Stream.reduce ()

Stream.reduce () er en terminaloperasjon somutfører en reduksjon av elementene i strømmen.

Den bruker en binær operator (akkumulator) på hvert element i strømmen, der den første operanden er returverdien til den forrige applikasjonen, og den andre er det nåværende strømelementet.

I den første metoden for bruk av redusere() metode er akkumulatorfunksjonen et lambdauttrykk som legger til to Heltall verdier og returnerer en Heltall verdi:

Liste heltall = Arrays.asList (1, 2, 3, 4, 5); Heltalsum = heltall.strøm () .redusere (0, (a, b) -> a + b);

På samme måte kan vi bruke en allerede eksisterende Java-metode:

Liste heltall = Arrays.asList (1, 2, 3, 4, 5); Heltalsum = heltall.strøm () .reduser (0, Heltall :: sum);

Eller vi kan definere og bruke vår tilpassede metode:

offentlig klasse ArithmeticUtils {public static int add (int a, int b) {return a + b; }} 

Deretter kan vi overføre denne funksjonen som en parameter til redusere() metode:

Liste heltall = Arrays.asList (1, 2, 3, 4, 5); Heltalsum = heltall.strøm () .reduser (0, ArithmeticUtils :: add); 

3. Bruke Stream.collect ()

Den andre metoden for å beregne summen av en liste over heltall er å bruke samle inn() terminal drift:

Liste heltall = Arrays.asList (1, 2, 3, 4, 5); Heltalsum = heltall.strøm () .collect (Collectors.summingInt (Heltall :: intValue));

Tilsvarende Samlere klasse gir summingLong () og summingDouble () metoder for å beregne summen av henholdsvis lengde og dobler.

4. Bruke IntStream.sum ()

Stream API gir oss mapToInt () mellomdrift, som konverterer strømmen vår til en IntStream gjenstand.

Denne metoden tar en kartlegger som en parameter, som den bruker for å gjøre konverteringen, så kan vi kalle sum() metode for å beregne summen av strømens elementer.

La oss se et raskt eksempel på hvordan vi kan bruke det:

Liste heltall = Arrays.asList (1, 2, 3, 4, 5); Heltalsum = heltall.stream () .mapToInt (Heltall :: intValue) .sum ();

På samme måte kan vi bruke mapToLong () og mapToDouble () metoder for å beregne summen av henholdsvis lengde og dobler.

5. Bruke Stream # sum med Kart

For å beregne summen av verdiene til a Kart datastruktur, først lager vi en strøm fra verdiene av det Kart, så bruker vi en av metodene vi brukte tidligere.

For eksempel ved å bruke IntStream.sum ():

Heltalsum = map.values ​​() .stream () .mapToInt (Integer :: valueOf) .sum ();

6. Bruke Stream # sum med gjenstander

La oss forestille oss at vi har en liste over objekter og som vi ønsker å beregne summen av alle verdiene i et gitt felt av disse gjenstandene.

For eksempel:

public class Item {private int id; privat Heltallpris; public Item (int id, Integer price) {this.id = id; dette.pris = pris; } // Standard getters og setter} 

La oss forestille oss at vi vil beregne totalprisen på alle artiklene i følgende liste:

Item item1 = new Item (1, 10); Item item2 = new Item (2, 15); Item item3 = new Item (3, 25); Item item4 = new Item (4, 40); Listeelementer = Arrays.asList (item1, item2, item3, item4);

I dette tilfellet må vi kalle for å beregne summen ved hjelp av metodene som er vist i tidligere eksempler kart() metode for å konvertere strømmen vår til en strøm av heltall.

Som et resultat kan vi bruke Stream.reduce (), Stream.collect () og IntStream.sum () for å beregne summen:

Heltalsum = items.stream () .map (x -> x.getPrice ()) .reduce (0, ArithmeticUtils :: add); 

Heltalsum = items.stream () .map (x -> x.getPrice ()) .reduce (0, Integer :: sum);

Heltalsum = items.stream () .map (item -> item.getPrice ()) .reduce (0, (a, b) -> a + b);

Heltalsum = items.stream () .map (x -> x.getPrice ()) .collect (Collectors.summingInt (Heltall :: intValue));

items.stream () .mapToInt (x -> x.getPrice ()) .sum ();

7. Bruke Stream # sum med String

La oss anta at vi har en String objekt som inneholder noen heltall.

For å beregne summen av disse heltallene, trenger vi først og fremst å konvertere det String inn i en Array, da trenger vi for å filtrere ut elementene som ikke er heltall, og endelig, konverter de gjenværende elementene av den matrisen i tall.

La oss se alle disse trinnene i aksjon:

Strengstreng = "Vare1 10 Vare2 25 Vare3 30 Vare4 45"; Heltalsum = Arrays.stream (string.split ("")). Filter ((s) -> s.matches ("\ d +")) .mapToInt (Integer :: valueOf) .sum ();

8. Konklusjon

I denne veiledningen så vi flere metoder for å beregne summen av en liste over heltall ved hjelp av Stream API. Vi brukte også disse metodene for å beregne summen av verdiene til et gitt felt i en liste over objekter, summen av verdiene til et kart, samt tallene innenfor en gitt String gjenstand.

Som alltid er den komplette koden tilgjengelig på GitHub.