Question

我有以下情况。

1）模块A向Modele B发送参数，然后模块B向模块C发出请求以提供该参数的值。（可以有许多请求者，即模块A1，A2等作为模块A）。模块C然后将参数值发送到模块B，然后模块B将值发送回模块A.因此，模块B是中间件。

2）此处模块B为每个请求者（模块A1，A2等）提供唯一的 intKey 。模块C为每个请求者提供唯一的 StringKey 给模块B

3）模块B负责为正确的请求者提供正确的值。这意味着它必须将StringKey映射到intKey。目前，它通过创建两个并发的哈希映射来实现。 i） intKey，StringKey 和ii） StringKey，intKey

现在的问题是模块B必须一直遍历地图以找到正确的请求者（模块A）。

我想知道我是否可以拥有一个数据结构，其中我有两个键，如果我给任何人说Key1，那么我可以检索其对应的key2以及另一种方式。有什么办法可以摆脱这两个并发的Hashmaps吗？我非常感谢有关此事的任何帮助。

Answer 1

基本上没有 - 你不能放弃使用两个地图，无论是并发还是其他，因为你正在使用两种不同类型的密钥（除非你决定使用Map<Object,Object>，这将是犯罪行为。）

但是 - 你可以隐藏复杂性：

public interface BiMap<P, Q> {

    public Q putQ(P key, Q value);

    public Q getQ(P key);

    public P putP(P key, Q value);

    public P getP(Q key);
}

现在将你的两张地图包裹在其中一个看起来更整洁的地方，它们内部并不整洁。

这应该有效：

public class BiMap<P, Q> {

    final Map<P, Q> pq;
    final Map<Q, P> qp;

    public BiMap(MapFactory maker) {
        pq = maker.<P, Q>make();
        qp = maker.<Q, P>make();
    }

    public BiMap() {
        // Default to ConcurrentHashMap
        this(MapFactory.ConcurrentHashMap);
    }

    public Q putQ(P key, Q value) {
        return pq.put(key, value);
    }

    public Q getQ(P key) {
        return pq.get(key);
    }

    public P putP(Q key, P value) {
        return qp.put(key, value);
    }

    public P getP(Q key) {
        return qp.get(key);
    }

    // Puts both at once.
    public synchronized void put(P p, Q q) {
        putQ(p, q);
        putP(q, p);
    }

    public enum MapFactory {

        ConcurrentHashMap {

                    @Override
                    <P, Q> Map<P, Q> make() {
                        return new java.util.concurrent.ConcurrentHashMap<P,Q>();
                    }

                };

        abstract <P, Q> Map<P, Q> make();
    }
}

在java中有两个键的数据结构

1 个答案: