Why abstract implementation is returned by Map.values()?

user_9044051 0
Viewed 100
Map<Integer, String> map = new TreeMap<>();
map.put(1, "String1");
map.put(2, "String2");
map.put(3, "String3");

I wanted to convert the map's values to set. I know I could easily do

Set<String> set = new HashSet<>(map.values());

While thinking about this, I was curious what is map.values() by itself anyway? So I tried this

System.out.println("Set:"+ (map.values() instanceof Set));      
System.out.println("List:"+ (map.values() instanceof List));    
System.out.println("Queue:"+ (map.values() instanceof Queue));
System.out.println("SortedSet:"+ (map.values() instanceof SortedSet));

And the output surprisingly was

Set:false
List:false
Queue:false
SortedSet:false

This is all the documentation says.

a collection view of the values contained in this map

I then looked at the decompiled class file. 

public Collection<V> values() {
    if (values == null) {
        values = new AbstractCollection<V>() {
            public Iterator<V> iterator() {
                return new Iterator<V>() {
                    private Iterator<Entry<K,V>> i = entrySet().iterator();

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public V next() {
                        return i.next().getValue();
                    }

                    public void remove() {
                        i.remove();
                    }
                };
            }

            public int size() {
                return AbstractMap.this.size();
            }

            public boolean isEmpty() {
                return AbstractMap.this.isEmpty();
            }

            public void clear() {
                AbstractMap.this.clear();
            }

            public boolean contains(Object v) {
                return AbstractMap.this.containsValue(v);
            }
        };
    }
    return values;
}

Why does java return an abstract implementation instead of List/Set/Queue which could be immediately compatible with use cases?

collections java
3 Answers

I don't know which Java version you are using, but I don't see an abstract class instance returned by values(). It returns an instance of TreeMap.Values, which is a class that extends AbstractCollection.

As to why it doesn't return a Set - that's simply due to the fact that the collection of values may contain duplicates, which a Set doesn't allow.

A List is also not ideal, since it would imply the values are ordered, which is not true for all Map implementations (such as HashMap).

BTW, instead of printing things like map.values() instanceof Set, you could have simply printed map.value().getClass().getName() to see the actual implementation class.

user_12215710

One reasons just from looking at the implementation: contains and iterator both look at the current contents of the map as opposed to the contents of the map when values() was called.

If you call values() and then change something in the map that change will be reflected in the Collection originally returned from values().

Map<String, String> map = new HashMap<String, String>();
map.put("some", "thing");
Collection<String> values = map.values();
System.out.println(values.size()); // 1
map.put("foo", "bar");
System.out.println(values.size()); // 2
user_24428040

Hashset internally uses HashMap hence there is not much copy of values occured in the scenario.

You can see related link to get more about it. Reference Link.

where has coming to abstract collection, Below are some of Related information fetched from Java Doc:

1] This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface.

2] To implement an unmodifiable collection, the programmer needs only to extend this class and provide implementations for the <tt>iterator</tt> and <tt>size</tt> methods. (The iterator returned by the <tt>iterator</tt> method must implement <tt>hasNext</tt> and <tt>next</tt>.

3] To implement a modifiable collection, the programmer must additionally override this class's <tt>add</tt> method (which otherwise throws an UnsupportedOperationException), and the iterator returned by the iterator method must additionally implement its remove method.

Hope this was helpful.

user_44228820
Related