Java fornece várias bibliotecas de coleção integradas úteis. Mas às vezes precisávamos de tipos especiais de coleções que não estão incorporadas na biblioteca padrão do Java. Uma desta coleção é a Multimapa . Nesta seção, aprenderemos o que é multimapa e como implementar multimapa em Java, e a Interface multimapa da biblioteca Goiaba.

Multimapa Java

Em Java, Mapa é uma estrutura de dados que nos permite mapear chave em valor. Por outro lado, multimap é um novo tipo de coleção encontrado na biblioteca Guava que permite o mapeamento de uma única chave para vários valores (como relações um-para-muitos em SGBD). Mas observe que o JDK não permite multimapping.

A solução alternativa para implementar multimap em Java usando a biblioteca Guava do Google e as bibliotecas Apache Commons Collections. Ambos fornecem uma implementação da interface Multimap. Ele pode armazenar mais de um valor em uma única chave. Tanto as chaves quanto os valores armazenados na coleção e considerados como uma alternativa para Mapa ou Mapa (Estrutura de coleções JDK padrão).

índice java de

Mas usar o Multimap da biblioteca Guava do Google não é muito útil para nós. Em vez disso, implementaremos nossa própria classe Multimap em Java, que também pode ser customizada de acordo. É fácil escrever uma classe Multimap em Java.

O programa Java a seguir descreve a implementação da classe Multimap em Java usando Mapa e coleção.

Implementação Java Multimapa

MultimapExample.java

empresa vs empresa

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

Saída:

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

Usando a biblioteca Guava do Google

Multimapa interface é definida em com.google.common.collect pacote da biblioteca Guava. Ele implementa muitas classes nomeadas da seguinte forma:

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

Sintaxe:

 @GwtCompatible public interface Multimap 

Uma coleção que mapeia chaves para valores (o mesmo que em Map), mas cada chave pode estar associada a vários valores. Podemos visualizar o conteúdo de um multimapa como um mapa de chaves para coleções não vazias de valores. Por exemplo:

• X → 1, 2
• S → 3

ou

fatiar java

• X → 1
• X → 2
• S → 3

Métodos de interface multimapa Java