Stream Collectors er en kraftig funksjon i Java 8 Stream API som lar deg samle inn og behandle data effektivt. Her forklarer vi strukturen deres og hvordan Java collect()-metoden kan brukes.

Hvordan kan Java collect() brukes?

En strømkollektor kan brukes til å opprette en liste, et sett eller et kart fra en strøm. En strøm er en sekvens av elementer som behandles etter hverandre. Kollektorgrensesnittet tilbyr et sett med reduksjonsoperasjoner for data i en strømrørledning. Dette er terminale operasjoner som samler og slår sammen resultatene fra mellomtrinnene.

Collectors kan brukes til å filtrere eller sortere objekter fra en strøm. Aggregering er også mulig, for eksempel å summere tall, kombinere strenger eller telle elementer. I tillegg har Collectors funksjoner som kan transformere innholdet i en strøm til en bestemt struktur. Du kan for eksempel transformere en liste til et kart. Grupperinger hjelper med å kategorisere elementer med bestemte egenskaper eller betingelser. Det viktigste er at strømkollektorer har fordelen at de kan behandle data samtidig ved hjelp av flere tråder. Dette gjør at operasjoner kan utføres mye raskere og mer effektivt, spesielt med store datamengder.

Hva er syntaksen for Java collect()?

Metoden aksepterer en Collector som beskriver hvordan elementene i strømmen skal samles og aggregeres som et argument. En Collector er et grensesnitt som tilbyr ulike metoder for å aggregere strømelementer til en bestemt form, for eksempel til en liste, et sett eller et kart.

Det finnes to varianter av Java Stream-metoden collect():

  1. R collect(Supplier<R> leverandør, BiConsumer<R, ? super T> akkumulator, BiConsumer<R, R> kombiner)
  2. <R, A> R collect(Collector<? super T, A, R> collector)

Den første varianten har tre funksjoner som argumenter:

  • leverandør: oppretter en beholder som skal brukes til mellomresultater
  • akkumulator: beregner det endelige resultatet
  • kombinator: kombinerer resultatene av parallelle strømoperasjoner

Disse forhåndsdefinerte samlerne er allerede inkludert i standardbiblioteket og kan enkelt importeres og brukes.

Den andre varianten aksepterer en Collector som argument og returnerer et resultat.

  • R: typen resultat
  • T: typen elementer i strømmen
  • A: typen akkumulator som lagrer den mellomliggende tilstanden til samleroperasjonen
  • samler: utfører reduksjonsoperasjonen.

Ved å bruke denne varianten kan utviklere lage tilpassede Collectors som er spesielt tilpasset deres behov og gir større fleksibilitet og kontroll over reduksjonsprosessen.

Hva er praktiske eksempler på bruk av Java collect()?

Nedenfor illustrerer vi ulike funksjoner i Stream.collect(). Du bør allerede være kjent med de grunnleggende Java-operatorene før du går videre til samlingsrammeverket.

Sammenføy en liste med strenger

Med Java Collect() kan vi sammenføye en liste med strenger for å få en ny streng:

List<String> letters = List.of("a", "b", "c", "d", "e");
// without combiner function
StringBuilder result = letters.stream().collect(StringBuilder::new, (x, y) -> x.append(y),
    (a, b) -> a.append(",").append(b));
System.out.println(result.toString());
// with combiner function
StringBuilder result1 = letters.parallelStream().collect(StringBuilder::new, (x, y) -> x.append(y),
    (a, b) -> a.append(",").append(b));
System.out.println(result1.toString());
Java

Resultatet er:

abcde
a, b, c, d, e
Java

I den første beregningen ble det bare brukt én StringBuilder-instans, og det var ingen kombineringsfunksjon. Derfor er resultatet abcde.

I den andre utdataen slo kombineringsfunksjonen sammen StringBuilder-instansene og skilte dem med komma.

Samle elementer i en liste med toList()

Vi kan bruke funksjonen filter() til å velge ut bestemte elementer i en liste og deretter bruke toList() til å lagre dem i en ny liste.

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);
List<Integer> oddNumbers = numbers.stream().filter(x -> x % 2 != 0).collect(Collectors.toList());
System.out.println(oddNumbers);
Java

I den nye listen er det bare oddetall:

[1, 3, 5, 7]
Java

Samle elementer i et sett med toSet()

På samme måte kan vi velge elementer og lage et nytt sett av dem. Elementene i et sett trenger ikke å være ordnet i en bestemt rekkefølge.

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);
Set<Integer> evenNumbers = numbers.parallelStream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
System.out.println(evenNumbers);
Java

Dette viser utdataene:

[2, 4, 6]
Java

Samle elementer i et kart med toMap()

Et kart kan brukes sammen med Java collect() for å tilordne en verdi til hver nøkkel.

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);
Map<Integer, String> mapEvenNumbers = numbers.parallelStream().filter(x -> x % 2 == 0)
    .collect(Collectors.toMap(Function.identity(), x -> String.valueOf(x)));
System.out.println(mapEvenNumbers);
Java

I utdataene kan vi se at hvert partall i inndataene har fått tildelt en verdi som er identisk med det:

{2=2, 4=4, 6=6}
Java

Kombiner elementer i en streng med joining()

Metoden joining() kombinerer elementer i en strøm i den rekkefølgen de vises, og bruker et skilletegn for å skille elementene. Skilletegnet sendes som et argument til joining(). Hvis det ikke er angitt noe skilletegn, bruker joining() den tomme strengen "".

jshell> String result1 = Stream.of("a", "b", "c").collect(Collectors.joining());
jshell> String result2 = Stream.of("a", "b", "c").collect(Collectors.joining(",", "{", "}"));
Java

Resultatene er:

result1 ==> "abc"
result2 ==> "{a,b,c}"
Java

2031f050ecb6acd05c8d5a15242b684b

b0935f2d0a8a22847f34c718bc1097e2

2b336613473a736d21c74437800d56c3

Go to Main Menu