# Hvordan bruke Java collect() til å samle inn og behandle data

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:

```Java
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());
```

Resultatet er:

```Java
abcde
a, b, c, d, e
```

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.

```Java
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);
```

I den nye listen er det bare oddetall:

```Java
[1, 3, 5, 7]
```

### 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**.

```Java
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);
```

Dette viser utdataene:

```Java
[2, 4, 6]
```

### Samle elementer i et kart med toMap()

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

```Java
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);
```

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

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

### 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 `""`.

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

Resultatene er:

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


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-stream-collect/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-stream-collect/) for AI/LLM consumption.