Mapa bidireccional de valores múltiples en Java

Question

Estoy buscando una forma de almacenar pares clave-valor. Necesito que la búsqueda sea bidireccional, pero al mismo tiempo necesito almacenar valores múltiples para la misma clave. En otras palabras, algo así como BidiMap, pero para cada clave puede haber múltiples valores. Por ejemplo, debe ser capaz de mantener pares como: "s1" -> 1, "s2" -> 1, "s3" -> 2, y necesito poder asignar el valor asignado a cada tecla, y para cada valor, obtenga todas las claves asociadas con él.

Answer 1

¿Necesita soporte para relaciones de muchos a muchos? Lo más cercano que puede obtener es Guava 's Multimap como @Mechkov escribió - pero más específicamente Multimap combinación con Multimaps.invertFrom. "BiMultimap" aún no está implementado, pero está an issue solicitando esta función en la biblioteca de Google Guava.

En este punto se tienen pocas opciones:

1. Si su "BiMultimap" va a constante inmutable - utilizar Multimaps.invertFrom y ImmutableMultimap/ImmutableListMultimap/ImmutableSetMultimap (cada uno de theese tres tiene diferentes valores de la colección de almacenamiento). Algo de código (ejemplo tomado de aplicación que desarrollo, utiliza Enum s) y Sets.immutableEnumSet:

   public class RolesAndServicesMapping { 
       private static final ImmutableMultimap<Service, Authority> SERVICES_TO_ROLES_MAPPING = 
        ImmutableMultimap.<Service, Authority>builder() 
         .put(Service.SFP1, Authority.ROLE_PREMIUM) 
         .put(Service.SFP, Authority.ROLE_PREMIUM) 
         .put(Service.SFE, Authority.ROLE_EXTRA) 
         .put(Service.SF, Authority.ROLE_STANDARD) 
         .put(Service.SK, Authority.ROLE_STANDARD) 
         .put(Service.SFP1, Authority.ROLE_ADMIN) 
         .put(Service.ADMIN, Authority.ROLE_ADMIN) 
         .put(Service.NONE, Authority.ROLE_DENY) 
         .build(); 
   
       // Whole magic is here: 
       private static final ImmutableMultimap<Authority, Service> ROLES_TO_SERVICES_MAPPING = 
         SERVICES_TO_ROLES_MAPPING.inverse(); 
       // before guava-11.0 it was: ImmutableMultimap.copyOf(Multimaps.invertFrom(SERVICES_TO_ROLES_MAPPING, HashMultimap.<Authority, Service>create())); 
   
       public static ImmutableSet<Authority> getRoles(final Service service) { 
        return Sets.immutableEnumSet(SERVICES_TO_ROLES_MAPPING.get(service)); 
       } 
   
       public static ImmutableSet<Service> getServices(final Authority role) { 
        return Sets.immutableEnumSet(ROLES_TO_SERVICES_MAPPING.get(role)); 
       } 
   } 
   

2. Si realmente quiere que su Multimapa sea modificable, que será difícil de mantener tanto K-> V y V-> Variantes K a menos que solo modifiques kToVMultimap y llames al invertFrom cada vez que quieras tener su copia invertida (y haciendo que esa copia no se pueda modificar para asegurarte de que accidentalmente no modifique vToKMultimap lo que no actualizaría kToVMultimap). Esto no es óptimo, pero debería hacerlo en este caso.

3. (¿No es su caso, probablemente, como se ha mencionado bono): BiMap interfaz y las clases que implementan tiene .inverse() método que da BiMap<V, K> vista desde BiMap<K, V> y sí después biMap.inverse().inverse(). Si this issue que mencioné antes está hecho, probablemente tendrá algo similar.

4. (EDIT de octubre de 2016) También puede utilizar new graph API que estará presente en Guava 20:

   En su conjunto, común.gráfico soporta gráficas de las siguientes variedades:

   • gráficos dirigidos
   • grafos no dirigidos
   • nodos y/o bordes con valores asociados (pesos, etiquetas, etc.)
   • gráficos que hacen/no hacer permitir la libre bucles
   • gráficos que dO/no permiten bordes paralelos (gráficos con bordes paralelos a veces se llaman multigrafos)
   • gráficos cuyos nodos/bordes son inserción ordenada, ordenados o no ordenada

Answer 2

Esperanza te tengo

class A { 
    long id; 
    List<B> bs; 
} 

class B { 
    long id; 
    List<A> as; 
} 

Answer 3

¿Qué hay de malo en tener dos mapas, número->> valores, las teclas de la derecha valores-?

Answer 4

La implementación de Google Guava MultiMap es lo que estoy usando para estos fines.

Map<Key Collection<Values>> 

donde Collection puede ser una ArrayList por ejemplo. Permite mapear múltiples valores almacenados en una colección a una clave. Espero que esto ayude!

Answer 5

espero usando MultivaluedMap soluciona el problema. Encuentre la documentación del enlace de Oracle a continuación.

http://docs.oracle.com/javaee/6/api/javax/ws/rs/core/MultivaluedMap.html

Answer 6

Usando Google guayaba podemos escribir una BiMulitMap primitiva de la siguiente manera.

import java.util.Collection; 

import com.google.common.collect.ArrayListMultimap; 
import com.google.common.collect.Multimap; 

public class BiMultiMap<K,V> { 

    Multimap<K, V> keyToValue = ArrayListMultimap.create(); 
    Multimap<V, K> valueToKey = ArrayListMultimap.create(); 

    public void putForce(K key, V value) { 
     keyToValue.put(key, value); 
     valueToKey.put(value, key); 
    } 

    public void put(K key, V value) { 
     Collection<V> oldValue = keyToValue.get(key); 
     if (oldValue.contains(value) == false) { 
      keyToValue.put(key, value); 
      valueToKey.put(value, key); 
     } 
    } 

    public Collection<V> getValue(K key) { 
     return keyToValue.get(key); 
    } 

    public Collection<K> getKey(V value) { 
     return valueToKey.get(value); 
    } 

    @Override 
    public String toString() { 
     return "BiMultiMap [keyToValue=" + keyToValue + ", valueToKey=" + valueToKey + "]"; 
    } 

} 

Esperamos que ayude a algunas de las necesidades básicas de la bi-direccional Multi mapa. Tenga en cuenta que K y V deben implementar el método hascode y equals correctamente