streamalism.org

1. Introduksjon

I denne raske opplæringen vil vi utforske forskjellige måter å kombinere samlinger i Java på.

Vi vil utforske ulike tilnærminger ved hjelp av Java og eksterne rammer som Guava, Apache, etc. For introduksjonen til samlinger, se på denne serien her.

2. Eksterne biblioteker å jobbe med samlinger

I tillegg til innfødte tilnærminger, bruker vi også eksterne biblioteker. Legg til følgende avhengigheter i pom.xml:

 org.apache.commons commons-collection4 4.2 org.apache.commons commons-exec 1.3 com.google.guava guava 26.0-jre 

De nyeste versjonene finner du på Maven Central for Commons, Commons-exec og Guava.

3. Kombinere arrays i Java

3.1. Innfødt Java-løsning

Java leveres med en innebygd ugyldig arraykopi () metoden som kopierer et gitt kildearray til destinasjonen.

Vi kan bruke det på følgende måte:

Objekt [] kombinert = nytt Objekt [første.lengde + sekund.lengde]; System.arraycopy (første, 0, kombinert, 0, første.lengde); System.arraycopy (andre, 0, kombinert, første.lengde, andre.lengde);

I denne metoden, sammen med matriseobjektene, spesifiserer vi også posisjonen hvorfra vi trenger å kopiere, og vi sender også lengdeparameteren.

Dette er en innfødt Java-løsning, så den krever ingen eksterne biblioteker.

3.2. Bruke Java 8 Strøm API

Strømmer tilbyr en effektiv måte å gjenta over flere forskjellige typer samlinger. For å komme i gang med strømmer, gå over til Java 8 Stream API Tutorial.

For å kombinere arrays ved hjelp av a Strøm, kan vi bruke denne koden:

Objekt [] kombinert = Stream.concat (Arrays.stream (første), Arrays.stream (andre)). ToArray ();

Stream.concat () oppretter en sammenkoblet strøm der elementene i den første strømmen blir fulgt av elementene i den andre strømmen, som deretter konverteres til en matrise ved hjelp av toArray () metode.

Prosessen med å lage strømmen er den samme på tvers av forskjellige samlinger. Vi kan imidlertid samle den på forskjellige måter for å hente forskjellige datastrukturer fra den.

Vi vil se på denne metoden i avsnitt 4.2. og 5.2. for å se hvordan vi kan bruke den samme metoden på Lister og Settene.

3.3. Ved hjelp av ArrayUtils fra Apache Commons

Apache commons bibliotek gir oss Legg til alle() metoden fra ArrayUtils pakke. Vi kan levere destinasjons- og kildearray som parametere, og denne metoden returnerer et kombinert array:

Objekt [] kombinert = ArrayUtils.addAll (første, andre);

Denne metoden er også diskutert i detaljer i artikkelen Array Processing with Apache Commons Lang 3.

3.4. Bruke Guava

Guava gir oss concat () metode for samme formål:

Objekt [] kombinert = ObjectArrays.concat (første, andre, Object.class);

Den kan brukes med forskjellige datatyper, og den aksepterer to kildearriser sammen med klassen bokstavelig for å returnere den kombinerte matrisen.

4. Kombinere Liste i Java

4.1. Ved hjelp av Samling Innfødt Legg til alle() Metode

De Samling grensesnittet i seg selv gir oss Legg til alle() metode, som legger til alle elementene i den spesifiserte samlingen til innringerobjektet. Dette er også diskutert i detalj i denne Baeldung-artikkelen:

Liste kombinert = ny ArrayList (); combined.addAll (først); combined.addAll (andre);

Siden denne metoden er gitt i det mest overordnede grensesnittet til Collections-rammeverket, dvs. Samling grensesnitt, kan den brukes på tvers av alle Listes og Setts.

4.2. Bruke Java 8

Vi kan bruke Strøm og Samlere på følgende måte å kombinere Lister:

Liste kombinert = Stream.concat (first.stream (), second.stream ()). Collect (Collectors.toList ());

Dette er det samme som det vi gjorde i tilfelle Arrays i avsnitt 3.2, men i stedet for å konvertere den til en matrise, brukte vi samlere til å konvertere den til en liste. For å lære om Samlere i detalj, besøk Guide to Java 8’s Collectors.

Vi kan også bruke flatMaps på denne måten:

Liste kombinert = Stream.of (første, andre) .flatMap (Collection :: stream) .collect (Collectors.toList ());

Først bruker vi Stream.of () som returnerer en sekvensiell strøm av to lister - først og sekund. Vi sender den videre til flatMap som vil returnere innholdet i en tilordnet strøm etter å ha brukt kartleggingsfunksjonen. Denne metoden ble også diskutert i Merging Streams i Java-artikkelen.

For å lære mer om flatMap, gå over til denne Baeldung-artikkelen.

4.3. Ved hjelp av ListUtils fra Apache Commons

CollectionUtils.union forener to samlinger og returnerer en samling som inneholder alle elementene:

Liste kombinert = ListUtils.union (første, andre);

Denne metoden er også diskutert i A Guide to Apache Commons Collections CollectionUtils. For mer info, gå til seksjon 4.9. av denne artikkelen.

4.4. Bruke Guava

Å slå sammen en Liste bruker Guava, vil vi bruke Iterabel som består av concat () metode. Etter å ha samlet alle samlingene, kan vi raskt få kombinasjonen Liste objekt som vist i dette eksemplet:

Iterable combinedIterables = Iterables .unmodifiableIterable (Iterables.concat (første, andre)); Liste kombinert = Lists.newArrayList (combinedIterables);

5. Kombinere Sett i Java

5.1. Vanlig Java-løsning

Som vi allerede hadde diskutert i avsnitt 4.1., Kommer samlingsgrensesnittet med en innebygd Legg til alle() metode som kan brukes til kopiering Lister og Settene også:

Sett kombinert = nytt HashSet (); combined.addAll (først); combined.addAll (andre);

5.2. Bruke Java 8 Streams

Den samme funksjonen som vi brukte til Liste objekter kan brukes her:

Sett kombinert = Stream .concat (first.stream (), second.stream ()) .collect (Collectors.toSet ());

Den eneste bemerkelsesverdige forskjellen her når man sammenligner med listen er at i stedet for å bruke Collectors.toList (), vi bruker Collectors.toSet () å samle alle elementene fra de to strømmen som ble levert til en ny Sett.

Og ligner på Lister, når du bruker flatMaps på Settene, det ser ut som:

Sett kombinert = Stream.of (første, andre) .flatMap (Collection :: stream) .collect (Collectors.toSet ());

5.3. Bruke Apache Commons

I likhet med ListUtils, kan vi også jobbe med SetUtils som gjør en forening av Sett elementer:

Sett kombinert = SetUtils.union (første, andre);

5.4. Bruker fra Guava

Guava-biblioteket gir oss grei Sets.union () metode å kombinere Settene i Java:

Sett kombinert = Sets.union (første, andre);

6. Kombinere Kart i Java

6.1. Vanlig Java-løsning

Vi kan benytte oss av Kart grensesnitt som i seg selv gir oss putt alle() metoden som kopierer alle kartleggingene fra det medfølgende argumentet fra Kart motsette innringeren Kart gjenstand:

Kart kombinert = nytt HashMap (); combined.putAll (først); combined.putAll (andre);

6.2. Bruke Java 8

Siden Java 8, den Kart klasse består av slå sammen() metode som godtar en nøkkel, verdi og en BiFunction. Vi kan bruke dette med en Java 8 forEach-uttalelse for å oppnå sammenslåingsfunksjonalitet:

second.forEach ((key, value) -> first.merge (key, value, String :: concat));

Den tredje parameteren, det vil si omformingsfunksjonen er nyttig når det samme nøkkelverdiparet er tilstede i begge kildekartene. Denne funksjonen spesifiserer hva som skal gjøres med den typen verdier.

Vi kan også bruke flatMap som dette:

Kart kombinert = Stream.of (første, andre) .map (Map :: entrySet) .flatMap (Collection :: stream) .collect (Collectors.toMap (Map.Entry :: getKey, Map.Entry :: getValue, String: : concat));

6.3. Bruke Apache Commons Exec

Apache Commons Exec gir oss en grei flette (Kart først, Kart andre) metode:

Kart kombinert = MapUtils.merge (første, andre);

6.4. Bruke Google Guava

Vi kan bruke ImmutableMap levert av Googles Guava-bibliotek. Det er putt alle() metoden knytter alle gitte kartets nøkler og verdier til det innebygde kartet:

Kart kombinert = ImmutableMap.builder () .putAll (første) .putAll (andre) .build ();

7. Konklusjon

I denne artikkelen gikk vi gjennom forskjellige tilnærminger for å kombinere forskjellige typer Samlinger. Vi slo sammen arrays, Lister, Settene, og Kart.

Som alltid kan du finne de komplette kodebitene med riktige enhetstester på GitHub.