1

だから、私は2つのハッシュマップを持っています

public HashMap<String, Integer> map1 = new HashMap<String,Integer>();

public HashMap<String, Integer> map2 = new HashMap<String,Integer>();

これらの両方のハッシュマップをマージしたハッシュマップを作成したいと考えています。

また、これら 2 つのハッシュマップのいずれかに要素を追加すると、次のようになります。

map1.put("key",1);

3 番目のハッシュマップにはこの変更が必要です

解決：

import java.util.*;
public final class JoinedMap {
static class JoinedMapView<K,V> implements Map<K,V> {
    private final Map<? extends K,? extends V>[] items;
    public JoinedMapView(final Map<? extends K,? extends V>[] items) {
        this.items = items;
    }

    @Override
    public int size() {
        int ct = 0;
        for (final Map<? extends K,? extends V> map : items) {
            ct += map.size();
        }
        return ct;
    }

    @Override
    public boolean isEmpty() {
        for (final Map<? extends K,? extends V> map : items) {
            if(map.isEmpty()) return true;
        }
        return false;
    }

    @Override
    public boolean containsKey(Object key) {
        for (final Map<? extends K,? extends V> map : items) {
            if(map.containsKey(key)) return true;
        }
        return false;
    }

    @Override
    public boolean containsValue(Object value) {
        for (final Map<? extends K,? extends V> map : items) {
            if(map.containsValue(value)) return true;
        }
        return false;
    }

    @Override
    public V get(Object key) {
        for (final Map<? extends K,? extends V> map : items) {
            if(map.containsKey(key)){
                return map.get(key);
            }
        }
        return null;
    }

    @Override
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public V remove(Object key) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear() {
        for (final Map<? extends K,? extends V> map : items) {
            map.clear();
        }
    }

    @Override
    public Set<K> keySet() {
        Set<K> mrgSet = new HashSet<K>();
        for (final Map<? extends K,? extends V> map : items) {
            mrgSet.addAll(map.keySet());
        }
        return mrgSet;
    }

    @Override
    public Collection<V> values() {
        Collection<V> values = new ArrayList<>();
        for (final Map<? extends K,? extends V> map : items) {
            values.addAll(map.values());
        }
        return values;
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        throw new UnsupportedOperationException();
    }
}

/**
 * Returns a live aggregated map view of the maps passed in.
 * None of the above methods is thread safe (nor would there be an easy way
 * of making them).
 */
public static <K,V> Map<K,V> combine(
        final Map<? extends K, ? extends V>... items) {
    return new JoinedMapView<K,V>(items);
}

private JoinedMap() {
}
}
4

3 に答える 3

0

1 つのマップを使用して、読み取り元のマップに基づいて取得したデータをフィルター処理できます。2 つのマップ間の衝突をどのように処理するかによって異なります。衝突が必要ない場合は、次を使用できます。

private Map<String, Integer> map = newHashMap<>():

void putInMap1(String key, Integer value) {
    map.put(key + "_1", value);
}

void putInMap2(String key, Integer value) {
    map.put(key + "_" + 1, value);
}

Integer getFromMap1(String key) {
     return map.get(key + "_1");
}

Integer getFromMap2(String key) {
     return map.get(key + "_2");
}

List<Integer> getFromMap3(String key) {
     List<Integer> res = new ArrayList<>();
     Integer map1Val = getFromMap1(key);
     if (map1Val != null) {
        res.add(map1Val);
     }
     Integer map2Val = getFromMap2(key);
     if (map2Val != null) {
        res.add(map2Val);
     }
     return res;
}
于 2013-10-10T12:48:27.030 に答える