Java：將遺留類型Dictionary的實例轉換為Map

Question

我正在調用一個庫，出於API兼容性原因，它返回一個java.util.Dictionary類型的實例，但我希望有一個實現java.util.Map的實例。

如何輕松地將java.util.Dictionary實例轉換為java.util.Map實例？

Answer 1

使用Guava和Java 8：

Iterator<String> keysIter = Iterators.forEnumeration(dict.keys());
Map<String, Object> dictCopy = Maps.toMap(keysIter, dict::get);

純Java 8的替代方案：

List<String> keys = Collections.list(dict.keys());
Map<String, Object> dictCopy = keys.stream()
           .collect(Collectors.toMap(Function.identity(), dict::get)); 

Answer 2

這就是我自己編程這種轉換的方式（在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 3

我更喜歡使用public static <K, V> Map<K, V> valueOf(Dictionary<K, V> dictionary)命名這種方法的方式。 我會請guava家伙將它添加到他們的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;
}

Answer 4

一種有趣的實現方法是使用視圖方法，它允許您將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);
            }
        };
    }
}

一些重寫的​​方法是可選的，但出於性能原因我實現了它們。