Java 在不统一接口的情况下组合哈希表

由于很多实现原因（使用JavaMe1.4和非常有限的库），我无法访问HashMap或任何类型的Map接口。与此相结合，我必须使用Hashtable，在我使用的库中，Hashtable不继承任何内容

是的，我绝对没有办法绕过我正在使用的实现和库

所以我有两个哈希表。我需要创建一个新的Hashtable实例来访问和更改两个“backing”实例。既然Hashtable不继承任何内容，有什么方法可以做到这一点吗？我尝试了一种基本的组合策略，它只需要遍历一组表，但它存在一些严重的问题。具体来说，

put（key，object）

很难，因为无法判断它要备份到哪个映射

有没有关于这样做的策略的建议，或者我被卡住了

public class Scope {

    private final Hashtable publicVars;
    private final Hashtable publicMethods;
    private final Hashtable publicReturning;
    private final Hashtable privateVars;
    private final Hashtable privateMethods;

    public Scope() {
        publicMethods = new Hashtable();
        publicReturning = new Hashtable(0);
        publicVars = new Hashtable();
        privateVars = new Hashtable();
        privateMethods = new Hashtable();
    }

    public Scope(Scope scope) {
        publicVars = scope.publicVars;
        publicMethods = scope.publicMethods;
        publicReturning = scope.publicReturning;
        privateVars = new Hashtable();
        privateMethods = new Hashtable();

        // Here's my problem - I need changes made to publicVars to also affect scope.privateVars (and the same to methods)
        publicVars.putAll(scope.privateVars);
        publicMethods.putAll(scope.privateMethods);
    }

私有静态最终类映射组{
私有最终列表映射=新的ArrayList（）；
公共映射组（哈希表开始）{
添加（开始）；
}
公共地图组（地图组）{
对于（int x=0；x

---

谢谢你让我想到这些家伙。我写了这篇文章，它对我很有用。

好吧，如果没有办法告诉我要把哪个

映射到
中，那么就没有办法告诉我了。你需要为此制定一个策略。或者使统一的
哈希表不可变。为什么要使一个哈希表更新两个哈希表？为什么不在两个地方使用一个哈希表呢？你想用这个“组合哈希表”解决什么问题？我需要一个哈希表来“向上游”推送更新到它的“父”哈希表。这有什么意义吗？我可能是走错路了。我添加了一个例子，希望能澄清我的想法。
private static final class MapGroup {

    private final List maps = new ArrayList();

    public MapGroup(Hashtable start) {
        maps.add(start);
    }

    public MapGroup(MapGroup group) {
        for (int x = 0; x < group.maps.size(); x++) {
            maps.add(group.maps.get(x));
        }
    }

    public void add(Hashtable h) {
        maps.add(h);
    }

    public Enumeration keys() {
        return new Enumeration() {
            private final Enumeration[] enumerations;
            private int i;

            {
                enumerations = new Enumeration[maps.size()];
                for (int x = 0; x < maps.size(); x++) {
                    enumerations[x] = ((Hashtable) maps.get(x)).keys();
                }
            }

            public boolean hasMoreElements() {
                return enumerations[i].hasMoreElements()
                        || (++i < enumerations.length && enumerations[i].hasMoreElements());
            }

            public Object nextElement() {
                // needed to increment i
                return hasMoreElements() ? enumerations[i].nextElement() : null;
            }
        };
    }

    public Enumeration elements() {
        return new Enumeration() {
            private final Enumeration[] enumerations;
            private int i;

            {
                enumerations = new Enumeration[maps.size()];
                for (int x = 0; x < maps.size(); x++) {
                    enumerations[x] = ((Hashtable) maps.get(x)).elements();
                }
            }

            public boolean hasMoreElements() {
                return enumerations[i].hasMoreElements()
                        || (++i < enumerations.length && enumerations[i].hasMoreElements());
            }

            public Object nextElement() {
                // needed to increment i
                return hasMoreElements() ? enumerations[i].nextElement() : null;
            }
        };
    }

    public boolean contains(Object value) {
        for (int x = 0; x < maps.size(); x++) {
            if (((Hashtable) maps.get(x)).contains(value)) {
                return true;
            }
        }
        return false;
    }

    public boolean containsKey(Object key) {
        for (int x = 0; x < maps.size(); x++) {
            if (((Hashtable) maps.get(x)).containsKey(key)) {
                return true;
            }
        }
        return false;
    }

    public Object get(Object key) {
        for (int x = 0; x < maps.size(); x++) {
            if (((Hashtable) maps.get(x)).containsKey(key)) {
                return ((Hashtable) maps.get(x)).get(key);
            }
        }
        return null;
    }

    public Object put(Object key, Object value) {
        for (int x = 0; x < maps.size(); x++) {
            if (((Hashtable) maps.get(x)).containsKey(key)) {
                return ((Hashtable) maps.get(x)).put(key, value);
            }
        }
        return ((Hashtable) maps.get(maps.size() - 1)).put(key, value);
    }

    public Object remove(Object key) {
        // Nothing is ever removed - don't worry
        return null;
    }

    public void clear() {
    }

    public int size() {
        int s = 0;
        for (int x = 0; x < maps.size(); x++) {
            s += ((Hashtable) maps.get(x)).size();
        }
        return s;
    }

    public boolean isEmpty() {
        return size() == 0;
    }
}