Java fournit diverses bibliothèques de collections intégrées utiles. Mais parfois, nous avions besoin de types spéciaux de collections qui ne sont pas intégrés à la bibliothèque standard de Java. L'une de cette collection est le Multicarte . Dans cette section, nous apprendrons ce qu'est le multimap et comment implémenter multimap en Java, et le Interface multicarte de la bibliothèque Goyave.

Java Multicarte

En Java, Carte est une structure de données qui nous permet de mapper la clé en valeur. D'autre part, multimap est un nouveau type de collection trouvé dans la bibliothèque Guava qui permet le mappage d'une seule clé sur plusieurs valeurs (comme les relations un-à-plusieurs dans les SGBD). Mais notez que le JDK n'autorise pas le multimapping.

La solution alternative pour implémenter le multimap en Java en utilisant la bibliothèque Guava de Google et les bibliothèques Apache Commons Collections. Les deux fournissent une implémentation de l’interface Multimap. Il peut stocker plusieurs valeurs sur une seule clé. Les clés et les valeurs stockées dans la collection et considérées comme une alternative à Carte ou Carte (cadre de collections JDK standard).

arbre binaire en Java

Mais utiliser Multimap de la bibliothèque Guava de Google ne nous est pas d'une grande aide. Au lieu de cela, nous implémenterons notre propre classe Multimap en Java qui peut également être personnalisée en conséquence. Il est facile d'écrire une classe Multimap en Java.

Le programme Java suivant décrit l'implémentation de la classe Multimap en Java à l'aide de Map et de la collection.

Implémentation multicarte Java

MultimapExample.java

entreprise contre entreprise

 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,>

Sortir:

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

Utiliser la bibliothèque Guava de Google

Multicarte l'interface est définie dans com.google.common.collect paquet de la bibliothèque Guava. Il implémente de nombreuses classes nommées comme suit :

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

Syntaxe:

 @GwtCompatible public interface Multimap 

Une collection qui mappe les clés aux valeurs (comme dans Map), mais chaque clé peut être associée à plusieurs valeurs. Nous pouvons visualiser le contenu d'une multi-carte sous la forme d'une carte allant des clés vers des collections de valeurs non vides. Par exemple:

appeler la fonction javascript depuis HTML

• X → 1, 2
• O → 3

ou

• X → 1
• X → 2
• O → 3

Méthodes d'interface multicarte Java