一、Map的常用方法

    增加：put(K key, V value)
    - 如果集合中有这个 key，则替换其value，并返回原value
    - 如果没有，直接添加，并返回 null
    
    删除：
        clear() 
        remove(Object key)
        
    修改：
    
    查看：
        entrySet()  查看键值对集合
        get(Object key) 获取指定键的值
        keySet() 查看键集合
        size() 查看map有效元素数量
        values() 查看值集合
        
    判断：
        containsKey(Object key) map是否包含指定key
        containsValue(Object value) map是否包含指定value
        equals(Object o) 判断两个map是否值相等
        isEmpty() map是否为空

二、Hashtable

Hashtable 是JDK 1.0开始的，效率低，线程安全，key不可以存null值
HashMap 是 JDK 1.2开始的。效率高，线程不安全，key可以存null值，并且key的null值也遵循唯一的特点。

三、LinkedHashMap

底层：哈希表+链表
特点：

1. 唯一
2. 有序（按照输入顺序存入）

四、TreeMap

底层：二叉树，key遵照二叉树的特点

放入集合的key的数据对应的类型内部一定要实现比较器（内部比较器或外部比较器）

特点：

1. 唯一
2. 有序（按照升序或降序）

比如String类型重写了比较器，按字母升序
如果是自己的类，必须写内部比较器 或 外部比较器

内部比较器
@Override
public int cpmpareTo(Student o){
return this,getAge()-o.getAge();
}
外部比较器
new Comparator(){
@Override
public int cpmpareTo(Student o){
return this,getAge()-o.getAge();
}
}

public class TreeMap<K,V>{
        //重要属性：
        //外部比较器：
        private final Comparator<? super K> comparator;
        //树的根节点：
        private transient Entry<K,V> root = null;
        //集合中元素的数量：
        private transient int size = 0;
        //空构造器:
        public TreeMap() {
        comparator = null;//如果使用空构造器，那么底层就不使用外部比较器
    }
        //有参构造器：
        public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;//如果使用有参构造器，那么就相当于指定了外部比较器
    }
        
        public V put(K key, V value) {//k,V的类型在创建对象的时候确定了
        //如果放入的是第一对元素，那么t的值为null
        Entry<K,V> t = root;//在放入第二个节点的时候，root已经是根节点了
                //如果放入的是第一个元素的话，走入这个if中：
        if (t == null) {
                        //自己跟自己比
            compare(key, key); // type (and possibly null) check
                        //根节点确定为root
            root = new Entry<>(key, value, null);
                        //size值变为1
            size = 1;
            modCount++;
            return null;
        }
                
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
                //将外部比较器赋给cpr:
        Comparator<? super K> cpr = comparator;
                //cpr不等于null，意味着你刚才创建对象的时候调用了有参构造器，指定了外部比较器
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);//将元素的key值做比较
                                //cmp返回的值就是int类型的数据：
                                //要是这个值《0 =0  》0
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else//cpm==0
                                //如果key的值一样，那么新的value替换老的value  但是key不变 因为key是唯一的
                    return t.setValue(value);
            } while (t != null);
        }
                //cpr等于null，意味着你刚才创建对象的时候调用了空构造器，没有指定外部比较器，使用内部比较器
        else {
            if (key == null)
                throw new NullPointerException();
            Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);//将元素的key值做比较
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;//size加1 操作
        modCount++;
        return null;
    }
        
        
}
 static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left = null;
        Entry<K,V> right = null;
        Entry<K,V> parent;
        boolean color = BLACK;
 }