java util包学习（8）Map源码分析

Set 接口的实现类，，虽然实现了Set的方法但是实际上的实现都是基于Map的，Map是键与值的映射关系,键不能重复，Set则是元素不能重复，，如果没有映射关系的Map不就是Set么，，总之它们是很类似的，所以看看Map

package java.util;


public interface Map<K,V> {
  
    int size();

  
    boolean isEmpty();

   
    boolean containsKey(Object key);

   
    boolean containsValue(Object value);

   
    V get(Object key);//根据键去取值

   
    V put(K key, V value);

   
    V remove(Object key);


   
    void putAll(Map<? extends K, ? extends V> m);

   
    void clear();


   
    Set<K> keySet();//键Set

   
    Collection<V> values();//值集合

  
    Set<Map.Entry<K, V>> entrySet();//Set元素就是Map

   
    interface Entry<K,V> {//内部接口
    	
	K getKey();

    	
	V getValue();

    	
	V setValue(V value);

	
	boolean equals(Object o);

	
	int hashCode();
    }

   
    boolean equals(Object o);

   
    int hashCode();
}

AbstractMap

package java.util;
import java.util.Map.Entry;



public abstract class AbstractMap<K,V> implements Map<K,V> {
    
    protected AbstractMap() {
    }

    public int size() {
	return entrySet().size();
    }

    
    public boolean isEmpty() {
	return size() == 0;
    }

  
    public boolean containsValue(Object value) {
	Iterator<Entry<K,V>> i = entrySet().iterator();//Set的迭代器，迭代的就是Map
	if (value==null) {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getValue()==null)
		    return true;
	    }
	} else {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (value.equals(e.getValue()))
		    return true;
	    }
	}
	return false;
    }

    
    public boolean containsKey(Object key) {
	Iterator<Map.Entry<K,V>> i = entrySet().iterator();
	if (key==null) {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getKey()==null)
		    return true;
	    }
	} else {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (key.equals(e.getKey()))
		    return true;
	    }
	}
	return false;
    }

    
    public V get(Object key) {
	Iterator<Entry<K,V>> i = entrySet().iterator();
	if (key==null) {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getKey()==null)
		    return e.getValue();
	    }
	} else {
	    while (i.hasNext()) {
		Entry<K,V> e = i.next();
		if (key.equals(e.getKey()))
		    return e.getValue();
	    }
	}
	return null;
    }


   
    public V put(K key, V value) {
	throw new UnsupportedOperationException();//这个得查查
    }

    
    public V remove(Object key) {
	Iterator<Entry<K,V>> i = entrySet().iterator();
	Entry<K,V> correctEntry = null;
	if (key==null) {
	    while (correctEntry==null && i.hasNext()) {
		Entry<K,V> e = i.next();
		if (e.getKey()==null)
		    correctEntry = e;
	    }
	} else {
	    while (correctEntry==null && i.hasNext()) {
		Entry<K,V> e = i.next();
		if (key.equals(e.getKey()))
		    correctEntry = e;
	    }
	}

	V oldValue = null;
	if (correctEntry !=null) {
	    oldValue = correctEntry.getValue();
	    i.remove();
	}
	return oldValue;//返回值，，貌似null就映射到空了吧,,回去试试
    }


 
    public void putAll(Map<? extends K, ? extends V> m) {
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }

  
    public void clear() {
	entrySet().clear();
    }


   
    public Set<K> keySet() {
	if (keySet == null) {
	    keySet = new AbstractSet<K>() {
		public Iterator<K> iterator() {
		    return new Iterator<K>() {//匿名的内部类，，为什么这么实现呢,也许就是为了回调吧，，调用匿名内部类自己实现的方法
			private Iterator<Entry<K,V>> i = entrySet().iterator();

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

			public K next() {
			    return i.next().getKey();//和原来不一样吧
			}

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

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

		public boolean contains(Object k) {
		    return AbstractMap.this.containsKey(k);
		}
	    };
	}
	return keySet;
    }

   
    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 contains(Object v) {
		    return AbstractMap.this.containsValue(v);
		}
	    };
	}
	return values;
    }

    public abstract Set<Entry<K,V>> entrySet();//抽象方法


   
    public boolean equals(Object o) {
	if (o == this)
	    return true;

	if (!(o instanceof Map))
	    return false;
	Map<K,V> m = (Map<K,V>) o;
	if (m.size() != size())
	    return false;

        try {
            Iterator<Entry<K,V>> i = entrySet().iterator();
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
		K key = e.getKey();
                V value = e.getValue();
                if (value == null) {
                    if (!(m.get(key)==null && m.containsKey(key)))
                        return false;
                } else {
                    if (!value.equals(m.get(key)))
                        return false;
                }
            }
        } catch (ClassCastException unused) {
            return false;
        } catch (NullPointerException unused) {//异常的很好处理，，不会扩散了
            return false;
        }

	return true;
    }

   
    public int hashCode() {
	int h = 0;
	Iterator<Entry<K,V>> i = entrySet().iterator();
	while (i.hasNext())
	    h += i.next().hashCode();//各个累加
	return h;
    }

  
    public String toString() {
	Iterator<Entry<K,V>> i = entrySet().iterator();
	if (! i.hasNext())
	    return "{}";

	StringBuilder sb = new StringBuilder();
	sb.append('{');
	for (;;) {
	    Entry<K,V> e = i.next();
	    K key = e.getKey();
	    V value = e.getValue();
	    sb.append(key   == this ? "(this Map)" : key);
	    sb.append('=');
	    sb.append(value == this ? "(this Map)" : value);
	    if (! i.hasNext())
		return sb.append('}').toString();
	    sb.append(", ");
	}
    }

   
    protected Object clone() throws CloneNotSupportedException {
        AbstractMap<K,V> result = (AbstractMap<K,V>)super.clone();
        result.keySet = null;
        result.values = null;
        return result;
    }

   
    private static boolean eq(Object o1, Object o2) {
        return o1 == null ? o2 == null : o1.equals(o2);
    }

    
    public static class SimpleEntry<K,V>
	implements Entry<K,V>, java.io.Serializable
    {
	private static final long serialVersionUID = -8499721149061103585L;

	private final K key;
	private V value;

      
	public SimpleEntry(K key, V value) {
	    this.key   = key;
            this.value = value;
	}

       
	public SimpleEntry(Entry<? extends K, ? extends V> entry) {
	    this.key   = entry.getKey();
            this.value = entry.getValue();
	}

    	
	public K getKey() {
	    return key;
	}

    	
	public V getValue() {
	    return value;
	}

    	
	public V setValue(V value) {
	    V oldValue = this.value;
	    this.value = value;
	    return oldValue;
	}

	
	public boolean equals(Object o) {
	    if (!(o instanceof Map.Entry))
		return false;
	    Map.Entry e = (Map.Entry)o;
	    return eq(key, e.getKey()) && eq(value, e.getValue());
	}

	
	public int hashCode() {
	    return (key   == null ? 0 :   key.hashCode()) ^
		   (value == null ? 0 : value.hashCode());
	}

        
	public String toString() {
	    return key + "=" + value;
	}

    }

   
    public static class SimpleImmutableEntry<K,V>
	implements Entry<K,V>, java.io.Serializable
    {
	private static final long serialVersionUID = 7138329143949025153L;

	private final K key;
	private final V value;

       
	public SimpleImmutableEntry(K key, V value) {
	    this.key   = key;
            this.value = value;
	}

       
	public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
	    this.key   = entry.getKey();
            this.value = entry.getValue();
	}

    	
	public K getKey() {
	    return key;
	}

    	
	public V getValue() {
	    return value;
	}

    	
	public V setValue(V value) {
            throw new UnsupportedOperationException();
        }

	
	public boolean equals(Object o) {
	    if (!(o instanceof Map.Entry))
		return false;
	    Map.Entry e = (Map.Entry)o;
	    return eq(key, e.getKey()) && eq(value, e.getValue());
	}

	
	public int hashCode() {
	    return (key   == null ? 0 :   key.hashCode()) ^
		   (value == null ? 0 : value.hashCode());
	}

       
	public String toString() {
	    return key + "=" + value;
	}

    }

}

感觉Map比Set List复杂很多啊。。。。看我博客的朋友们给你评价呗，希望能交个朋友啊