Java集合知识详解

北小风
145 阅读8分钟

「这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」

List

UMI类图

image-20211026215501491

ArryayList

底层扩容原理

​

未指定初始化长度的扩容：

第一次进入的时候，计算出minCapacity的值，然后检测是否需要进行扩容操作，然后判断当前长度是否够用，不够就进行grow()1.5倍扩容，最后进行数组的拷贝；

无参构造器构造一个空数组

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

使用有参构造器构造ArrayList

image-20211023180500597

第一步：先确定是否要扩容，在进行赋值操作

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

第二步：确认minCapacity(DEFAULTCAPACITY_EMPTY_ELEMENTDATA默认为10)

数组为空给个默认值，否则就是原来的

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;// 第一次为10
    }

第三步：检测是否需要进行扩容操作

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)// 如果大于当前数组的长度就进行扩容
            grow(minCapacity);
    }

第四步：核心——对数组进行1.5倍的扩容

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);// 1.5倍速
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);// 进行数组的拷贝
    }

image-20211023151114099

Vector

一般用JUC当中的绝对线程安全的集合。Wlectbor只是相对安金。addcremove这些方法不是原子操作。所以逐是别用VectorD

构造器：

public Vector() {
        this(10);
    }

Vector vector=new Vector(8,6);// 指定初始大小和扩容因子

 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

扩容原理：

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);// 双倍扩容
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

LinkList

尾入头出

构造函数：

 public LinkedList() {
    }

add()方法底层：

  void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

image-20211023194943114

remove()方法

public E remove() {
        return removeFirst();
    }

// 判断头节点是否为空，为空则报错！
 public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);// 如果头节点不为空，把头结点传入函数
    }

 private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

image-20211023202721568

Set

HashSet

底层原理：

1、底层是HashMap

2、添加一个元素时，先得到hash值 会转换成-》索引值

3、找到存储数据表table，看这个索引位置是否已经存放的有元素

如果没有，直接加入；

如果有，掉用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后

4、底层是数组加链表

5、在java8中，如果有一条链表的元素个数到达TREEIFY_THRESHOLD（默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY（默认是64）就会进行树化（红黑树）

初始化：

public HashSet() {
        map = new HashMap<>();
    }

// 返回null表示添加成功，返回对象的地址表示失败！
public boolean add(E e) {
        return map.put(e, PRESENT)==null;//  private static final Object PRESENT = new Object();
    }

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }


// 调用hashcode()方法计算出hash值
 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 减少hash碰撞的概率
    }



 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
     
     // 1、根据key得到hash（根据hash值判断索引值） 去计算key应该存放到table表的哪个索引位置，并把这个位置的对象赋值给P
     // 2、判断p 是否为null
     // 2.1、如果p为null，表示还没有存放元素，就创建一个Node(key="java",value=PRESENT)
     
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            // p是数组中下标为i = (n - 1) & hash]的node节点
            // 如果p的hash值和要加入节点的hash值一样，就返回当前节点的值
            // 如果当前索引位置对应的链表的第一个元素和准备添加的hash值一样
            // 并且满足 下面两个条件之一：
            //（1） 准备加入的key和p指向的Node节点的key是同一个对象
            // (2) p指向Node节点的key的equals()和准备key比较后相同
            
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 在判断p是不是一颗红黑树；
            // 如果是一颗红黑树，就调用putTreeVal，进行添加
            
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // hash值决定的索引相同，但内容不同，就在链表的最后一个位置加上元素
                // 如果table对应的索引位置已经是一个链表，就使用for循环进行比较
                for (int binCount = 0; ; ++binCount) {
                    //(1) 依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
                    // 注意在把元素添加到链表后1，立即判断 该链表是否已经达到8个结点，
                    // 如果达到就调用treeifyBin() 对当前这个链表进行树化（转成红黑树）
                    // 注意，在转成红黑树时，要进行判断，判断条件
                    // 如果上面条件成立，先table扩容
                    // 如果条件不成立，才进行转换成红黑树
                    //(2) 依次和该链表的每一个元素比较过程中，如果有相同的个情况，就直接break
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value; // 新值覆盖旧值
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
         // 当我们向hashset增加一个元素，->Node->加入table，就算是增加了一个
        //  如果当前容量超过预警容量，进行扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }




final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold 两倍扩容
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY; // 初始化容量为16
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//预处理
    }
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;// 预警容量
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;// 完成扩容操作
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

image-20211024205256684

转换成红黑树机制：

  • HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值(threshold)是16*加载因子（loadFactor）是0.75=12

  • 如果table数组使用到了临界值12，就会扩容到16 * 2=32，新的临界值就是32 * 0.75=24，以此类推。

  • 如果一条链表的元素个数到达TREEIFY_THRESHOLD（默认是8），并且table的大小>=MIN_TREEIFY_CAPACITY（默认64），就会进行树化（红黑树），否则任然采用数组扩容机制

    ==成功放入第九个元素后开始判断转红黑树，第13个元素后开始扩容==

    ==hash值相同，并且值相同就不放进去==

    ==hash值决定索引的位置==

经典面试题：

        Set set=new HashSet();
        System.out.println(set.add(new String("123")));// true
        System.out.println(set.add(new String("123")));// false

//原因：String 类重写了hashcode()和equal()方法！

LinkedHashSet

1、LinkedHashSet底层是一个LinkedHashMap，维护了数组加双向链表

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

2、LinkedHashSet 加入顺序和取出元素/数据的顺序一致，不允许添加重复数据

3、LinkedHashSet 底层结构（数组table+双向链表）

4、添加第一次时，直接将 数组table扩容到16，存放的节点类型是LinkedHashMap$Entry

5、数组是HashMapNode[]存放的元素/数组是LinkedHashMapNode[] 存放的元素/数组是LinkedHashMapEntry类型

image-20211025193006813

// LinkedHashMap的匿名内部类
static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

// HashMap
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

TreeSet

底层原理

底层为一个TreeMap

public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

	// 把比较器赋值给TreeMap的属性——comparator
  public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
    }

添加元素

1、开始根节点root为空，第一个元素直接加入进去

2、然后判断是否有用户自定义的比较器

3、通过比较为新插入的key在树中找到合适的位置

public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }


  public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
           // 开始根节点root为空，第一个元素直接加入进去
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator<? super K> cpr = comparator;// 比较器赋值
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);// 通过自定义的比较方法进行比较
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    // 如果数据key相同，进行覆盖值的操作
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
            // 用户没有自定义比较器，采用默认的比较去
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.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++;
        modCount++;
        return null;
    }

Map

UMI类图

image-20211026215532703

HashMap

特点：

  • 和Collection并列，且存储类型为key-value
  • Mapkey，value可以为任意类型,会封装到HashMap$Node对象中
  • key不能重复，value可以重复
  • null可以作为key，不能重复；null也可以放在value上
  • 根据对应的key可以取出对应的value,key-value是单向一对一关系

map存取原理

1、k-v 最后是hashMap$Node node=new Node(hash,key,value,null)

2、k-v 为了方便程序员的遍历，还会创建EntrySet集合，该集合存放的元素的类型是Entry，

而一个Entry对象就有k,v EntrySet<Entry<k,v>> Set<Map.Entry<K, V>> entrySet();

3、entrySet中，定义的类型是 Map.Entry, 但是实际上存放的还是HashMap$Node

这是因为 static class Node<K,V> implements Map.Entry<K,V>

4、当把HashMap$Node 对象存放到 entrySet 就方便我们的遍历，因为 Map.Entry 提供了重要方法

K getKey(); V getValue();

底层原理

进行map的初始化，执行构造器，初始化加载因子（0.75）

 public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

根据key计算出hash值，然后进行putValue()

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

判断table是否为空，为空或者length=0进行扩容，扩容到16

if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

// 如果table为null，旧容量为0，旧的缓冲容量初始化为0，新容量、新缓冲容量为0
Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;

// 新容量初始化为16；新缓冲容量为16*0.75=12；	
 else {       
     // zero initial threshold signifies using defaults
      newCap = DEFAULT_INITIAL_CAPACITY;
      newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }

threshold = newThr;// 更新缓冲容量

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];// table底层是一个Node数组

返回初始化的新table，容量为16

image-20211026093206242

把值不断更新进table中

  // 取出hash值对应的table的索引位置的Node,如果为null,就直接把加入的k-v，创建成一个Node，加入该位置
if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

// 第二次加入重复的key，取出来的p不为空，进入else
// 如果table的索引位置的key的hash相同和新的key的hash值相同，
// 并满足（table现有的节点的key和准备添加的key是同一个对象  ||  equals返回真）
// 就认为不能加入新的k-v

            else{
             Node<K,V> e; K k;
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;// 把当前节点赋值给e
            }
            else {
                for (int binCount = 0; ; ++binCount) {   // 死循环
                    if ((e = p.next) == null) {// 如果整个链表（e==null），没有和他相同，就加入到该链表的最后				
                        // 尾插法
                        p.next = newNode(hash, key, value, null);
                        // 加入后，判断当前链表的个数，是否已经到达8个，8个后就调用treeifyBin()树化
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 如果在循环比较过程中，发现有相同，就break，就只是替换val
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
                
				//e为空，说明加入了新元素
			 if (e != null) { // existing mapping for key
                 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;// 把新value值跟key绑定
                afterNodeAccess(e);
                return oldValue;
            }

关于树化

当前链表的长度>8,并且table的长度>=64，会进行红黑树转化

// 链表的长度>8,进行判断              
for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }


 final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
     // 如果table为null，或者大小还没有到64，暂时不会树化，而是进行扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

HashTable

特点：

1）存放的元素是键值对：即 k-V

2） hashtable的键和值都不能为null,否则会抛出NullPointerException

3） hashTable是线程安全的（synchronized），hashMap是线程不安全的

底层原理：

1）底层有数组 Hashtable$Entry[] 初始化大小为11

2）临界值 threshold 8=11*0.75

3）扩容：按照自己的扩容机制来进心即可

初始化，调用父类构造器,初始长度为11，加载因子为0.75

 public Hashtable() {
        this(11, 0.75f);
    }

放入键值对，带有synchronized是线程安全的

public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();// value==null,报空指针异常
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;// table是个Entry数组
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;// 根据hash求出下标
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);// table对应的下标为null，直接添加元素
        return null;
    }

table是个Entry数组

image-20211026151046957

添加元素

private void addEntry(int hash, K key, V value, int index) {
    modCount++;

    Entry<?,?> tab[] = table;
    if (count >= threshold) {
        // 当前table中的数据个数超过缓冲量，进行扩容
        // Rehash the table if the threshold is exceeded
        rehash();

        tab = table;
        hash = key.hashCode();
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    @SuppressWarnings("unchecked")
    // 封装数据，然后放入到table中
    // 采用头插法
    Entry<K,V> e = (Entry<K,V>) tab[index];
    tab[index] = new Entry<>(hash, key, value, e);
    count++;// 更新table总共存放数据的个数
}


 protected Entry(int hash, K key, V value, Entry<K,V> next) {
            this.hash = hash;
            this.key =  key;
            this.value = value;
            this.next = next;
        }

table扩容

protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;// 拷贝一份旧数据 

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;// 二倍加一扩容
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

        modCount++;
    	// 重置缓冲区
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;
		
    	// 把旧map中的数据放回到扩容后的map中
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
                Entry<K,V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K,V>)newMap[index];
                newMap[index] = e;
            }
        }
    }

Properties

1、Properties类继承自Hashtable类并且实现了Map接口，也是使用了一种键值对的形式来保存数据

2、使用特点和HashTable类似

3、Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改

4、说明：工作后 xxx.properties文件通常作为配置文件

TreeMap

底层原理：

// 把自定义的比较器给自身的属性
public TreeMap(Comparator<? super K> comparator) {
        this.comparator = comparator;
}

第一次添加元素


Entry<K,V> t = root;
if (t == null) {
    compare(key, key); // type (and possibly null) check
	// 封装好数据，赋值给root属性
    // 注意节点数据时Entry类型
    root = new Entry<>(key, value, null);
    size = 1;
    modCount++;
    return null;
}

// 判断第一个key不能为null，为空抛出异常
final int compare(Object k1, Object k2) {
        return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
            : comparator.compare((K)k1, (K)k2);
    }

第二次添加元素时

int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
Comparator<? super K> cpr = comparator;
if (cpr != null) {
    do {
        // 循环找到可以依附的父节点1
        parent = t;
        cmp = cpr.compare(key, t.key);
        if (cmp < 0)
            t = t.left;
        else if (cmp > 0)
            t = t.right;
        else
            return t.setValue(value);
    } while (t != null);
}
else {
    // key不能为Null
    if (key == null)
        throw new NullPointerException();
    @SuppressWarnings("unchecked")
        Comparable<? super K> k = (Comparable<? super K>) key;
    do {
        parent = t;
        cmp = k.compareTo(t.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);// 选取红黑树的颜色
// 更新map中数据的数量
size++;
// 更新操作的次数
modCount++;
return null;
avatar
文章
阅读
粉丝
相关推荐
Java集合系列之LinkedHashMap
23k阅读
 · 
140点赞
Java集合（1）一 集合框架
4.7k阅读
 · 
91点赞
扯淡 Java 集合
1.6k阅读
 · 
35点赞
Java集合框架
2.1k阅读
 · 
5点赞
Java集合类
1.8k阅读
 · 
5点赞