关于JAVA集合

最新推荐文章于 2024-06-09 20:40:58 发布

凌晨的咸鱼

最新推荐文章于 2024-06-09 20:40:58 发布

阅读量463

点赞数 4

分类专栏： java 文章标签： Java集合

本文链接：https://blog.youkuaiyun.com/qq_34989804/article/details/83243002

版权

java 专栏收录该内容

7 篇文章

订阅专栏

一、集合是什么？

java集合类存放与java.util包中，是一个用来存放对象的容器。

注意：

集合只能存放对象。比如存放一个int i = 1，其实是自动转换成Integer类之后存入的。
集合存放的是多个对象的引用，对象本身还存储在堆中。
集合可以存放不同类型，不限数量的数据类型。

二、Java集合框架

总的框架图：
https://img-blog.youkuaiyun.com/20160124221843905

Collection集合体系：

Map集合体系：
Map

注意：以下有序和无序的概念——>有序指的是输出元素的顺序和插入元素的顺序一致，反之则无序。

List接口（父接口是Collection接口，可以使用Iterator迭代器遍历集合）：

元素可重复
可以插入多个null值
有序容器
常用的实现类：ArrayList，LinkedList和Vector（线程安全的，几乎被淘汰了）
以下都是有序。可重复的集合
|- ArrayList：基于数组实现的，查询快，增删慢，线程不安全
|- LinkedList：基于双向链表实现的，查询慢，增删快，线程不安全
|- Vector：基于数组实现的，查询快，增删慢，线程安全，几乎淘汰

Set接口（父接口是Collection接口，可以使用Iterator迭代器遍历集合）：

元素不可重复
无序容器
只允许一个null值
常用的实现类：HashSet、LinkedHashSet以及TreeSet
|- HashSet：无序，不可重复，基于HashMap实现的；使用HashSet存储的对象，注意正确重写其equals和hashcode方法，以保证放入的对象的唯一性。大佬详解

|- LinkedHashSet：有序，不可重复，继承于HashSet，又基于LinkedHashSetMap实现；大佬详解

|- TreeSet：排好序的，不可重复，基于TreeMap实现的，存储的类需要实现Comparable接口并重写compareTo()方法，这样存入TreeSet的元素可以自动排序。
如何实现排序，

Map接口（一个接口，无法使用Iterator迭代器）：

Map存储的是键值对（Entry类），一个Key和一个Value，Map存储的Value可能相等，当Key值是唯一的
Map里可以有多个null值（Value），但只能有一个null键（Key）
常用的实现类：HashMap，LinkedHashMap，TreeMap和 HashTable（线程安全的）

关于HashMap：

详解1
详解2，JDK1.8
JDK1,8的HashMap

1、什么是HashMap：

HashMap是基于哈希表的Map接口的非同步实现，即它是非线程安全的，存储的是Key-Value键值对，允许多个null值Value，但只允许有一个null键Key。

2、HashMap的数据结构：

JDK1.8之前是HashMap基于数组+链表实现的（即链地址法）；
JDK1.8之后变为数组+链表+红黑树，当链表节点较少的时候仍然是以链表存在，当链表节点大于8时，会在添加新元素的同时将原来的单链表转为红黑树（查询的时间复杂度是 O(logn) 级别的）。

简单介绍一下关于HashMap的存储：
JDK1.8中，HashMap存储Node节点，Node是HashMap中的一个内部类，实现了Map.Entry接口，实质就是一个键值对。

3、如何定位哈希桶数组的索引位置：

比如：map.put(“name”,“zhang”); 如何定位
（1）通过Key值的hashCode()方法计算出Key的hashCode值
（2）将hashCode值的高16为参与高位运算，计算hash值。（JDK1.8中，将hashCode的高16位与hashCode值进行异或运算(不同为1相同为0)）。
（3）将计算出来的hash值与**(table.length-1)进行位于(&)运算**（即indexFor()方法），得出键值对的存储位置

4、hash冲突：

有时两个不同的Key会定位到同一位置，这就叫Hash碰撞，或叫Hash冲突。那如何解决Hash冲突呢？
（1）链地址法（默认）：就是我们说的数组+链表，将产生冲突的Entry放在表头。
（2）开放地址法：也称为再散列法，基本思想：当发生冲突时，按照某种方法继续探测哈希表中的其他存储单元。
（3）再哈希法：发生冲突时，使用哈希函数重新计算hash值，直到无冲突。比如上面第一次按照姓首字母进行哈希，如果产生冲突可以按照姓字母首字母第二位进行哈希，再冲突，第三位，直到不冲突为止。

5、HashMap的get()方法的调用过程：

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
 
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // table不为空 && table长度大于0 && table索引位置(根据hash值计算出)不为空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {    
        if (first.hash == hash && 	// 总是先检查索引位置处的第一个节点
            ((k = first.key) == key || (key != null && key.equals(k)))) 
            return first;	// first的key等于传入的key则返回first对象
        if ((e = first.next) != null) { // 向下遍历
            if (first instanceof TreeNode)  // 判断是否为TreeNode
            	// 如果是红黑树节点，则调用红黑树的查找目标节点方法getTreeNode
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 走到这代表节点为链表节点
            do { // 向下遍历链表, 直至找到节点的key和传入的key相等时,返回该节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;    // 找不到符合的返回空
}

（1）首先对table桶数组进行检验，检验table是否为空，长度length是否大于0，数组索引位置处的节点（first）是否为空。
（2）检查first节点的hash值和key是否和入参一样，若一样则直接返回firs节点。
（3）first节点不是目标节点，接着判断first的next节点，若first的next节点不为空，继续向下遍历
（4）这时该判断是链表结构还是红黑树结构了；红黑树就是用getTreeNode()方法查找目标节点，链表就普通的遍历链表查找目标节点。
（5）查找不到就返回为null。

6、HashMap的put方法的调用过程：

public V put(K key, V value) {
    // 对key的hashCode()做hash
    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;
    // 步骤①：tab为空则创建
    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存在，直接覆盖value
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 步骤④：判断该链为红黑树
        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) {
                    p.next = newNode(hash, key,value,null);
                     //链表长度大于8转换为红黑树进行处理
                    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;
            }
        }
        
        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;
}

hashmap-put方法

（1）判断数组table是否为空或者length==0，是则执行resize()扩容操作。
（2）根据Key值计算hash值得到插入的数组的索引位置i，如果table[i]==null（该节点为空），则直接插入
（3）如果table[i]该节点不为空，判断table[i]的首个元素是否和key一样，若key相等则覆盖value值
（4）若不相等，则需要先判断是红黑树还是链表，然后再遍历插入节点（遍历过程中若有Key已经存在则直接覆盖）；注意如果是链表结构，还需要判断链表长度是否大于8，大于8的话需要将链表转换成红黑树，然后再执行插入操作；
（5）插入成功后，通过判断来决定是否要进行扩容。

7、HashMap的扩容机制：

首先了解几个HashMap的两个关键参数：

initialCapacity：初始容量，默认初始容量为16，即table数组的长度
loadFactor：负载因子，默认为0.75。

怎样会导致扩容： 当向容器中添加元素时，判断(容器中的元素个数) >= (当前数组的长度*负载因子)时，就会自动进行扩容。

扩容过程： 扩容时，需要新建一个长度为之前数组2倍的新数组，然后将当前数组中的Entry对象全部移动到新数组中。扩容后的数组长度是之前的2倍。而元素在新数组的位置只能是**（原数组索引的位置）或（原索引的位置+旧数组的长度）**。

8、HashMap并发环境下的问题

这是HashMap在并发环境下使用中最为典型的一个问题，就是在HashMap进行扩容重哈希时导致Entry链形成环。一旦Entry链中有环，势必会导致在同一个桶中进行插入、查询、删除等操作时陷入死循环。

JDK1.7和JDK1.8在扩容上的区别：

JDK1.7时：需要对元素重新计算hash，计算出在新数组中的索引位置。
JDK1.8时：只需要判断原来的hash值新增的那个位是1还是0，是0的话索引没变，是1的话变成“原索引+旧数组长度”。

8、HashMap与HashTable：

HashMap是线程不安全的，HashTable线程安全，是使用synchronized锁住。
HashMap允许一个null的Key和多个null的Value，而HashTable不允许有null的key和value。
扩容方式不同：HashMap初始容量16，扩容时变为原来的2倍；HashTable初始容量11，扩容时变为2n+1

补充：多线程有更好的ConcurrentHashMap，单线程使用HashMap。

关于ConcurrentHashMap：

1、ConcurrentHashMap的存储结构：

ConcurrentHashMap

ConcurrentHashMap采用**“分段锁”策略，ConcurrentHashMap的主干是一个Segment数组**。

Segment继承了ReentrantLock，所以它是一种可重入锁。如上图，在ConcurrentHashMap中，一个Segment就是一个哈希表，Segment里维护了一个HashEntry数组，并发下，对于不同的Segment的数据进行操作是不用考虑锁竞争的。（默认下ConcurrentHashMap初始容量为16，理论上允许16个线程并发执行）。

每个Segment就像一个HashMap。

注意：ConcurrentHashMap不允许Key和Value为null

2、关于Segment

在Segment类中，有一个count变量，是volatile的，相当于计数器，表示该Segment中包含的HashEntry对象的个数。每一个Segment对象中都有一个count变量——>因为这样需要更新计数器时，就不用锁定整个ConcurrentHashMap。

还有一个modCount，用于统计Segment结构改变的次数。

3、同步方式：

对于读操作（get），并不需要加锁，有三点保证了读操作不需要加锁：

利用HashEntry对象的不变性，HashEntry中的key，hash，next指针都是final的。
Value值是使用volatile修饰的，保证value被更新后其他线程读到的是最新值。
若读时发生指令重排序，则加锁重读。

对于写操作（put），只对该Key-value键值对所在的Segment数组加锁，然后想操作一个HashMap一样去操作该Segment。不会影响其他Segment的操作。

获取Segment的锁时，使用了自旋锁，循环tryLock获取锁。

4、JDK1.8的改动

JDK1.8放弃了分段锁，直接使用一个大数组，然后基于CAS实现。
JDK1.8使用了CAS操作来实现更高的并发度，在CAS操作失败时使用内置锁Synchronized。
并且在链表长度超过8时会将链表转换为红黑树。

ConcurrentHashMap演进从Java7到Java8

上面提到一个CAS，介绍一下
CAS是什么？
CAS是英文单词CompareAndSwap的缩写，中文意思是：比较并替换。是一种实现并发算法时常用到的技术，
CAS需要有3个操作数：当前内存值V，期望值A，新值B。

CAS指令执行时，当且仅当要更新的值V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作

CAS会产生的“ABA”问题：
如果内存地址V初次读取的值是A，并且在准备赋值的时候检查到它的值仍然为A，那我们就能说它的值没有被其他线程改变过了吗？
如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。 Java并发包为了解决这个问题，提供了一个**带有标记的原子引用类“AtomicStampedReference”，**它可以通过控制变量值的版本来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。

其余可能的问题

1、HashMap与HashSet的区别：
（1）HashMap存储的是键值对，HashSet存储的是对象元素
（2）HashMap实现的是Map接口，HashSet实现的是Set接口
（注意：HashSet底层基于HashMap实现的，存储的对象元素实际上存到了底层HashMap中的Key值中，所以HashSet的值不允许重复，且可以为null值）