# Kuidas kasutada Java collect() andmete kogumiseks ja töötlemiseks

Stream Collectors on **Java 8 Stream API** võimas funktsioon, mis võimaldab teil andmeid tõhusalt koguda ja töödelda. Siin selgitame nende struktuuri ja kuidas Java collect() meetodit kasutada.

## Kuidas saab kasutada Java collect()-i?

Stream Collector’it saab kasutada voost nimekirja, kogumi või kaardi loomiseks. Vool on järjestikku töödeldavate elementide jada. Collector’i liides pakub voo torujuhtmes olevate andmete jaoks rea **vähendusoperatsioone**. Need on lõppoperatsioonid, mis koguvad ja ühendavad vaheetappide tulemused.

Kogujaid saab kasutada voost objektide filtreerimiseks või sorteerimiseks. Samuti on võimalik **koondamine**, näiteks numbrite summeerimine, stringide ühendamine või elementide loendamine. Lisaks on kogujatel funktsioonid, mis võimaldavad voo sisu teisendada kindlaks struktuuriks. Näiteks saab nimekirja teisendada kaardiks. Rühmitused aitavad kategoriseerida elemente teatud omaduste või tingimuste alusel. Kõige olulisem on see, et voo kogujatel on eelis, et nad saavad **töödelda andmeid samaaegselt** mitme niidi abil. See võimaldab operatsioone teha palju kiiremini ja tõhusamalt, eriti suurte andmemahtude puhul.

## Mis on Java collect() süntaks?

Meetod võtab argumendina vastu kollektori, mis kirjeldab, kuidas voo elemendid tuleks koguda ja koondada. **Kollektor on liides**, mis pakub erinevaid meetodeid voo elementide koondamiseks kindlasse vormi, näiteks nimekirja, kogumisse või kaardile.

Java Stream collect() meetodil on kaks varianti:

1. R collect(Supplier<R> tarnija, BiConsumer<R, ? super T> akumulaator, BiConsumer<R, R> kombinaator)
2. <R, A> R koguda(Koguja<? super T, A, R> koguja)

Esimesel variandil on kolm funktsiooni argumentidena:

- **tarnija**: loob vahetulemuste jaoks kasutatava konteineri
- **akumulaator**: arvutab lõpptulemuse
- **kombinaator**: ühendab paralleelsete voooperatsioonide tulemused

Need eelmääratud kogujad on juba standardteegis olemas ja neid saab hõlpsasti importida ja kasutada.

Teine variant võtab argumendina vastu kollektori ja tagastab tulemuse.

- **R**: tulemuse tüüp
- **T**: voo elementide tüüp
- **A**: akumulaatori tüüp, mis salvestab koguja operatsiooni vahepealse seisundi
- **koguja**: teostab reduktsioonioperatsiooni.

Selle variandi abil saavad arendajad luua oma vajadustele spetsiaalselt kohandatud **kogujaid**, mis pakuvad suuremat paindlikkust ja kontrolli vähendamisprotsessi üle.

## Millised on praktilised näited Java collect() kasutamiseks?

Allpool illustreerime `Stream.collect()` meetodi erinevaid funktsioone. Enne **kollektsiooni raamistikku** süvenemist peaksite olema juba tuttav Java põhioperaatoritega.

### Stringide loendi ühendamine

Java Collect() abil saame **ühendada** stringide loendi, et saada uus string:

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

Väljund on:

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

Esimeses arvutuses kasutati ainult ühte StringBuilderi instantsi ja kombineerimisfunktsiooni ei olnud. Seetõttu on tulemus `abcde`.

Teises väljundis ühendas kombineerimisfunktsioon StringBuilderi instantsid ja eraldas need komaga.

### Koguge elemendid nimekirja toList() abil

Me saame kasutada funktsiooni `filter()`, et valida loendi teatud elemendid, ja seejärel kasutada `toList()`, et need uude loendisse salvestada.

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

Uues nimekirjas on ainult paaritud numbrid:

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

### Koguge elemendid komplekti funktsiooniga toSet()

Samamoodi saame valida elemendid ja luua neist uue hulga. Hulgasse kuuluvad elemendid **ei pea olema kindlas järjekorras**.

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

See kuvab väljundi:

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

### Koguge elemendid kaardile funktsiooniga toMap()

Kaarti saab kasutada koos Java collect()-iga, et määrata igale võtmele väärtus.

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

Väljundis näeme, et igale sisendi paarisarvule on omistatud sellega identne väärtus:

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

### Ühendage stringi elemendid funktsiooniga joining()

Meetod `joining()` ühendab voo elemendid nende ilmumise järjekorras ja kasutab **eraldajat elementide eraldamiseks**. Eraldaja edastatakse argumendina meetodile `joining()`. Kui eraldajat ei ole määratud, kasutab `joining()` tühja stringi `""`.

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

Tulemused on järgmised:

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


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-voo-kogumine/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/java-voo-kogumine/) for AI/LLM consumption.