Unione di due mappe con Java 8

1. Introduzione

In questo breve tutorial, dimostreremo come unire due mappe utilizzando le funzionalità di Java 8 .

Per essere più specifici, esamineremo diversi scenari di fusione, comprese le mappe con voci duplicate.

2. Inizializzazione

Per iniziare, definiamo due istanze di Map :

private static Map map1 = new HashMap(); private static Map map2 = new HashMap();

La classe Employee ha questo aspetto:

public class Employee {       private Long id;     private String name;       // constructor, getters, setters }

Quindi, possiamo inserire alcuni dati nelle istanze di Map :

Employee employee1 = new Employee(1L, "Henry"); map1.put(employee1.getName(), employee1); Employee employee2 = new Employee(22L, "Annie"); map1.put(employee2.getName(), employee2); Employee employee3 = new Employee(8L, "John"); map1.put(employee3.getName(), employee3); Employee employee4 = new Employee(2L, "George"); map2.put(employee4.getName(), employee4); Employee employee5 = new Employee(3L, "Henry"); map2.put(employee5.getName(), employee5);

Nota che abbiamo chiavi identiche per le voci dipendente1 e dipendente5 nelle nostre mappe che utilizzeremo in seguito.

3. Map.merge ()

Java 8 aggiunge una nuova merge () funzione nel java.util.Map dell'interfaccia .

Ecco come funziona la funzione merge () : Se la chiave specificata non è già associata a un valore o il valore è nullo, associa la chiave al valore dato.

In caso contrario, sostituisce il valore con i risultati della funzione di rimappatura data. Se il risultato della funzione di rimappatura è nullo, rimuove il risultato.

Per prima cosa, costruiamo una nuova HashMap copiando tutte le voci dalla map1 :

Map map3 = new HashMap(map1);

Successivamente, introduciamo la funzione merge () insieme alla regola di unione:

map3.merge(key, value, (v1, v2) -> new Employee(v1.getId(),v2.getName())

Infine, itereremo sulla map2 e uniremo le voci in map3 :

map2.forEach( (key, value) -> map3.merge(key, value, (v1, v2) -> new Employee(v1.getId(),v2.getName())));

Eseguiamo il programma e stampiamo il contenuto di map3 :

John=Employee{id=8, name="John"} Annie=Employee{id=22, name="Annie"} George=Employee{id=2, name="George"} Henry=Employee{id=1, name="Henry"}

Di conseguenza, la nostra mappa combinata ha tutti gli elementi delle precedenti voci HashMap . Le voci con chiavi duplicate sono state unite in un'unica voce .

Inoltre, notiamo che l' oggetto Employee dell'ultima voce ha l' id da map1 e il valore è scelto da map2 .

Ciò è dovuto alla regola che abbiamo definito nella nostra funzione di fusione:

(v1, v2) -> new Employee(v1.getId(), v2.getName())

4. Stream.concat ()

L' API Stream in Java 8 può anche fornire una facile soluzione al nostro problema. Innanzitutto, dobbiamo combinare le nostre istanze di Map in un unico flusso . Questo è esattamente ciò che fa l'operazione Stream.concat () :

Stream combined = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream());

Qui passiamo i set di voci della mappa come parametri. Successivamente, dobbiamo raccogliere il nostro risultato in una nuova mappa . Per questo possiamo usare Collectors.toMap () :

Map result = combined.collect( Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Di conseguenza, il raccoglitore utilizzerà le chiavi e i valori esistenti delle nostre mappe. Ma questa soluzione è lungi dall'essere perfetta. Non appena il nostro raccoglitore incontra voci con chiavi duplicate, genererà un'eccezione IllegalStateException .

Per gestire questo problema, aggiungiamo semplicemente un terzo parametro lambda "merger" nel nostro raccoglitore:

(value1, value2) -> new Employee(value2.getId(), value1.getName())

It will use the lambda expression every time a duplicate key is detected.

Finally, putting all together:

Map result = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream()) .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (value1, value2) -> new Employee(value2.getId(), value1.getName())));

Finally, let's run the code and see the results:

George=Employee{id=2, name="George"} John=Employee{id=8, name="John"} Annie=Employee{id=22, name="Annie"} Henry=Employee{id=3, name="Henry"}

As we see, the duplicate entries with the key “Henry” were merged into a new key-value pair where the id of the new Employee was picked from the map2 and the value from map1.

5. Stream.of()

To continue to use the Stream API, we can turn our Map instances into a unified stream with the help of Stream.of().

Here we don't have to create an additional collection to work with the streams:

Map map3 = Stream.of(map1, map2) .flatMap(map -> map.entrySet().stream()) .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> new Employee(v1.getId(), v2.getName())));

First, we transform map1 and map2 into a single stream. Next, we convert the stream into the map. As we can see, the last argument of toMap() is a merging function. It solves the duplicate keys problem by picking the id field from v1 entry, and the name from v2.

The printed map3 instance after running the program:

George=Employee{id=2, name="George"} John=Employee{id=8, name="John"} Annie=Employee{id=22, name="Annie"} Henry=Employee{id=1, name="Henry"}

6. Simple Streaming

Additionally, we can use a stream() pipeline to assemble our map entries. The code snippet below demonstrates how to add the entries from map2 and map1 by ignoring the duplicate entries:

Map map3 = map2.entrySet() .stream() .collect(Collectors.toMap( Map.Entry::getKey, Map.Entry::getValue, (v1, v2) -> new Employee(v1.getId(), v2.getName()), () -> new HashMap(map1)));

As we expect, the results after the merge are:

{John=Employee{id=8, name="John"}, Annie=Employee{id=22, name="Annie"}, George=Employee{id=2, name="George"}, Henry=Employee{id=1, name="Henry"}}

7. StreamEx

In addition to solutions that are provided by the JDK, we can also use the popular StreamEx library.

Simply put, StreamEx is an enhancement for the Stream API and provides many additional useful methods. We'll use an EntryStream instance to operate on key-value pairs:

Map map3 = EntryStream.of(map1) .append(EntryStream.of(map2)) .toMap((e1, e2) -> e1);

The idea is to merge the streams of our maps into one. Then we collect the entries into the new map3 instance. Important to mention, the (e1, e2) -> e1 expression as it helps to define the rule for dealing with the duplicate keys. Without it, our code will throw an IllegalStateException.

And now, the results:

{George=Employee{id=2, name="George"}, John=Employee{id=8, name="John"}, Annie=Employee{id=22, name="Annie"}, Henry=Employee{id=1, name="Henry"}}

8. Summary

In questo breve articolo, abbiamo imparato diversi modi per unire le mappe in Java 8. Più specificamente, abbiamo utilizzato Map.merge (), Stream API, StreamEx library .

Come sempre, il codice utilizzato durante la discussione può essere trovato su GitHub.