Collections.newSetFromMap使用场景

在看Spring源码的时候，偶然看到了BeanUtils.java类中有

private static final Set<Class<?>> unknownEditorTypes =
            Collections.newSetFromMap(new ConcurrentReferenceHashMap<>(64));

之前没看到过newSetFromMap这种用法，基本上都是直接new HashSet。
进入Collections类查看newSetFromMap方法的注释：

    /*
    *Returns a set backed by the specified map. The resulting set displays the same ordering, concurrency, and performance characteristics as the backing map. In essence, this factory method provides a Set implementation corresponding to any Map implementation. There is no need to use this method on a Map implementation that already has a corresponding Set implementation (such as HashMap or TreeMap).
    *Each method invocation on the set returned by this method results in exactly one method invocation on the backing map or its keySet view, with one exception. The addAll method is implemented as a sequence of put invocations on the backing map.
    *The specified map must be empty at the time this method is invoked, and should not be accessed directly after this method returns. These conditions are ensured if the map is created empty, passed directly to this method, and no reference to the map is retained, as illustrated in the following code fragment:
    *          Set<Object> weakHashSet = Collections.newSetFromMap(
    *              new WeakHashMap<Object, Boolean>());
    *       
    *
    *Params:
    *map – the backing map
    *Type parameters:
    *<E> – the class of the map keys and of the objects in the returned set
    *Returns:
    *the set backed by the map
    *Throws:
    *IllegalArgumentException – if map is not empty
    *Since:
    *1.6
    */
    public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
        return new SetFromMap<>(map);
    }

    /**
     * @serial include
     */
    private static class SetFromMap<E> extends AbstractSet<E>
        implements Set<E>, Serializable
    {
        private final Map<E, Boolean> m;  // The backing map
        private transient Set<E> s;       // Its keySet

        SetFromMap(Map<E, Boolean> map) {
            if (!map.isEmpty())
                throw new IllegalArgumentException("Map is non-empty");
            m = map;
            s = map.keySet();
        }

        public void clear()               {        m.clear(); }
        public int size()                 { return m.size(); }
        public boolean isEmpty()          { return m.isEmpty(); }
        public boolean contains(Object o) { return m.containsKey(o); }
        public boolean remove(Object o)   { return m.remove(o) != null; }
        public boolean add(E e) { return m.put(e, Boolean.TRUE) == null; }
        public Iterator<E> iterator()     { return s.iterator(); }
        public Object[] toArray()         { return s.toArray(); }
        public <T> T[] toArray(T[] a)     { return s.toArray(a); }
        public String toString()          { return s.toString(); }
        public int hashCode()             { return s.hashCode(); }
        public boolean equals(Object o)   { return o == this || s.equals(o); }
        public boolean containsAll(Collection<?> c) {return s.containsAll(c);}
        public boolean removeAll(Collection<?> c)   {return s.removeAll(c);}
        public boolean retainAll(Collection<?> c)   {return s.retainAll(c);}
        // addAll is the only inherited implementation

        // Override default methods in Collection
        @Override
        public void forEach(Consumer<? super E> action) {
            s.forEach(action);
        }
        @Override
        public boolean removeIf(Predicate<? super E> filter) {
            return s.removeIf(filter);
        }

        @Override
        public Spliterator<E> spliterator() {return s.spliterator();}
        @Override
        public Stream<E> stream()           {return s.stream();}
        @Override
        public Stream<E> parallelStream()   {return s.parallelStream();}

        private static final long serialVersionUID = 2454657854757543876L;

        private void readObject(java.io.ObjectInputStream stream)
            throws IOException, ClassNotFoundException
        {
            stream.defaultReadObject();
            s = m.keySet();
        }
    }

可以看出来这个方法是从JDK1.6开始提供的，用于生成对Map进行包装的Set。这个Set和被包装的Map拥有相同的key顺序（遍历Set调用的还是Map的keySet），相同的并发特性（也就是说如果对ConcurrentHashMap进行包装，得到的Set也将线程安全）。本质上来说，这个工厂方法（newSetFromMap）就是提供了一个和Map实现相对应的Set实现。但并不是所有的Map实现类都需要用这个工厂方法转换成Set的，例如已经有了对应Set实现的HashMap（已经有了HashSet），TreeMap（TreeSet）。

你可以用这个工厂包装WeakHashMap来生成一个Set（可以看作是WeakHashSet），因为并没有WeakHashSet这个现成的Set类可用。

参考文章：
1.http://www.jguru.com/faq/view.jsp?EID=1348143