Mapeamento Two Way usando única estrutura de dados

Question

deparei com algum código recentemente no trabalho (recriado para ser semelhante ao que estou lidando com) semelhante ao código abaixo

Existe uma maneira que eu possa reformular o código abaixo para usar uma estrutura de dados (com desempenho em mente)? ??

Aqui está um código para ilustrar o que quero dizer:

public class ObjectMapper {

    private Map<UUID,Integer> uuidMap;
    private Map<Integer,UUID> indexMap;

    public ObjectMapper(){
        uuidMap = new HashMap<UUID,Integer>();
        indexMap = new HashMap<Integer,UUID>();
    }

    public void addMapping(int index, UUID uuid){
        uuidMap.put(uuid, index);
        indexMap.put(index, uuid);
    }


    .
    .
    .

    public Integer getIndexByUUID(UUID uuid){
        return uuidMap.get(uuid);
    }

    public UUID getUUIDByIndex(Integer index){
        return indexMap.get(index);
    }


}

Answer 1

Esta é respondida aqui com a recomendação do uso de bitmap de Google Collections

Answer 2

Apache coleções suporta um BidiMap interface e uma variedade de implementações bastante eficazes.

Answer 3

Você pode usar um único Map<Object,Object> para fazer ambos os mapeamentos. Feio, com certeza. O desempenho deve ser mais ou menos o mesmo, ou um pouco melhor no caso improvável de que você tem muitas ObjectMappers com alguns valores mapeados.

Answer 4

Você pode usar bitmap de Eclipse coleções .

BiMap é um mapa que permite aos usuários realizar pesquisas de ambos os sentidos. Ambas as chaves e os valores em um bitmap são únicos.

A principal aplicação é HashBiMap.

inverse()

BiMap.inverse() retorna uma visão onde a posição do tipo de chave e tipo de valor são trocados.

MutableBiMap<Integer, String> biMap =
  HashBiMap.newWithKeysValues(1, "1", 2, "2", 3, "3");
MutableBiMap<String, Integer> inverse = biMap.inverse();
Assert.assertEquals("1", biMap.get(1));
Assert.assertEquals(1, inverse.get("1"));
Assert.assertTrue(inverse.containsKey("3"));
Assert.assertEquals(2, inverse.put("2", 4));

put()

comporta MutableBiMap.put() como Map.put() em um mapa regular, exceto que ele joga quando um valor duplicado é adicionado.

MutableBiMap<Integer, String> biMap = HashBiMap.newMap();
biMap.put(1, "1"); // behaves like a regular put()
biMap.put(1, "1"); // no effect
biMap.put(2, "1"); // throws IllegalArgumentException

forcePut()

Esta se comporta como MutableBiMap.put(), mas silenciosamente remove a entrada do mapa com o mesmo valor antes de colocar o par de valores-chave no mapa.

MutableBiMap<Integer, String> biMap = HashBiMap.newMap();
biMap.forcePut(1, "1"); // behaves like a regular put()
biMap.forcePut(1, "1"); // no effect
biMap.forcePut(1, "2"); // replaces the [1,"1"] pair with [1, "2"]
biMap.put(2, "2"); // removes the [1, "2"] pair before putting
Assert.assertFalse(biMap.containsKey(1));
Assert.assertEquals(HashBiMap.newWithKeysValues(2, "1"), biMap);

Nota:. Eu sou um committer para coleções Eclipse