Kombination af forskellige typer samlinger i Java

1. Introduktion

I denne hurtige vejledning undersøger vi forskellige måder at kombinere samlinger i Java på.

Vi vil undersøge forskellige tilgange ved hjælp af Java og eksterne rammer som Guava, Apache osv. For introduktion til samlinger, se på denne serie her.

2. Eksterne biblioteker til at arbejde med samlinger

Sammen med native tilgange bruger vi også eksterne biblioteker. Tilføj venligst følgende afhængigheder 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 versioner findes på Maven Central for Commons, Commons-exec og Guava.

3. Kombination af arrays i Java

3.1. Native Java-løsning

Java leveres med en indbygget ugyldig arraycopy () metode, der kopierer et givet kildearray til destinationen.

Vi kan bruge det på følgende måde:

Objekt [] kombineret = nyt objekt [første.længde + sekund.længde]; System.arraycopy (første, 0, kombineret, 0, første.længde); System.arraycopy (anden, 0, kombineret, første.længde, anden.længde);

I denne metode sammen med array-objekterne specificerer vi også positionen, hvorfra vi skal kopiere, og vi sender også længdeparameteren.

Dette er en indfødt Java-løsning, så den kræver ingen eksterne biblioteker.

3.2. Brug af Java 8 Strøm API

Streams tilbyder en effektiv måde at gentage over flere forskellige typer samlinger. For at komme i gang med streams, gå over til Java 8 Stream API Tutorial.

At kombinere arrays ved hjælp af en Strøm, vi kan bruge denne kode:

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

Stream.concat () opretter en sammenkædet strøm, hvor elementerne i den første strøm efterfølges af elementerne i den anden strøm, som derefter konverteres til en matrix ved hjælp af toArray () metode.

Processen med at oprette strømmen er den samme på tværs af forskellige typer samlinger. Vi kan dog indsamle det på forskellige måder for at hente forskellige datastrukturer fra det.

Vi gennemgår denne metode igen i afsnit 4.2. og 5.2. for at se, hvordan vi kan bruge den samme metode til Lister og Sæt.

3.3. Ved brug af ArrayUtils fra Apache Commons

Apache commons-bibliotek giver os tilføjAlle () metode fra ArrayUtils pakke. Vi kan levere destinations- og kildearray som parametre, og denne metode returnerer et kombineret array:

Objekt [] kombineret = ArrayUtils.addAll (første, andet);

Denne metode diskuteres også detaljeret i Array Processing with Apache Commons Lang 3-artiklen.

3.4. Brug af Guava

Guava giver os den concat () metode til samme formål:

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

Den kan bruges med forskellige datatyper, og den accepterer to kildearrays sammen med klassen bogstavelig for at returnere det kombinerede array.

4. Kombination Liste i Java

4.1. Ved brug af Kollektion Hjemmehørende tilføjAlle () Metode

Det Kollektion selve grænsefladen giver os tilføjAlle () metode, som tilføjer alle elementerne i den specificerede samling til den, der ringer op. Dette diskuteres også detaljeret i denne Baeldung-artikel:

Liste kombineret = ny ArrayList (); combined.addAll (første); combined.addAll (anden);

Da denne metode er tilvejebragt i den mest overordnede grænseflade til Collections-rammen, dvs. Kollektion interface, kan den anvendes på tværs af alle Listes og Sæts.

4.2. Brug af Java 8

Vi kan bruge Strøm og Samlere på følgende måde at kombinere Lister:

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

Dette er det samme som hvad vi gjorde i tilfælde af Arrays i afsnit 3.2, men i stedet for at konvertere det til et array brugte vi samlere til at konvertere det til en liste. At lære om Samlere detaljeret, besøg Guide til Java 8's Collectors.

Vi kan også bruge flatMaps på denne måde:

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

For det første bruger vi det Stream.of () som returnerer en sekventiel strøm af to lister - først og sekund. Vi sender det derefter til flatMap som returnerer indholdet af en kortlagt strøm efter anvendelse af kortlægningsfunktionen. Denne metode diskuteres også i Fletning af streams i Java-artiklen.

For at lære mere om flatMap, gå over til denne Baeldung-artikel.

4.3. Ved brug af ListUtils fra Apache Commons

CollectionUtils.union forener to samlinger og returnerer en samling, der indeholder alle elementerne:

Liste kombineret = ListUtils.union (første, anden);

Denne metode diskuteres også i En guide til Apache Commons-samlinger CollectionUtils. For mere info, gå over til afsnit 4.9. i denne artikel.

4.4. Brug af Guava

At fusionere en Liste ved hjælp af Guava bruger vi Iterabel som består af concat () metode. Efter sammenkædning af alle samlinger kan vi hurtigt få kombineret Liste objekt som vist i dette eksempel:

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

5. Kombination Sæt i Java

5.1. Almindelig Java-løsning

Som vi allerede havde diskuteret i afsnit 4.1., Kommer samlingsgrænsefladen med en indbygget tilføjAlle () metode, der kan bruges til kopiering Lister og Sæt såvel:

Indstil kombineret = nyt HashSet (); combined.addAll (første); combined.addAll (anden);

5.2. Brug af Java 8 Streams

Den samme funktion, som vi brugte til Liste objekter kan anvendes her:

Indstil kombineret = Stream .concat (first.stream (), second.stream ()) .collect (Collectors.toSet ());

Den eneste bemærkelsesværdige forskel her, når man sammenligner med listen, er den i stedet for at bruge Collectors.toList (), vi bruger Collectors.toSet () at akkumulere alle elementerne fra de leverede to strømme til en ny Sæt.

Og ligner Lister, når du bruger flatMaps Sæt, det ser ud som:

Set combined = Stream.of (first, second) .flatMap (Collection :: stream) .collect (Collectors.toSet ());

5.3. Brug af Apache Commons

Svarende til ListUtils, kan vi også arbejde med SetUtils det gør en forening af Sæt elementer:

Set combined = SetUtils.union (første, andet);

5.4. Brug fra Guava

Guava-biblioteket giver os ligetil Sets.union () metode til at kombinere Sæt i Java:

Set combined = Sets.union (første, anden);

6. Kombination Kort i Java

6.1. Almindelig Java-løsning

Vi kan gøre brug af Kort interface, som i sig selv giver os putAll () metode, der kopierer alle kortlægningerne fra det medfølgende argument af Kort modsætter sig den, der ringer op Kort objekt:

Kort kombineret = nyt HashMap (); combined.putAll (første); combined.putAll (sekund);

6.2. Brug af Java 8

Siden Java 8 er den Kort klasse består af fusionere() metode, der accepterer en nøgle, værdi og en BiFunction. Vi kan bruge dette med en Java 8 forEach-sætning for at opnå sammenlægningsfunktionalitet:

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

Den tredje parameter, dvs. remapping-funktion, er nyttig, når det samme nøgleværdipar er til stede i begge kildekort. Denne funktion specificerer, hvad der skal gøres med denne type værdier.

Vi kan også bruge flatMap sådan her:

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

6.3. Brug af Apache Commons Exec

Apache Commons Exec giver os en ligetil flet (kort først, kort andet) metode:

Kort kombineret = MapUtils.merge (første, andet);

6.4. Brug af Google Guava

Vi kan bruge ImmutableMap leveret af Googles Guava-bibliotek. Det er det putAll () metoden knytter alle de givne korts nøgler og værdier til det indbyggede kort:

Kort kombineret = ImmutableMap.builder () .putAll (første) .putAll (anden) .build ();

7. Konklusion

I denne artikel gennemgik vi forskellige tilgange til at kombinere forskellige typer Samlinger. Vi fusionerede arrays, Lister, Sætog Kort.

Som altid kan de komplette kodestykker med deres korrekte enhedstest findes på GitHub.