java重点学习-集合-CSDN博客

本文链接：https://blog.csdn.net/qq_40453972/article/details/142081586

七集合

7.1 复杂度分析

7.2 数组

1.数组(Array)是一种用连续的内存空间存储相同数据类型

数据的线性数据结构。

2.数组下标为什么从0开始

寻址公式是:baseAddress+i*dataTypeSize，计算下标的内存地址效率较高

3.查找的时间复杂度

随机(通过下标)查询的时间复杂度是O(1)
查找元素(未知下标)的时间复杂度是O(n)
查找元素(未知下标但排序)通过二分查找的时间复杂度是O(logn)

4.插入和删除时间复杂度

插入和删除的时候，为了保证数组的内存连续性，需要挪动数组元素，平均时间复杂度为O(n)

7.3 ArrayList 底层实现

7.4 ArrayList底层的实现原理是什么

ArrayList底层是用动态的数组实现的
ArrayList初始容量为0，当第一次添加数据的时候才会初始化容量为10
ArrayList在进行扩容的时候是原来容量的1.5倍，每次扩容都需要拷贝数组
ArrayList在添加数据的时候
- 确保数组已使用长度(size)加1之后足够存下下一个数据
- 计算数组的容量，如果当前数组已使用长度+1后的大于当前的数组长度，则调用grow方法扩容(原来的1.5倍)
- 确保新增的数据有地方存储之后，则将新元素添加到位于size的位置上。
- 返回添加成功布尔值。

7.5 ArrayList list=new ArrayList(10)中的list扩容几次

7.6 如何实现数组和list之间的转换

数组转List ，使用JDK中java.util.Arrays工具类的asList方法
List转数组，使用List的toArray方法。无参toArray方法返回Object数组，传入初始化长度的数组对象，返回该对象数组

7.7 ArrayList 和 LinkedList 的区别是什么?

7.7.1单向链表

链表中的每一个元素称之为结点(Node)
物理存储单元上，非连续、非顺序的存储结构
单向链表:每个结点包括两个部分:一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。记录下个结点地址的指针叫作后继指针 next

7.7.2 双向连表

7.8 什么是二叉树

1.什么是二叉树

每个节点最多有两个“叉”，分别是左子节点和右子节点。
不要求每个节点都有两个子节点，有的节点只有左子节点，有的节点只有右子节点。
二叉树每个节点的左子树和右子树也分别满足二叉树的定义

2.什么是二叉搜索树

二叉搜索树(Binary Search Tree,BST)又名二叉查找树，有序二叉树
在树中的任意一个节点，其左子树中的每个节点的值，都要小于这个节点的值而右子树节点的值都大于这个节点的值
没有键值相等的节点
通常情况下二叉树搜索的时间复杂度为O(logn)

在二叉树中，比较常见的二又树有:

满二叉树
完全二叉树
二叉搜索树
红黑树

7.9 红黑树

红黑树(Red Black Tree):也是一种自平衡的二叉搜索树(BST)，之前叫做平衡二叉B树(Symmetric Binary BTree)

红黑树(Red BlackTree):也是一种自平衡的二叉搜索树(BST)
所有的红黑规则都是希望红黑树能够保证平衡
红黑树的时间复杂度:查找、添加、删除都是O(logn)

7.10 散列表(Hash Table)，哈希表/Hash表

散列表(Hash Table)又名哈希表/Hash表，是根据键(Key)直接访问在内存存储位置值 (Value)的数据结构，它是由数组演化而来的，利用了数组支持按照下标进行随机访问数据的特性

1.什么是散列表?

散列表(Hash Table)又名哈希表/Hash表
根据键(Key)直接访问在内存存储位置值(Value)的数据结构
由数组演化而来的，利用了数组支持按照下标进行随机访问数据

2.散列冲突

散列冲突又称哈希冲突，哈希碰撞
指多个key映射到同一个数组下标位置

3.散列冲突-链表法(拉链)

数组的每个下标位置称之为桶(bucket)或者槽(slot)
每个桶(槽)会对应一条链表
hash冲突后的元素都放到相同槽位对应的链表中或红黑树中

7.11 HashMap的实现原理

HashMap的数据结构:底层使用hash表数据结构，即数组+链表或红黑树

1.当我们往HashMap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
2.存储时，如果出现hash值相同的key，此时有两种情况。
- a.如果key相同，则覆盖原始值;
- b.如果key不同(出现冲突)，则将当前的key-value放入链表或红黑树中
3.获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。

7.12 HashMap的jdk1.7和jdk1.8有什么区别

●JDK1.8之前采用的拉链法，数组+链表

OJDK1.8之后采用数组+链表+红黑树，链表长度大于8且数组长度大于64则会从链表转化为红黑树

7.13 HashMap的put方法的具体流程

HashMap源码分析

HashMap的put方法的具体流程

1.判断键值对数组table是否为空或为nul，否则执行resize()进行扩容(初始化)
2.根据键值key计算hash值得到数组索引
3.判断table[i]==nul，条件成立，直接新建节点添加
4.如果table[i]==nul,不成立
- 4.1 判断table[]的首个元素是否和key一样，如果相同直接覆盖value
- 4.2 判断table[] 是否为treeNode，即table 是否是红黑树，如果是红黑树，则直接在树中插入键值对
- 4.3 遍历tablel，链表的尾部插入数据，然后判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，遍历过程中若发现key已经存在直接覆盖value
5.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold(数组长度*0.75)，如果超过，进行扩容。

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

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)
//如果未初始化，调用resize方法 进行初始化
            n = (tab = resize()).length;
//通过 & 运算求出该数据(key)的数组下标并判断该下标位置是否有数据
        if ((p = tab[i = (n - 1) & hash]) == null)
//如果没有，直接将数据放在该下标位置
            tab[i] = newNode(hash, key, value, null);
//该数组下标有数据的情况
        else {
            Node<K,V> e; K k;
//判断该位置数据的key和新来的数据是否一样
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
//如果一样，证明为修改操作，该节点的数据赋值给e,后边会用到
                e = p;
//判断是不是红黑树
            else if (p instanceof TreeNode)
//如果是红黑树的话，进行红黑树的操作
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//新数据和当前数组既不相同，也不是红黑树节点，证明是链表
            else {
//遍历链表
                for (int binCount = 0; ; ++binCount) {
//判断next节点，如果为空的话，证明历到链表尾部了
                    if ((e = p.next) == null) {
//把新值放入链表尾部
                        p.next = newNode(hash, key, value, null);
//因为新插入了一条数据，所以判断链表长度是不是大于等于8
                        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;
                }
            }
//判断e是否为空(e值为修改操作存放原数据的变量)
            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;
    }

7.14 HashMap源码分析-扩容

在添加元素或初始化的时候需要调用resize方法进行扩容，第一次添加数据初始化数组长度为16，以后每次每次扩容都是达到了扩容阈值(数组长度*0.75)
每次扩容的时候，都是扩容之前容量的2倍;
扩容之后，会新创建一个数组，需要把老数组中的数据挪动到新的数组中
- 没有hash冲突的节点，则直接使用 e.hash &(newCap-1)计算新数组的索引位置
- 如果是红黑树，走红黑树的添加
- 如果是链表，则需要遍历链表，可能需要拆分链表，判断(e.hash & oldCap)是否为0，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上

//扩容-初始化数组
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
//如果当前数组为nu11的时候，把oldcap老数组容量设置为0
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
//老的扩容阈值
        int oldThr = threshold;
        int newCap, newThr = 0;
//判断数组容量是否大于0，大于0说明数组已经初始化
        if (oldCap > 0) {
//判断当前数组长度是否大于最大数组长度
            if (oldCap >= MAXIMUM_CAPACITY) {
//如果是，将扩容阈值直接设置为int类型的最大数值并直接返回
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
//如果在最大长度范围内，则需要扩容0ldcap<<1等价于oldcap*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);
        }
        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;
//判断当前下标为j的数组如果不为空的话赋值个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节点
                            next = e.next;
//通过 与操作 计算得出结果为0
                            if ((e.hash & oldCap) == 0) {
//如果低位尾为nu11，证明当前数组位置为空，没有任何数据
                                if (loTail == null)
//将e值放入低位头
                                    loHead = e;
//低位尾不为nu11，证明已经有数据了
                                else
//将数据放入next节点
                                    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;
    }