# Kā izmantot Java collect(), lai vāktu un apstrādātu datus

Stream Collectors ir jaudīga funkcija **Java 8 Stream API**, kas ļauj efektīvi vākt un apstrādāt datus. Šeit mēs izskaidrosim to struktūru un to, kā var izmantot Java collect() metodi.

## Kā var izmantot Java collect()?

Plūsmas kolektoru var izmantot, lai no plūsmas izveidotu sarakstu, kopu vai karti. Plūsma ir elementu secība, kas tiek apstrādāti viens pēc otra. Kolektora saskarne nodrošina virkni **redukcijas operāciju** datiem plūsmas cauruļvadā. Tās ir galīgās operācijas, kas apkopo un apvieno starpposmu rezultātus.

Kolektori var tikt izmantoti, lai filtrētu vai šķirotu objektus no plūsmas. Ir iespējama arī **agregācija**, piemēram, skaitļu summēšana, virkņu apvienošana vai elementu skaitīšana. Turklāt kolektoriem ir funkcijas, kas var pārveidot plūsmas saturu konkrētā struktūrā. Piemēram, jūs varat pārveidot sarakstu kartē. Grupēšana palīdz kategorizēt elementus ar noteiktām īpašībām vai nosacījumiem. Visnozīmīgākā straumju kolektoru priekšrocība ir tā, ka tie var **apstrādāt datus vienlaikus,** izmantojot vairākus pavedienus. Tas ļauj operācijas veikt daudz ātrāk un efektīvāk, īpaši ar lieliem datu apjomiem.

## Kāda ir Java collect() sintakse?

Metode kā argumentu pieņem Collector, kas apraksta, kā straumes elementi jāvāc un jāapvieno. **Collector ir saskarne**, kas nodrošina dažādas metodes, lai apvienotu straumes elementus konkrētā formā, piemēram, sarakstā, kopā vai kartē.

Ir divi Java Stream collect() metodes varianti:

1. R collect(Supplier<R> piegādātājs, BiConsumer<R, ? super T> akumulators, BiConsumer<R, R> kombinators)
2. <R, A> R collect(Collector<? super T, A, R> collector)

Pirmajam variantam ir trīs funkcijas kā argumenti:

- **piegādātājs**: izveido konteineru, kas tiks izmantots starpposma rezultātiem
- **akumulators**: aprēķina galīgo rezultātu
- **apvienotājs**: apvieno paralēlo plūsmu operāciju rezultātus

Šie iepriekš definētie kolektori jau ir iekļauti standarta bibliotēkā un tos var viegli importēt un izmantot.

Otrais variants pieņem Collector kā argumentu un atgriež rezultātu.

- **R**: rezultāta veids
- **T**: plūsmas elementu tips
- **A**: akumulatora tips, kas uzglabā kolektora darbības starpposma stāvokli
- **kolektors**: veic redukcijas darbību.

Izmantojot šo variantu, izstrādātāji var izveidot **pielāgotus kolektorus**, kas ir īpaši pielāgoti viņu prasībām un nodrošina lielāku elastību un kontroli pār samazināšanas procesu.

## Kādi ir praktiski piemēri Java collect() izmantošanai?

Zemāk mēs ilustrējam dažādas `Stream.collect()` metodes funkcijas. Pirms sākt izmantot **kolekciju struktūru**, jums jau jābūt pazīstamiem ar pamata Java operatoriem.

### Savienot virkni stingu

Izmantojot Java Collect(), mēs varam **savienot** virkni stingu, lai iegūtu jaunu stingu:

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

Rezultāts ir:

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

Pirmajā aprēķinā tika izmantots tikai viens StringBuilder instances un nebija kombinatora funkcijas. Tāpēc rezultāts ir `abcde`.

Otrajā izvades rezultātā kombinatora funkcija apvienoja StringBuilder instancēm un atdalīja tās ar komatu.

### Vāc elementus sarakstā ar toList()

Mēs varam izmantot funkciju `filter()`, lai atlasītu noteiktus saraksta elementus, un pēc tam izmantot `toList()`, lai tos saglabātu jaunā sarakstā.

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

Jaunajā sarakstā ir tikai nepāra skaitļi:

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

### Vāc elementus kopā ar toSet()

Tāpat mēs varam atlasīt elementus un no tiem izveidot jaunu kopu. Elementiem kopā **nav jābūt sakārtotiem noteiktā secībā**.

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

Tad tiek parādīts šāds izvades rezultāts:

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

### Vāc elementus kartē ar toMap()

Karti var izmantot kopā ar Java collect(), lai katrai atslēgai piešķirtu vērtību.

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

Rezultātā redzam, ka katram ieejas pāra skaitlim ir piešķirta identiska vērtība:

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

### Apvienojiet elementus virknē ar pievienošanu()

`joining()` metode apvieno elementus plūsmā tādā secībā, kādā tie parādās, un izmanto **atdalītāju, lai atdalītu elementus**. Atdalītājs tiek nodots kā arguments `joining()`. Ja atdalītājs nav norādīts, `joining()` izmanto tukšo virkni `""`.

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

Rezultāti ir šādi:

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


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-plusmas-savaksana/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/java-plusmas-savaksana/) for AI/LLM consumption.