// 獲取對(duì)應(yīng)的key
K getKey();

// 獲取對(duì)應(yīng)的value
V getValue();

// 替換原有的value
V setValue(V value);

// 希望我們實(shí)現(xiàn)equals和hashCode
boolean equals(Object o);
int hashCode();

// 從1.8起，還提供了比較的方法，類似的方法共四個(gè)
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
        return (Comparator<Map.Entry<K, V>> & Serializable)
            (c1, c2) -> c1.getKey().compareTo(c2.getKey());
}

// 返回當(dāng)前數(shù)據(jù)個(gè)數(shù)
int size();

// 是否為空
boolean isEmpty();

// 判斷是否包含key，這里用到了key的equals方法，所以key必須實(shí)現(xiàn)它
boolean containsKey(Object key);

// 判斷是否有key保存的值是value，這也基于equals方法
boolean containsValue(Object value);

// 通過key獲取對(duì)應(yīng)的value值
V get(Object key);

// 存入key-value
V put(K key, V value);

// 移除一個(gè)key-value對(duì)
V remove(Object key);

// 從其他Map添加
void putAll(Map<? extends K, ? extends V> m);

// 清空
void clear();

// 返回所有的key至Set集合中，因?yàn)閗ey是不可重的，Set也是不可重的
Set<K> keySet();

// 返回所有的values
Collection<V> values();

// 返回key-value對(duì)到Set中
Set<Map.Entry<K, V>> entrySet();

// 希望我們實(shí)現(xiàn)equals和hashCode
boolean equals(Object o);
int hashCode();

transient Set<K>        keySet;
transient Collection<V> values;

// 返回大小，這里大小基于entrySet的大小
public int size() {
    return entrySet().size();
}

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

//基于entrySet操作
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 boolean containsValue(Object value) {
    //...
}

public V get(Object key) {
    //...
}

public V remove(Object key) {
    //...
}

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

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = 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 isEmpty() {
               return AbstractMap.this.isEmpty();
            }

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

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