java - Java: レガシ型 Dictionary のインスタンスを Map に変換する

Question

API 互換性の理由から、 type のインスタンスを返すライブラリを呼び出していますが、 をjava.util.Dictionary実装するインスタンスが必要ですjava.util.Map。

java.util.Dictionaryインスタンスをインスタンスに簡単に変換するにはどうすればよいjava.util.Mapですか?

Answer 1

これは、この変換を自分でプログラムする方法です (Dictionaryジェネリック型引数があるという追加の仮定の下で)。

メソッドを追加する

public static <K, V> Map<K, V> addDictionaryToMap(Dictionary<K, V> source, Map<K, V> sink) {
    for (Enumeration<K> keys = source.keys(); keys.hasMoreElements();) {
        K key = keys.nextElement();
        sink.put(key, source.get(key));
    }
    return sink;
}

たとえば、 で呼び出しますaddDictionaryToMap(dict, new HashMap<String, String>())。

Answer 2

これを実装する 1 つの興味深い方法は、ビュー アプローチを使用することです。これにより、Dictionaryと をMapリンクさせ、両方を完全に機能させることができます。次のコード例に示すように:

Dictionary<String, String> dict = new Hashtable<>();

dict.put("PT", "Portugal");
dict.put("CH", "Switzerland");
System.out.println(dict);

Map<String, String> map = MapUtils.asMap(dict);
System.out.println(map);

map.remove("CH");
dict.put("UK", "United Kingdom");
System.out.println(dict);
System.out.println(map);

map.clear();
System.out.println(dict);
System.out.println(map);

実装は次のようになります。

public class MapUtils {
    public static  <K, V> Map<K, V> asMap(Dictionary<K, V> dict) {
        return new AbstractMap<K, V>() {
            @Override
            public Set<Entry<K, V>> entrySet() {
                return new AbstractSet<Entry<K, V>>() {
                    @Override
                    public Iterator<Entry<K, V>> iterator() {
                        return new Iterator<Entry<K, V>>() {
                            private Enumeration<K> keys = dict.keys();
                            private Enumeration<V> elements = dict.elements();
                            private K k = null;

                            @Override
                            public boolean hasNext() {
                                return keys.hasMoreElements();
                            }

                            @Override
                            public Entry<K, V> next() {
                                k = keys.nextElement();
                                return new SimpleEntry<>(k,
                                        elements.nextElement());
                            }

                            @Override
                            public void remove() {
                                if (k == null) {
                                    throw new IllegalStateException();
                                }
                                dict.remove(k);
                                k = null;
                            }
                        };
                    }

                    @Override
                    public int size() {
                        return dict.size();
                    }
                };
            }

            @Override
            public int size() {
                return dict.size();
            }

            @Override
            public boolean containsKey(Object key) {
                return dict.get(key) != null;
            }

            @Override
            public V get(Object key) {
                return dict.get(key);
            }

            @Override
            public V put(K key, V value) {
                return dict.put(key, value);
            }

            @Override
            public V remove(Object key) {
                return dict.remove(key);
            }
        };
    }
}

一部のオーバーライドされたメソッドはオプションですが、パフォーマンス上の理由から実装しました。

Answer 3

public static <K, V> Map<K, V> valueOf(Dictionary<K, V> dictionary)この種のメソッドの命名スタイルに従うことをお勧めします。そして、グアバの人たちに、それをMapsクラスに追加するように依頼します。

public static <K, V> Map<K, V> valueOf(Dictionary<K, V> dictionary) {
  if (dictionary == null) {
    return null;
  }
  Map<K, V> map = new HashMap<K, V>(dictionary.size());
  Enumeration<K> keys = dictionary.keys();
  while (keys.hasMoreElements()) {
    K key = keys.nextElement();
    map.put(key, dictionary.get(key));
  }
  return map;
}