Java bietet verschiedene nützliche integrierte Sammlungsbibliotheken. Aber manchmal benötigten wir spezielle Arten von Sammlungen, die nicht in der Standardbibliothek von Java integriert sind. Eine dieser Sammlungen ist die Multimap . In diesem Abschnitt erfahren wir, was Multimap ist und wie man Multimap in Java implementiert, und das Multimap-Schnittstelle der Guava-Bibliothek.

Java-Multimap

In Java, Karte ist eine Datenstruktur, die es uns ermöglicht, den Schlüssel dem Wert zuzuordnen. Andererseits ist Multimap ein neuer Sammlungstyp in der Guava-Bibliothek, der die Zuordnung eines einzelnen Schlüssels zu mehreren Werten ermöglicht (wie Eins-zu-Viele-Beziehungen in DBMS). Beachten Sie jedoch, dass JDK kein Multimapping zulässt.

Die alternative Lösung zur Implementierung von Multimap in Java unter Verwendung der Guava-Bibliothek von Google und der Apache Commons Collections-Bibliotheken. Beide stellen eine Implementierung der Multimap-Schnittstelle bereit. Es kann mehr als einen Wert für einen einzelnen Schlüssel speichern. Sowohl die Schlüssel als auch die Werte, die in der Sammlung gespeichert sind und als Alternative zu betrachtet werden Karte oder Karte (Standard JDK Collections Framework).

Polymorphismus

Aber die Verwendung von Multimap der Guava-Bibliothek von Google ist für uns nicht sehr hilfreich. Stattdessen werden wir eine eigene Multimap-Klasse in Java implementieren, die auch entsprechend angepasst werden kann. Es ist einfach, eine Multimap-Klasse in Java zu schreiben.

Das folgende Java-Programm zeigt die Implementierung der Multimap-Klasse in Java mithilfe von Map und Collection.

Java-Multimap-Implementierung

MultimapExample.java

MySQL nicht gleich

 import java.util.*; class MultiMap { //creating a map of key and value (collection) private Map<k, collection> map = new HashMap(); //add the specified value with the specified key in this multimap public void put(K key, V value) { if (map.get(key) == null) { map.put(key, new ArrayList()); } map.get(key).add(value); } //associate the specified key with the given value if not already associated with a value public void putIfAbsent(K key, V value) { if (map.get(key) == null) { map.put(key, new ArrayList()); } // if the value is absent, insert it if (!map.get(key).contains(value)) { map.get(key).add(value); } } //the method returns the Collection of values to which the specified key is mapped, or null if this multimap contains no mapping for the key public Collection get(Object key) { return map.get(key); } //the method returns a set view of the keys contained in this multimap public Set keySet() { return map.keySet(); } //the method returns a set view of the mappings contained in this multimap public Set<map.entry<k, collection>&gt; entrySet() { return map.entrySet(); } //the method returns a Collection view of Collection of the values present in this multimap public Collection<collection> values() { return map.values(); } //Returns true if this multimap contains a mapping for the specified key. public boolean containsKey(Object key) { return map.containsKey(key); } //Removes the mapping for the specified key from this multimap if present and returns the Collection of previous values associated with the key, or null if there was no mapping for key public Collection remove(Object key) { return map.remove(key); } //Returns the total number of key-value mappings in this multimap. public int size() { int size = 0; for (Collection value: map.values()) { size += value.size(); } return size; } //Returns true if this multimap contains no key-value mappings. public boolean isEmpty() { return map.isEmpty(); } //Removes all the mappings from this multimap. public void clear() { map.clear(); } //Removes the entry for the specified key only if it is currently mapped to the specified value and returns true if removed public boolean remove(K key, V value) { if (map.get(key) != null) // key exists return map.get(key).remove(value); return false; } //Replaces the entry for the specified key only if currently mapped to the specified value and return true if replaced public boolean replace(K key, V oldValue, V newValue) { if (map.get(key) != null) { if (map.get(key).remove(oldValue)) { return map.get(key).add(newValue); } } return false; } } //main class public class MultimapExample { //main method public static void main(String args[]) { //Creating a multimap of type String MultiMap multimap = new MultiMap(); //adding values to the multimap multimap.put(&apos;a&apos;, &apos;Andrew&apos;); multimap.put(&apos;b&apos;, &apos;Albert&apos;); multimap.put(&apos;b&apos;, &apos;Tom&apos;); multimap.put(&apos;d&apos;, &apos;Sam&apos;); multimap.put(&apos;d&apos;, &apos;Reo&apos;); multimap.put(&apos;g&apos;, &apos;Jack&apos;); multimap.put(&apos;g&apos;, &apos;David&apos;); System.out.println(&apos;----- Printing Multimap using keySet -----
&apos;); //loop iterate over multimap for (String lastName: multimap.keySet()) { //printing key and values System.out.println(lastName + &apos;: &apos; + multimap.get(lastName)); } } } </collection></map.entry<k,></k,>

Ausgabe:

 ----- Printing Multimap using keySet ----- a: [Andrew] b: [Albert, Tom] d: [Sam, Reo] g: [Jack, David] 

Verwendung der Guava-Bibliothek von Google

Multimap Die Schnittstelle ist in definiert com.google.common.collect Paket der Guava-Bibliothek. Es implementiert viele Klassen mit den folgenden Namen:

ArrayListMultimap, ForwardingListMultimap, ForwardingMultimap, ForwardingSetMultimap, ForwardingSortedSetMultimap, HashMultimap, ImmutableListMultimap, ImmutableMultimap, ImmutableSetMultimap, LinkedHashMultimap, LinkedListMultimap, TreeMultimap.

Syntax:

 @GwtCompatible public interface Multimap 

Eine Sammlung, die Schlüssel Werten zuordnet (dasselbe wie in Map), aber jeder Schlüssel kann mehreren Werten zugeordnet sein. Wir können den Inhalt einer Multimap entweder als Karte von Schlüsseln zu nichtleeren Wertesammlungen visualisieren. Zum Beispiel:

• X → 1, 2
• Y → 3

oder

Arten von Joins in RDBMS

• X → 1
• X → 2
• Y → 3

Methoden der Java-Multimap-Schnittstelle