Stream Collectors är en kraftfull funktion i Java 8 Stream API som gör det möjligt att samla in och bearbeta data på ett effektivt sätt. Här förklarar vi deras struktur och hur Java-metoden collect() kan användas.

Hur kan Java collect() användas?

En strömkollektor kan användas för att skapa en lista, uppsättning eller karta från en ström. En ström är en sekvens av element som bearbetas efter varandra. Kollektorgränssnittet tillhandahåller en uppsättning reduktionsoperationer för data i en strömrörledning. Dessa är terminaloperationer som samlar in och sammanfogar resultaten från mellanliggande steg.

Collectors kan användas för att filtrera eller sortera objekt från en ström. Aggregering är också möjligt, till exempel att summera siffror, kombinera strängar eller räkna element. Dessutom har Collectors funktioner som kan omvandla innehållet i en ström till en specifik struktur. Du kan till exempel omvandla en lista till en karta. Grupperingar hjälper till att kategorisera element med vissa egenskaper eller villkor. Viktigast av allt är att strömkollektorer har fördelen att de kan bearbeta data samtidigt med hjälp av flera trådar. Detta gör att operationer kan utföras mycket snabbare och effektivare, särskilt med stora datamängder.

Vad är syntaxen för Java collect()?

Metoden accepterar en Collector som beskriver hur elementen i strömmen ska samlas in och aggregeras som ett argument. En Collector är ett gränssnitt som tillhandahåller olika metoder för att aggregera strömelement till en specifik form, till exempel till en lista, en uppsättning eller en karta.

Det finns två varianter av Java Stream-metoden collect():

  1. <R> R collect(Supplier<R> leverantör, BiConsumer<R, ? super T> ackumulator,BiConsumer<R, R> kombinerare)
  2. <R, A> R collect(Collector<? super T, A, R> collector)

Den första varianten har tre funktioner som argument:

  • leverantör: skapar en behållare som kommer att användas för mellanresultat
  • ackumulator: beräknar det slutliga resultatet
  • kombinator: kombinerar resultaten från parallella strömoperationer

Dessa fördefinierade samlare ingår redan i standardbiblioteket och kan enkelt importeras och användas.

Den andra varianten accepterar en Collector som argument och returnerar ett resultat.

  • R: typ av resultat
  • T: typen av element i strömmen
  • A: typen av ackumulator som lagrar det mellanliggande tillståndet för samlarens operation
  • samlare: utför reduktionsoperationen.

Genom att använda denna variant kan utvecklare skapa anpassade Collectors som är specifikt skräddarsydda efter deras behov och ger större flexibilitet och kontroll över reduktionsprocessen.

Vilka är praktiska exempel på användning av Java collect()?

Nedan illustrerar vi olika funktioner i metoden Stream.collect(). Du bör redan vara bekant med de grundläggande Java-operatorerna innan du går vidare till samlingsramverket.

Sammanfoga en lista med strängar

Med Java Collect() kan vi sammanfoga en lista med strängar för att få en ny sträng:

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 är:

abcde
a, b, c, d, e
Java

I den första beräkningen användes endast en StringBuilder-instans och det fanns ingen kombinatorfunktion. Det är därför resultatet blev abcde.

I den andra utdata sammanslog kombinatorfunktionen StringBuilder-instanserna och separerade dem med ett kommatecken.

Samla element i en lista med toList()

Vi kan använda funktionen filter() för att välja ut vissa element i en lista och sedan använda toList() för att lagra dem i en ny lista.

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 nya listan finns endast udda tal:

[1, 3, 5, 7]
Java

Samla element i en uppsättning med toSet()

På samma sätt kan vi välja element och skapa en ny uppsättning av dem. Elementen i en uppsättning behöver inte ordnas i någon specifik ordning.

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

Detta visar resultatet:

[2, 4, 6]
Java

Samla element i en karta med toMap()

En karta kan användas tillsammans med Java collect() för att tilldela ett värde till varje nyckel.

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 utdata kan vi se att varje jämnt tal i indata har tilldelats ett värde som är identiskt med det:

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

Kombinera element i en sträng med joining()

Metoden joining() kombinerar element i en ström i den ordning de visas och använder en separator för att separera elementen. Separatorn skickas som ett argument till joining(). Om ingen separator anges använder joining() den tomma strängen "".

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

Resultaten är:

result1 ==> "abc"
result2 ==> "{a,b,c}"
Java
Gå till huvudmeny