JAVA基础篇之集合

于 2021-05-20 10:13:21 发布
阅读量157 收藏
点赞数
分类专栏： JAVA八股文 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_28014809/article/details/117065057
版权

集合

集合主要分为两大类，一个是实现Collection接口的，一个是Map接口。

在这里插入图片描述

ArrayList

数据结构： Object[] 数组， 线程不安全，有序

jdk7 默认初始容量为10，扩容为原来1.5倍
jdk8 默认初始容量为0，第一 add时候扩容，容量为原来1.5倍

扩容机制：

调用 add方法添加元素的时候，会执行 ensureCapacityInternal(size + 1);来保证数组空间足够，如果不够时会调用grow来进行扩容，扩容方法 int newCapacity = oldCapacity + (oldCapacity >> 1); 新容量大小为旧容量的1.5倍。数据复制使用Arrays.copyOf(elementData, newCapacity);

快速失败机制：

快速失败是JAVA集合的一种错误检测机制。在使用迭代器对集合进行遍历的时候，我们在多线程下操作非线程安全的集合类可能就会触发 fail-fast, 导致抛出ConcurrentModificationException异常。另外，单线程环境下，如果遍历过程中对集合对象的内部进行了修改的话也会触发fail-fast。

modCount 用来记录ArrayList结构发生变化的次数。“结构变化”是指添加或删除至少一个元素的操作，或者调整内部数据的大小，仅仅是设置元素的值不算“结构变化”。

使用迭代器遍历时默认传入当前数组的modCount,每次操作都会进行检测。

LinkedList

数据结构：Node[], 线程不安全，有序

    //Node节点结构
	private static class Node<E> {
        E item;
        //下个节点
        Node<E> next;
        //上个节点
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

LinkedList 基于双向链表实现，使用Node存储节点信息。

方法作用
element() 和 getFirst()获取第一个元素，空则抛NoSuchElementException
peek()获取第一个元素，空则返回null
remove() 和 removeFirst()移除头元素并返回，如果列表为空则抛NoSuchElementException
poll()移除头元素并返回，列表为空则返回null

CopyOnWriteArrayList

看名字就知道这个是 读写分离的list， 线程安全的，适用于读多写少的操作。

写操作在一个复制数组上进行，读操作在原始数组上进行，读写分离。
写操作需要加锁，读操作不加锁。
写操作结束后需要把原始数组指向新的复制数组。


    //写的代码
	public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

    //读的代码
    public E get(int index) {
        return get(getArray(), index);
    }

HashSet

数据结构：底层是HashMap实现，key为存储的元素，value为Object对象；线程不安全，数据不重复。

    
	public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
	// PRESENT为下面Object对象
	private static final Object PRESENT = new Object();

LinkedHashSet

数据结构： 底层是LinkedHashMap

TreeSet

数据结构： 底层是TreeMap

HashMap

HashMap 底层使用的是动态数组， JDK1.7是数组+链表，JDK1.8 数组+链表或红黑树。

下面以jdk 8为例进行说明：

存储元素：Node节点的数组

transient Node<K,V>[] table;

内部成员变量说明：

变量说明
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;初始化容量大小 16
static final int MAXIMUM_CAPACITY = 1 << 30;最大容量 2^30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f;扩容因子，当前容量75%扩容。
0.75原因是时间与空间的一种平衡，若负载因子为1，那么在出现大量的hash膨胀的情况下，元素会较密集，并且都是用链表或者红黑树的方式连接，导致查询效率较低。 若负载因子为0.5 那么就会造成空间的浪费，元素分布较为稀疏。
int threshold;当前所能容纳键值对最大值，超过则扩容。
transient int size;键值对数量
static final int TREEIFY_THRESHOLD = 8;链表转红黑树阈值，链表长度超过这个则转为红黑树

红黑树

红黑树一种自平衡二叉树，比普通二叉树效率高，时间复杂度为 O(logN)。
普通二叉树在极端情况下可能退化为链表，导致查找效率下降。红黑树通过定义一些性质，将任意节点的左右子树高度差控制在规定范围内，以达到平衡。定义如下：
	1、节点只有两种，红色或者黑色。
	2、根节点为黑色。
	3、所有叶子节点都是黑色（叶子是NIL节点）
	4、每个红色节点必须有两个黑色子节点。（从根节点到每个叶子节点不能有两个连续红色节点。）
	5、从任一节点到每个叶子节点的所有简单路径都包含相同数量黑色节点。
红黑树的操作和其他二叉树一样，但是插入和删除要复杂的多，这也是保证其不会退化为链表所付出的代价。红黑树主要通过旋转（左旋或者右旋）变色来保证平衡。

put操作

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;
        // 计算index并对null处理
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //key的hash等于节点hash并且key的值等于节点值，将e指向该键值
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果类型为TreeNode,则调用红黑树的插入方式
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //链表
            else {
                //对链表进行遍历，并统计链表长度
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        //链表中不包含要插入的键值对节点时，则将该节点接在链表的最后，尾插法
                        //1.7则是头插法
                        p.next = newNode(hash, key, value, null);
                        //如果链表长度达到阈值，则转变为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //key已存在，直接覆盖为新的value值
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //判断要出入的value是否
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
    	//超过阈值，扩容
        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;
    	//当table 不为空，说明已经初始化了
        if (oldCap > 0) {
            //不能超过最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //新的阈值为原来2倍
            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;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //计算新resize上限
        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);
                    //链表优化重hash的代码块
                    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;
                            }
                            //原索引 + oldCap
                            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;
                        }
                        //原索引+oldCap放到桶中
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

HashMap并发下扩容问题

jdk7的hashmap链表是头插法，并发下扩容时候可能会产生循环列表。
jdk8采用的是尾插法

ConcurrentHashMap

HashMap 的并发环境下安全版本
JDK1.7 使用的是分段锁机制，其内部类 Segment 继承了 ReentrantLock，将 容器内的数组划分成多段区域，每个区域对应一把锁，相比于 HashTable 确实提升了不少并发能力，但在数据量庞大的情况下，性能依然不容乐观，只能通过不断的增加锁来维持并发性能。

JDK1.8 则使用了 CAS 乐观锁 + synchronized 局部锁 处理并发问题，锁粒度更细，即使数据量很大也能保证良好的并发性。

put操作（jdk8)

	/**
	 * 如果插入位置无元素时候，则使用CAS操作，将Node插入Hash槽中（数组），
	 * 如果出现hash冲突，则使用synchronized局部锁锁住，遍历链表节点，替换对应的node节点或者在尾部插入
	 * node,如果是红黑树，则遍历树节点替换或者增加节点。
	 * 
	 */
final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //cas操作保证线程安全
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //当前在扩容，则先帮助扩容
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                //局部锁
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        //链表
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        //红黑树
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

LinkHashMap

基于HashMap的Node为基础做拓展，添加头尾指针，因此支持顺序访问。

1、LinkedHashMap 继承HashMap,所以和HashMap的底层数据结构是一样的，都是数组+链表+红黑树，扩容机制也一样。
2、LinkedHashMap 通过双向链表来维护的，与HashMap的拉链式是不一样的。
3、LinkedHashMap 存储顺序与添加顺序是一样的，同时可以根据accessOrder参数来决定是否在访问时移动元素，以实现LRU功能（accessOrder = true)。

    /**
     * 在 HashMap.Node节点 的基础上增加了 “前继节点” 和 “后继节点” 这种双向链表的功能特性
     */
    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);
        }
    }

	// 在访问元素之后
    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        // 如果开启LRU(accessOrder = true)并且链表尾部不是该元素，则将该元素放到双向链表的尾巴处
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值