集合深度学习08—Map

集合深度学习08—Map_第1张图片

一、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;
 }

你可能感兴趣的:(集合,java,java)