Java fornisce varie utili librerie di raccolte integrate. Ma a volte abbiamo bisogno di tipi speciali di raccolte che non sono integrate nella libreria standard di Java. Una di questa collezione è la Multimappa . In questa sezione impareremo cos'è il multimappa e come implementare la multimappa in Java, e il Interfaccia multimappa della Biblioteca Guava.
Multimappa Java
A Giava, Carta geografica è una struttura dati che ci consente di associare la chiave al valore. D'altra parte, multimap è un nuovo tipo di raccolta trovato nella libreria Guava che consente la mappatura di una singola chiave su più valori (come le relazioni uno-a-molti nei DBMS). Ma tieni presente che JDK non consente il multimapping.
La soluzione alternativa per implementare multimap in Java utilizzando la libreria Guava di Google e le librerie Apache Commons Collections. Entrambi forniscono un'implementazione dell'interfaccia Multimap. Può memorizzare più di un valore rispetto a una singola chiave. Sia le chiavi che i valori archiviati nella raccolta e considerati come un'alternativa a Carta geografica
nozioni di base su Java
Ma l'utilizzo di Multimap della libreria Guava di Google non ci è molto utile. Implementeremo invece la nostra classe Multimap in Java che può anche essere personalizzata di conseguenza. È facile scrivere una classe Multimap in Java.
Il seguente programma Java descrive l'implementazione della classe Multimap in Java utilizzando Map e collection.
Implementazione Java multimappa
MultimapExample.java
mysql non è uguale
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>> 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('a', 'Andrew'); multimap.put('b', 'Albert'); multimap.put('b', 'Tom'); multimap.put('d', 'Sam'); multimap.put('d', 'Reo'); multimap.put('g', 'Jack'); multimap.put('g', 'David'); System.out.println('----- Printing Multimap using keySet ----- '); //loop iterate over multimap for (String lastName: multimap.keySet()) { //printing key and values System.out.println(lastName + ': ' + multimap.get(lastName)); } } } </collection></map.entry<k,></k,>
Produzione:
----- Printing Multimap using keySet ----- a: [Andrew] b: [Albert, Tom] d: [Sam, Reo] g: [Jack, David]
Utilizzando la libreria Guava di Google
Multimappa l'interfaccia è definita in com.google.common.collect pacchetto della libreria Guava. Implementa molte classi denominate come segue:
ArrayListMultimap, ForwardingListMultimap, ForwardingMultimap, ForwardingSetMultimap, ForwardingSortedSetMultimap, HashMultimap, ImmutableListMultimap, ImmutableMultimap, ImmutableSetMultimap, LinkedHashMultimap, LinkedListMultimap, TreeMultimap.
np.clip
Sintassi:
@GwtCompatible public interface Multimap
Una raccolta che mappa le chiavi ai valori (come in Map), ma ciascuna chiave può essere associata a più valori. Possiamo visualizzare il contenuto di una multimappa sia come una mappa da chiavi a raccolte di valori non vuote. Per esempio:
- X → 1, 2
- Y → 3
O
- X → 1
- X → 2
- Y → 3
Metodi di interfaccia multimappa Java
Metodo | Descrizione |
---|---|
comeMappa() | Restituisce una vista di questa multimappa come una mappa da ciascuna chiave distinta alla raccolta non vuota dei valori associati di quella chiave. |
chiaro() | Rimuove tutte le coppie chiave-valore dalla multimappa, lasciandola vuota. |
contieneEntry(chiave oggetto, valore oggetto) | Restituisce true se questa mappa multipla contiene almeno una coppia chiave-valore con la chiave e il valore. |
contieneChiave(Chiave oggetto) | Restituisce true se questa mappa multipla contiene almeno una coppia chiave-valore con la chiave. |
contieneValore(Valore oggetto) | Restituisce true se questa multimappa contiene almeno una coppia chiave-valore con il valore. |
inserimenti() | Restituisce una raccolta di visualizzazioni di tutte le coppie chiave-valore contenute in questa multimappa, come istanze Map.Entry. |
è uguale a(Oggetto oggetto) | Confronta l'oggetto specificato con questa multimappa per verificarne l'uguaglianza. |
forEach(azione BiConsumer) | Esegue l'azione specificata per tutte le coppie chiave-valore contenute in questa multimappa. |
ottieni (tasto K) | Restituisce una raccolta di visualizzazioni dei valori associati alla chiave in questa multimappa, se presente. |
codice hash() | Restituisce il codice hash per questa multimappa. |
è vuoto() | Restituisce true se questa multimappa non contiene coppie chiave-valore. |
chiavi() | Restituisce una raccolta di viste contenente la chiave di ciascuna coppia chiave-valore in questa multimappa, senza comprimere i duplicati. |
mazzo di chiavi() | Restituisce una raccolta di viste di tutte le chiavi distinte contenute in questa multimappa. |
put(chiave K, valore V) | Memorizza una coppia chiave-valore in questa multimappa. |
putAll(chiave K, valori iterabili) | Memorizza una coppia chiave-valore in questa multimappa per ciascuno dei valori, tutti utilizzando la stessa chiave, key. |
putAll(Multimappa multimappa) | Memorizza tutte le coppie chiave-valore di multimap in questo multimap, nell'ordine restituito da multimap.entries(). |
rimuovi(Chiave oggetto, Valore oggetto) | Rimuove una singola coppia chiave-valore con la chiave e il valore da questa multimappa, se esistente. |
rimuovi tutto(chiave oggetto) | Rimuove tutti i valori associati alla chiave. |
replaceValues(chiave K, valori iterabili) | Memorizza una raccolta di valori con la stessa chiave, sostituendo eventuali valori esistenti per quella chiave. |
misurare() | Restituisce il numero di coppie chiave-valore in questa multimappa. |
valori() | Restituisce una raccolta di viste contenente il valore di ciascuna coppia chiave-valore contenuta in questa multimappa, senza comprimere i duplicati (quindi valori().size() == size()). |