java基础-容器知识

甲乙Rocket

已于 2022-07-02 23:22:03 修改

阅读量137

点赞数 1

分类专栏： java基础文章标签： java 数据结构开发语言

于 2022-06-09 14:44:31 首次发布

本文链接：https://blog.csdn.net/weixin_46643875/article/details/125202995

版权

java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

学习目标
1、容器类别
2、每种容器的数据结构
3、每种容器的适用场景
4、优缺点

一、Collections【存放单一元素】

1.1List【有序，可重复】

（1）LinkList

数据结构：链表

优点：适合在链表的中间添加和删除元素的场景【注：在尾部操作元素效率还是数组高】
缺点：查询慢【原因：链表需要遍历】

适用场景：增删多的场景

（2）ArrayList

数据结构：数组

优点：检索速度快【数组能根据下标定位】
缺点：对中间的元素进行增删的时候慢【每个内存地址都需要移动】

适用场景：查询多的场景；对尾部增删多的场景

扩容：1.5倍左右，位操作
int newCapacity = oldCapacity + (oldCapacity >> 1);

  - 当不传初始值的时候，赋初始值10；有初始值直接赋值

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 强制初始值10
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

  - 当满的时候进行扩容通过位运算加原来的长度约定于扩容原来的1.5倍；将老list中的值copy到一个新的list中（扩容图片和源码）

在这里插入图片描述

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
    // 扩容算法
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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:
    // 将原来的list中的值copy到新的扩容好的list中
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

（3）Vector【过时：加锁太多，影响效率】

类似ArrayList，不一样的地方就是Vector线程安全，扩容机制不同

1.2Set【不可重复】

（1）HashSet

使用HashMap的key来存储元素，无序

（2）LinkedHashMap

使用HashSet+LinkedList，有序

（3）TreeHash

数据结构：红黑树

总结：Set底层都是map中的key

1.3Queue

（1）LinkedList

略

（2）ArrayDeque

ArrayDeque和LinkedList之间的区别

ArrayDeque 是一个可扩容的数组，LinkedList 是链表结构；
ArrayDeque 里不可以存 null 值，但是 LinkedList 可以；
ArrayDeque 在操作头尾端的增删操作时更高效，但是 LinkedList 只有在当要移除中间某个元素且已经找到了这个元素后的移除才是 O(1) 的；
ArrayDeque 在内存使用方面更高效
不存null值尽量使用ArrayDeque

（3）PriorityQueue

二、Map【k-v方式存放】

（1）HashMap（线程不安全）

JDK8之前
- 数据结构：数组+链表
- 插入方式：头插法（扩容时可能并发死链）
JDK8
- 数据结构：数组+链表+红黑树
- 插入方式：尾插法
基于JDK8
- put流程
  - 1.判断数组是否为空，为空进行初始化

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


      2.计算hash值(n - 1) & hash 定位下标

if ((p = tab[i = (n - 1) & hash]) == null)


      - 3.判断当前的下标是否有值，没有就创建一个node节点存放到当前下标位置处

tab[i] = newNode(hash, key, value, null);


      - 4.存在数据，hash冲突，先判断key是否相同，相等就使用新的value进行替换

 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

      - 5.不相等的话，就判断当前节点是不是树型节点，是树型节点就以树节点的方式插入

p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);


      - 6.如果不是树型节点就以链表节点的方式插入，并且判断数组的长度是否大于64（底层先通过数组扩容的方式提高查询效率），链表的长度是否大于8，若满足就将链表转化为红黑树

else {
                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;
                }
            }


      - 7.插入完成后判断当前节点是否大于阈值，如果大于的话将数组的大小扩容为原来的两倍

 if (++size > threshold)
            resize();// 调用该方法

hash算法（原始key的hash值和数组的长度进行取模）=》优化：（n-1）&hash

目标：
为什么数组的长度是2^n;
hash值的优化为什么；