Java中的两种方式集合

Question

我有一个对象列表。这些对象被赋予一个 ID 并存储在哈希表中。如果我需要一个具有特定 ID 的对象，我只是说：

ht.get(ID);

但是，有时我需要获取给定对象的 ID：

ht.get(Object);

我的第一个想法是使用两个不同的哈希表；一个用于 ID ->对象映射和其他对象-> ID 映射。

这听起来是一个足够好的解决方案吗？

Answer 1

如果您无法使用外部集合（因为您似乎不想使用给定的一条评论），您可以编写一个简单的类来执行您想要的操作（是的，这本质上是您的第一个想法），沿着（我没有编译这个，这只是第一个想法，所以可能是一个坏主意，等等...）：

编辑：现在有两个版本，一个允许重复值，一个不允许。如果值被覆盖，则不这样做的将删除该键。

此版本不允许重复值：

class Foo<K, V>
{
    private final Map<K, V> keyValue;
    private final Map<V, K> valueKey;

    {
        keyValue = new HashMap<K, V>();
        valueKey = new HashMap<V, K>();
    }

    // this makes sure that if you do not have duplicate values.
    public void put(final K key, final V value)
    {
        if(keyValue.containsValue(value))
        {
            keyValue.remove(valueKey.get(value));
        }

        keyValue.put(key, value);
        valueKey.put(value, key);
    }

    public V getValueForKey(final K key)
    {
        return (keyValue.get(key));
    }

    public K getKeyForValue(final V value)
    {
        return (valueKey.get(value));
    }

    public static void main(final String[] argv)
    {
        Foo<String, String> foo;

        foo = new Foo<String, String>();
        foo.put("a", "Hello");
        foo.put("b", "World");
        foo.put("c", "Hello");

        System.out.println(foo.getValueForKey("a"));
        System.out.println(foo.getValueForKey("b"));
        System.out.println(foo.getValueForKey("c"));

        System.out.println(foo.getKeyForValue("Hello"));
        System.out.println(foo.getKeyForValue("World"));
    }
}

此版本允许重复值，并返回具有给定值的所有键的列表：

class Foo<K, V>
{
    private final Map<K, V> keyValue;
    private final Map<V, List<K>> valueKeys;

    {
        keyValue = new HashMap<K, V>();
        valueKeys = new HashMap<V, List<K>>();
    }

    public void put(final K key, final V value)
    {
        List<K> values;

        keyValue.put(key, value);

        values = valueKeys.get(value);

        if(values == null)
        {
            values = new ArrayList<K>();
            valueKeys.put(value, values);
        }

        values.add(key);
    }

    public V getValueForKey(final K key)
    {
        return (keyValue.get(key));
    }

    public List<K> getKeyForValue(final V value)
    {
        return (valueKeys.get(value));
    }

    public static void main(final String[] argv)
    {
        Foo<String, String> foo;

        foo = new Foo<String, String>();
        foo.put("a", "Hello");
        foo.put("b", "World");
        foo.put("c", "Hello");

        System.out.println(foo.getValueForKey("a"));
        System.out.println(foo.getValueForKey("b"));
        System.out.println(foo.getValueForKey("c"));

        System.out.println(foo.getKeyForValue("Hello"));
        System.out.println(foo.getKeyForValue("World"));
    }
}

隐藏类中的两个映射是一个好主意，因为稍后您会找到更好的方法您需要做的就是替换类的内部结构，其余代码保持不变。

Answer 2

如果使用外部库没问题，你应该检查 google 集合上的 BiMap：
http://google-collections。 googlecode.com/svn/trunk/javadoc/com/google/common/collect/BiMap.html

Answer 3

您正在寻找的是双向地图。您可以在实现 commons 集合 的类中找到它/commons.apache.org/collections/apidocs/org/apache/commons/collections/BidiMap.html" rel="nofollow noreferrer">BidiMap 界面或 Google Guava。

Answer 4

您正在寻找的是双向地图。
尝试 Apache Collections BidiMap。

http://commons.apache.org/集合/api-3.1/org/apache/commons/collections/BidiMap.html

Answer 5

并不是说我立即知道，但你可以构建一个......拥有一个对象集合和多个查找结构（哈希图或树）怎么样，这些结构不存储对象本身（出于节省内存的原因），而是存储索引你的单品收藏？通过这种方式，您可以使用所需的适当查找结构（Id -> object 或反之亦然）返回一个整数值，您可以将其索引到原始集合中。这样，您可以执行的不仅仅是双向查找，以防将来需要这样做。