D05 第五部分集合框架任务

通过集合框架了解为什么我们要使用集合？

提供了一种方便、高效和灵活的方式来处理和管理数据集合。

1.数据组织和管理：集合框架允许我们以一种有序或无序的方式组织数据，这样可以更轻松地管理数据。无论是需要查找、插入、删除还是遍历数据，集合框架提供了高效的方法来执行这些操作。

2.去重和唯一性：有些情况下，我们需要存储唯一的元素，而集合框架提供了去重的功能。这样就可以确保集合中不包含重复的元素，简化了数据处理过程。

3.性能优化：集合框架的实现通常经过优化，能够在处理大量数据时保持高效。这包括对插入、删除、查找等操作的高效支持，以及对内存占用的优化。

4.算法和数据结构支持：集合框架提供了多种数据结构的实现，如哈希表、树等，这些数据结构在不同场景下有不同的优势。通过集合框架，我们可以选择最适合当前需求的数据结构，从而优化算法的性能。
集合框架中，list、set、map它们对数据的处理都有什么区别？

一次存1个数据 List：有序，可重复，有索引 Set:无序，不重复，无索引

一次存一对数据：键值（键值对对象） 键不可重复，值可以重复键值一一对应
list集合底层的数据结构都有哪些，它们在数据操作上有什么特点？

数组：查询快，增删慢双向链表：增删快，查询慢
迭代器 Iterator 是类还是接口？如何创建使用？
在Java中，迭代器（Iterator）是接口而不是类。它定义了一种访问集合中元素的方式，而具体的实现则由集合类来提供。

要创建和使用迭代器，需要按照以下步骤进行：

获取集合的迭代器：首先，通过调用集合对象的 iterator() 方法来获取迭代器对象。例如，在ArrayList中，可以使用 iterator() 方法获取一个迭代器。
```
ArrayList<String> list = new ArrayList<>();
// 添加元素到列表
// ...

Iterator<String> iterator = list.iterator();
```
使用迭代器遍历集合：一旦获得了迭代器对象，就可以使用它来遍历集合中的元素。迭代器提供了几个方法来遍历集合：

hasNext()：检查集合中是否还有下一个元素。 next()：返回集合中的下一个元素，并将迭代器移动到下一个位置。 remove()：从集合中移除通过迭代器返回的最后一个元素（可选操作）。
单列集合和双列集合都可以使用迭代器吗？

是的，单列集合（如List、Set）和双列集合（如Map）都可以使用迭代器来遍历其元素。不过需要注意的是，双列集合的迭代器通常是针对其键值对（Entry）的。
Iterator 和 ListIterator 有什么区别？

Iterator：用于单向遍历集合元素的接口，只能向前遍历集合。它提供了三个方法：hasNext()、next() 和 remove()。 ListIterator：是Iterator的子接口，提供了双向遍历列表的功能。除了具有Iterator的三个方法外，ListIterator还增加了向后遍历列表的能力，以及修改列表元素的能力，如 add()、set() 和 previous()。

遍历一个 List集合有哪些不同的方式？举例实现。

1.使用普通for循环：通过索引访问列表中的元素。
List<String> list = new ArrayList<>();
// 添加元素到列表
// ...
for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    // 处理元素
}
2.使用增强for循环：简化了遍历过程，不需要显式地处理索引。
for (String element : list) {
    // 处理元素
}
3.使用Iterator迭代器：提供了一种统一的方式来遍历集合，无需关心底层数据结构。
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    // 处理元素
}
4.使用ListIterator迭代器：可以双向遍历列表，并且可以在遍历的过程中修改列表元素。
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    // 处理元素
}
5.Lambda表达式
List<String> list = new ArrayList<>();
// 添加元素到列表
// ...

// 使用Lambda表达式遍历列表
list.forEach(element -> {
    // 处理元素
    System.out.println(element);
});

如何实现数组和 List 之间的转换？
要实现数组和List之间的转换，可以使用Java提供的Arrays类和Collections类中的静态方法来进行转换。

1.从数组到List：使用Arrays类的asList()方法将数组转换为List。
```
String[] array = {"apple", "banana", "orange"};
List<String> list = Arrays.asList(array);
```
2.从List到数组：使用List的toArray()方法将List转换为数组。
```
List<String> list = new ArrayList<>();
// 添加元素到列表
// ...
String[] array = list.toArray(new String[0]); // 或者指定目标数
```
ArrayList 和 Vector 的区别是什么？Stack呢？

ArrayList 和 Vector 区别：

同步性：ArrayList不是线程安全的，而Vector是线程安全的，所有对Vector的操作都是同步的，因此性能通常较差。 扩容方式：ArrayList每次扩容会增加当前容量的一半，而Vector则会增加当前容量的一倍。 初始容量增长：ArrayList默认初始容量为10，而Vector默认初始容量为10，增量为0。

Stack： Stack继承自Vector，它是一种后进先出（LIFO）的数据结构。与Vector相比，Stack多了push()和pop()方法，分别用于入栈和出栈操作。
插入数据时，ArrayList、LinkedList、Vector谁速度较快？阐述原因。

一般情况下，插入数据时LinkedList的速度较快，因为它是基于链表实现的，插入操作只需要调整链表中相邻节点的指针即可，不需要像ArrayList和Vector那样涉及到数组元素的移动或者容量的调整。

ArrayList的插入速度次之，当插入位置在数组中间时，需要将插入位置之后的所有元素都向后移动一个位置，这个操作的时间复杂度为O(n)，其中n为数组的大小。

Vector由于是线程安全的，插入时需要进行同步操作，因此相对于ArrayList而言，插入速度可能会略慢一些。
HashSet如何检查重复？HashSet是如何保证数据不可重复的？

HashSet检查重复是通过元素的hashCode和equals方法来进行的。当向HashSet中添加元素时，HashSet会首先调用元素的hashCode方法得到其哈希码，然后将哈希码与已有元素的哈希码进行比较，如果哈希码不相等，则直接添加元素；如果哈希码相等，再调用equals方法来比较元素是否相等，如果equals方法返回true，则说明元素重复，不添加到HashSet中。

HashSet保证数据不可重复的原理是基于哈希表（HashMap）实现的，通过哈希码和equals方法来保证元素的唯一性。HashSet内部使用HashMap来存储元素，元素作为HashMap的键，值为一个固定的常量（比如PRESENT），这样就可以利用HashMap的键不可重复的特性来保证HashSet中元素的唯一性。
HashMap 与 HashTable 有什么区别？

线程安全性： HashMap 不是线程安全的，不支持多线程并发操作。 HashTable 是线程安全的，支持多线程并发操作。在每个公共方法上都使用了 synchronized 关键字。

继承关系： HashMap 继承自 AbstractMap 类，实现了 Map 接口。 HashTable 继承自 Dictionary 类，实现了 Map 接口。

空键值处理： HashMap：允许 null 键和 null 值，但只能有一个 null 键。键值对中，键是唯一的，但值可以重复。

Hashtable：不允许 null 键或 null 值，否则会抛出 NullPointerException。键和值均不可重复。

性能： 在单线程环境下，HashMap 的性能通常优于 HashTable。在多线程环境下，由于 HashTable 使用了同步机制，性能可能会受到影响，而 HashMap 不会。
什么是TreeMap，如何决定使用 HashMap 还是 TreeMap？3

使用 HashMap：当不需要按照键的顺序来存储和访问键值对，并且对性能要求较高时，可以选择 HashMap。使用 TreeMap：当需要按照键的自然顺序或者自定义的顺序来存储和访问键值对时，可以选择 TreeMap。另外，如果需要进行区间检索或有序遍历，TreeMap 也是一个不错的选择。
comparable 和 comparator的区别？

Comparable：

Comparable 是一个接口，它强行对实现它的每个类的对象进行整体排序。类实现 Comparable 接口后，必须实现 compareTo 方法，用于定义该类对象的自然顺序。 例如，对于 String 类，字符串的自然顺序是按照字典顺序排列。

Comparator： Comparator 是一个函数式接口，它可以用来对类的对象进行定制排序。 Comparator 接口包含一个 compare 方法，用于定义对象之间的比较规则。通过 Comparator，可以为一个类创建多种不同的排序方式，而不需要修改类本身。 Comparator 通常用于对那些没有实现 Comparable 接口的类进行排序，或者在需要对同一个类进行多种排序方式时使用。
Collection 和 Collections 有什么区别？

Collection： Collection 是 Java 集合框架的顶层接口，表示一组对象的集合。它是所有集合类的父接口，定义了基本的集合操作和行为。 Collection 包括 List、Set 和 Queue 三种主要的子接口。

Collections： Collections 是一个实用类，包含了操作集合的各种静态方法。这些方法包括对集合进行排序、搜索、同步化等操作。 Collections 类中的所有方法都是静态的，不能被实例化。
Array 和 ArrayList 有何区别？

大小： Array 的大小在创建时确定，不能更改。 ArrayList 的大小可以动态增加或减少，根据需要自动调整。

类型： Array 可以存储基本数据类型（如 int、char、double 等）或对象（如 String、自定义类等）。 ArrayList 只能存储对象，不能存储基本数据类型。如果需要存储基本数据类型，可以使用对应的包装类（如 Integer、Character、Double 等）。

二、进阶任务
我们在使用数组时一定会给数组一个长度，那么有些集合的底层实现也用到了数组，它们是如何定义数组的长度的？长度达到上线之后又怎么进行扩容的？

初始长度：在创建集合对象时，会给定一个初始长度。这个初始长度可以是用户指定的或者是一个默认值。

扩容策略： ArrayList：当 ArrayList 的实际元素数量达到当前数组容量的上限时（即当前元素个数等于数组长度），会触发扩容操作。通常情况下，ArrayList 会将当前数组的容量增加一定的比例（如增加一半），然后将所有元素拷贝到新的数组中。

HashMap：当 HashMap 中的元素数量达到当前数组容量的某个阈值时（如负载因子 * 初始容量），会触发扩容操作。HashMap 会创建一个新的更大的数组，然后重新计算所有元素的位置，并将它们存储到新数组中。

HashSet：HashSet 的底层实现是基于 HashMap 的，因此其扩容策略与 HashMap 相同。

扩容后的新长度：通常，扩容后的新长度会根据一定的规则确定，比如 ArrayList 会增加一定的比例，而 HashMap 则是翻倍扩容。这样做的目的是为了减少频繁扩容带来的性能开销。

通过动态调整数组的长度，这些集合类能够灵活地适应不同数量级的元素，从而提高了其灵活性和性能。
说一下 HashSet 的实现原理？

HashSet 是基于 HashMap 实现的，它的实现原理可以简单概括如下：

HashSet 内部维护了一个 HashMap 对象，所有的元素都存储在这个 HashMap 的 key 中，而 value 则统一使用一个固定的常量（比如 PRESENT = new Object()）。

当向 HashSet 中添加一个元素时，实际上是将该元素作为 key 存储到 HashMap 中，而 value 则是一个固定的常量对象。

HashSet 利用 HashMap 的 key 不可重复的特性来保证集合中不会有重复元素。

因此，HashSet 实现了基于哈希表的集合，具有快速的插入和查找操作，但不保证元素的顺序。
HashMap在JDK1.7和JDK1.8中有哪些不同？HashMap的底层实现是什么？

DEFAULT_INITIAL_CAPACITY：数组默认长度16

DEFAULT_LOAD_FACTOR：默认加载因子0.75

链表长度>8 & 数组长度>=64

在 JDK1.7 和 JDK1.8 中，HashMap 的主要区别包括以下几点：

底层数据结构：在 JDK1.7 中，HashMap 使用数组+链表的方式来处理哈希冲突；而在 JDK1.8 中，引入了红黑树来优化处理哈希冲突的情况，即在链表长度超过一定阈值（8）时将链表转换为红黑树，以提高查找性能。

并发安全性：在 JDK1.7 中，HashMap 不是线程安全的，多线程操作时需要额外的同步措施；而在 JDK1.8 中，引入了一种新的实现方式，称为分段锁（Segment），通过将整个存储空间分成多个段（Segment），每个段都类似于一个小的 HashMap，不同段的数据可以并行处理，从而提高了并发性能。

HashMap 的底层实现基于哈希表，它使用数组+链表（或红黑树）的结构来存储键值对。具体实现流程如下：

计算哈希值：根据键对象的 hashCode 方法计算出哈希值，以确定存储位置。

确定存储位置：通过哈希值和数组长度取模的方式确定存储位置，即确定元素在数组中的索引位置。

处理哈希冲突：如果不同的键对象计算出的哈希值相同（发生哈希冲突），则在该位置上形成一个链表（或红黑树），将键值对插入到链表（或红黑树）的末尾。

数组扩容：当元素数量达到数组容量的某个阈值时，会触发数组的扩容操作，通常是将数组容量翻倍，并将原有元素重新散列到新数组中。

存储键值对：将键值对存储到确定的位置上，如果有相同键的元素，则覆盖原有的值。
HashMap的put方法的具体流程？

计算键的哈希值： 首先，调用键对象的 hashCode() 方法计算其哈希值。如果键为 null，则哈希值为 0。

确定存储位置： 将哈希值通过哈希函数转换成数组的索引位置。通常使用的方法是取哈希值对数组长度取模，以得到一个在数组范围内的索引值。

处理哈希冲突： 如果在计算出的索引位置上已经存在元素（发生了哈希冲突），则需要处理冲突。在 JDK 1.7 中，采用的是链地址法，即在同一索引位置的元素使用链表存储；而在 JDK 1.8 及之后的版本中，采用的是链地址法结合红黑树，当链表长度超过阈值（默认为 8）时，将链表转化为红黑树。

插入键值对： 如果计算出的索引位置上没有元素（即没有发生哈希冲突），或者已经存在的元素使用红黑树进行存储，直接将键值对插入到该位置即可。如果使用链表存储且没有发生哈希冲突，将新的键值对插入到链表的末尾。

判断是否需要进行扩容： 在插入完键值对后，会检查当前元素数量是否达到了负载因子（load factor）所定义的阈值。如果达到或超过了阈值，则进行扩容操作。

扩容操作： 创建一个新的更大的数组，通常是原数组的两倍大小。 将原数组中的所有键值对重新计算哈希值，并插入到新数组中的合适位置。扩容操作会导致重新哈希所有的键值对，因此比较耗时，但是由于扩容会增加数组大小，从而减少哈希冲突，提高了 HashMap 的性能。
HashMap的扩容操作是怎么实现的？

创建新数组： 当 HashMap 中的元素数量达到负载因子（load factor）乘以数组大小的阈值时，HashMap 就会触发扩容操作。扩容操作首先会创建一个新的更大的数组，通常是原数组大小的两倍。

重新计算哈希值： 对于原数组中的每个键值对，需要重新计算其哈希值，并根据新数组的长度取模，以确定新的存储位置。这是因为新数组的长度可能已经发生变化，所以需要重新计算哈希值来确定元素在新数组中的位置。

重新分配键值对： 将所有键值对重新分配到新数组中的合适位置。这通常涉及将元素从原数组中复制到新数组中。如果发生了哈希冲突，即多个键值对计算出的新索引位置相同，那么会根据具体的冲突解决策略，比如链地址法或红黑树，将这些键值对存储在新数组的相应位置上。

更新引用： 扩容完成后，HashMap 会更新内部的数组引用，指向新的数组。这样，原数组就可以被垃圾回收机制回收。

调整负载因子阈值： 扩容操作完成后，HashMap 会重新计算负载因子阈值，以便下次触发扩容操作时使用。通常情况下，负载因子阈值是固定的，但也有一些实现会根据元素数量动态调整负载因子阈值，以优化性能。
HashMap是怎么解决哈希冲突的？

链地址法（Separate Chaining）： 在 JDK 1.7 及之前的版本中，HashMap 使用链地址法来解决哈希冲突。当发生哈希冲突时，即多个键映射到了同一个数组位置，HashMap 会在这个位置上维护一个链表，将具有相同哈希值的键值对存储在同一个链表中。当需要查找、插入或删除一个键值对时，HashMap 会先计算键的哈希值，然后根据哈希值找到对应的数组位置，最后在对应的链表上执行相应的操作。链地址法简单且易于实现，适用于大部分情况。但是当链表过长时，会影响 HashMap 的性能。

红黑树（Red-Black Tree）优化： 在 JDK 1.8 及之后的版本中，当链表的长度超过一定阈值（默认为 8）时，HashMap 会将链表转换为红黑树，以优化查找性能。红黑树是一种自平衡的二叉查找树，它的查找、插入、删除等操作的时间复杂度为 O(log n)，相比链表的线性查找效率更高。当链表转换为红黑树时，HashMap 会调用 TreeMap 的相关方法来执行插入、查找、删除等操作。
TreeMap 和 TreeSet 在排序时如何比较元素？Collections 工具类中的 sort()方法如何比较元素？

TreeMap 和 TreeSet 的比较元素方式： TreeMap：在 TreeMap 中，元素的排序是基于键的比较。当向 TreeMap 中插入键值对时，会根据键的自然顺序或者指定的 Comparator 进行比较，并按照排好序的顺序进行存储。如果没有指定 Comparator，则键对象必须实现 Comparable 接口，TreeMap 将使用该接口中的 compareTo() 方法进行比较。

TreeSet：在 TreeSet 中，元素的排序是基于元素自身的比较。当向 TreeSet 中插入元素时，会根据元素的自然顺序或者指定的 Comparator 进行比较，并按照排好序的顺序进行存储。如果没有指定 Comparator，则元素对象必须实现 Comparable 接口，TreeSet 将使用该接口中的 compareTo() 方法进行比较。

Collections 工具类的 sort() 方法比较元素方式： Collections.sort() 方法可以对 List 中的元素进行排序。排序时，它会根据元素的自然顺序或者指定的 Comparator 进行比较，并按照排好序的顺序重新排列 List 中的元素。如果没有指定 Comparator，则 List 中的元素对象必须实现 Comparable 接口，sort() 方法将使用该接口中的 compareTo() 方法进行比较。
HashMap 和 ConcurrentHashMap、 Hashtable 的区别
1. 线程安全性：
  - HashMap：HashMap 是非线程安全的，即在多线程环境下不同步，需要手动处理线程同步问题。
  - ConcurrentHashMap：ConcurrentHashMap 是线程安全的，并发性能较高。它使用了分段锁（Segment）来实现并发访问，不同的段（Segment）上的操作可以并行执行，因此不会出现整个数据结构被锁住的情况。
  - Hashtable：Hashtable 是线程安全的，但是其所有的公有方法都使用了同步关键字 synchronized，因此在高并发场景下性能较差。
2. 性能：
  - HashMap：HashMap 在单线程环境下性能较好，但在多线程环境下需要考虑同步问题。
  - ConcurrentHashMap：ConcurrentHashMap 在多线程环境下性能比 HashMap 更好，因为它采用了分段锁来提高并发访问性能。
  - Hashtable：Hashtable 的性能较差，因为它使用了 synchronized 关键字来保证线程安全，所有线程都需要竞争同一把锁。
3. Null 键与值的处理：
  - HashMap：HashMap 允许 null 键和 null 值。
  - ConcurrentHashMap：ConcurrentHashMap 不允许 null 键和 null 值，否则会抛出 NullPointerException。
  - Hashtable：Hashtable 不允许 null 键和 null 值，否则会抛出 NullPointerException。
4. 迭代器：
  - HashMap：HashMap 的迭代器（Iterator）不是线程安全的，如果在迭代过程中修改了 HashMap 的结构（增删操作），会导致 ConcurrentModificationException 异常。
  - ConcurrentHashMap：ConcurrentHashMap 的迭代器是弱一致的，可以在迭代过程中修改 ConcurrentHashMap 的结构而不会抛出异常，但是迭代器不会反映出修改的结果。
  - Hashtable：Hashtable 的迭代器（Enumerator）是线程安全的，不会抛出 ConcurrentModificationException 异常。
综上所述，HashMap 在单线程环境下性能较好，但在多线程环境下需要考虑同步问题；ConcurrentHashMap 提供了更好的并发性能和线程安全性；Hashtable 在功能上类似于 ConcurrentHashMap，但性能较差，且很少被使用。
三、延伸思考
为什么 ArrayList 的 elementData 加上 transient 修饰？
在 Java 中，ArrayList 是一个动态数组，用于存储对象。ArrayList 的实现中有一个字段名为 elementData，它是一个数组，用于存储实际的元素。

添加 transient 关键字修饰 elementData 的目的是为了告诉 Java 序列化机制在序列化过程中不要将 elementData 字段持久化到存储设备中。这样做的原因有几点：
1. 性能考虑：ArrayList 在序列化时，如果将 elementData 也进行序列化，会导致序列化和反序列化的过程中需要处理大量的元素数据，增加了序列化和反序列化的时间开销。而实际上，elementData 中存储的是实际的元素，这些元素本身已经被序列化过了，因此在序列化过程中持久化 elementData 是没有必要的，可以节省时间。
2. 节省空间：ArrayList 的元素可能会占据大量的内存空间，而在某些情况下，我们并不需要将这些元素持久化到存储设备中。通过将 elementData 字段标记为 transient，可以减少序列化后的数据大小，节省存储空间。
3. 安全性：有时候 ArrayList 中存储的元素可能包含敏感信息，不希望被序列化后暴露在外部。通过将 elementData 标记为 transient，可以确保在序列化过程中不会将这些敏感信息持久化到存储设备中。
总之，将 elementData 字段标记为 transient 可以提高序列化和反序列化的性能，节省存储空间，并提高数据安全性。
多线程场景下如何使用 ArrayList？
在多线程场景下，ArrayList 并不是线程安全的，这意味着如果多个线程同时访问 ArrayList 的情况下，可能会导致意外的结果，例如数据损坏或者异常。但是，你可以通过以下几种方式来在多线程环境下安全地使用 ArrayList：
1. 使用线程安全的集合类：Java 提供了一些线程安全的集合类，如 CopyOnWriteArrayList。它是 ArrayList 的线程安全版本，适用于读操作频繁、写操作较少的场景。在迭代期间，它会对原始数组进行一次复制，从而实现了读写分离，保证了线程安全性。
```
List<String> threadSafeList = new CopyOnWriteArrayList<>();
```
2. 使用集合类的同步方法：可以通过 Collections.synchronizedList() 方法将 ArrayList 转换为线程安全的列表。但需要注意的是，虽然通过此方法可以获得一个线程安全的列表，但对列表进行遍历等复合操作时，还是需要手动添加额外的同步控制。
```
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
```
3. 显式添加同步控制：在使用 ArrayList 时，可以使用同步块或者锁来保护对列表的访问。通过在多线程访问 ArrayList 的关键代码段添加同步控制，可以确保同一时间只有一个线程可以访问该代码段，从而保证线程安全性。
```
codeList<String> arrayList = new ArrayList<>();

synchronized(arrayList) {
    // 在同步块中对 ArrayList 进行操作
}
```
4. 使用并发集合框架：Java 并发包提供了丰富的并发集合类，如 ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentLinkedQueue 等，它们已经在设计上考虑了多线程并发访问的问题，可以直接在多线程环境下使用。
选择哪种方法取决于你的具体需求和场景。如果读操作频繁而写操作较少，推荐使用 CopyOnWriteArrayList；如果需要在多线程环境下进行并发访问，可以考虑使用并发集合类；如果需要对现有的 ArrayList 进行线程安全的改造，可以使用同步方法或显式添加同步控制。
哪些集合类是线程安全的？它们在实现线程安全的方式上有什么区别？
在 Java 中，有几个集合类是线程安全的，它们在实现线程安全的方式上有所不同。以下是一些常见的线程安全的集合类及其特点：
1. Vector：Vector 是 Java 最早提供的线程安全的动态数组类。它的线程安全性是通过在每个方法上添加 synchronized 关键字来实现的，从而保证了在多线程环境下的安全性。然而，由于其方法级的同步控制，可能会带来性能上的开销。
2. Hashtable：Hashtable 是一种基于哈希表的线程安全的 Map 集合。它的线程安全性也是通过在每个方法上添加 synchronized 关键字来实现的。与 Vector 类似，Hashtable 的同步控制也可能带来性能上的开销。
3. Collections.synchronizedXXX 方法：Java 提供了一系列静态方法，如 synchronizedList()、synchronizedMap() 等，可以将非线程安全的集合类转换为线程安全的版本。这些方法在每个方法上都添加了同步控制，因此实现了整个集合的线程安全。但需要注意的是，虽然通过这些方法可以获得线程安全的集合，但对集合进行复合操作时仍需要额外的同步控制。
4. ConcurrentHashMap：ConcurrentHashMap 是 Java 并发包提供的线程安全的哈希表实现。它使用了一种锁分段的机制，将整个哈希表分为多个段（Segment），每个段都可以独立地进行操作，从而减小了锁的粒度，提高了并发性能。ConcurrentHashMap 提供了比 Hashtable 更好的并发性能。
5. CopyOnWriteArrayList 和 CopyOnWriteArraySet：CopyOnWriteArrayList 和 CopyOnWriteArraySet 是 Java 并发包提供的线程安全的列表和集合实现。它们的线程安全性是通过在写操作时对底层数组进行复制来实现的，从而保证了读写分离，读操作不受写操作的影响，从而提高了并发性能。适用于读操作频繁而写操作较少的场景。
6. ConcurrentLinkedQueue 和 ConcurrentLinkedDeque：ConcurrentLinkedQueue 和 ConcurrentLinkedDeque 是 Java 并发包提供的线程安全的队列和双端队列实现。它们基于无锁的并发算法实现，使用了一种非阻塞的算法来保证线程安全性，因此在高并发环境下具有较好的性能表现。
这些线程安全的集合类在实现线程安全的方式上有所不同，可以根据具体的需求和场景选择合适的集合类。
了解什么是红黑树？
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它在插入和删除操作后能够通过旋转和变色等操作来保持树的平衡，从而保证了树的搜索、插入、删除等操作的时间复杂度都是 O(log n)，其中 n 表示树中节点的数量。

红黑树具有以下特点：
1. 节点的颜色：每个节点都有一个颜色，可以是红色或黑色。
2. 根节点和叶子节点：根节点和叶子节点（NIL 节点，也称为哨兵节点）是黑色的。
3. 红色节点的子节点：红色节点的子节点必须是黑色的，这样可以确保从根节点到叶子节点的每条路径上都有相同数量的黑色节点，从而保证了树的黑色平衡性。
4. 路径规则：从任一节点到其每个叶子的路径都包含相同数量的黑色节点，这称为黑高度相同的性质。
5. 新增节点的处理：新增节点默认为红色，插入节点后，如果出现了连续的红色节点，则需要进行颜色调整和旋转操作来保持树的平衡。
6. 删除节点的处理：删除节点后，可能会破坏树的平衡性，需要通过颜色调整、旋转等操作来修复平衡性。
了解Java集合的快速失败机制 “fail-fast”。

在Java集合中，"快速失败"是一种设计原则，指的是当集合在被多个线程同时修改时，可能会抛出 ConcurrentModificationException 异常，以避免在迭代过程中出现不确定的行为。

快速失败机制的实现方式通常是通过在集合迭代器中维护一个修改次数的计数器，并在每次迭代之前检查该计数器是否与预期值相等。如果在迭代过程中集合被修改，计数器的值会发生变化，迭代器在下一次操作时会检测到这种变化并抛出异常。

这种机制的好处是可以尽早地发现并防止在迭代过程中的并发修改问题，而不是在迭代结束后才发现，从而使得程序更容易排查和修复问题。
HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标？

在HashMap中，使用 hashCode() 处理后的哈希值并不直接作为table的下标，而是需要再次进行处理，通常是通过取模运算得到实际的下标位置。这是因为 hashCode() 方法返回的哈希值可能会比较大，而HashMap的实际容量是有限的，所以需要将哈希值映射到一个合适的范围内，以确定该元素在table数组中的位置。
HashMap 的长度为什么是2的幂次方？
HashMap的长度选择为2的幂次方有利于提高性能。这是因为HashMap在计算元素的位置时，使用 index = hashCode & (length - 1) 的方式来取模，这样做等价于对长度取模，但是位运算的效率比较高，而且长度为2的幂次方时，使用 2 的幂次方作为数组长度的好处在于，当length是 2 的幂次方时，(length - 1)` 的二进制表示就是一串连续的 1。这样，与哈希值进行按位与操作之后，可以保证结果的分布更加均匀，避免了哈希碰撞的频繁发生，提高了 HashMap 的性能。，这样与任何哈希值进行与操作时，相当于只保留了哈希值的低位，从而可以更均匀地分布在table数组中，减少了哈希冲突的可能性，提高了查找效率。

例如，假设我们有一个哈希值为 5（二进制表示为 101），我们要将它存储到长度为 8 的数组中。通过按位与操作，我们可以得到：
```
  0111 (length - 1)
& 0101 (hash)
---------
  0101
```
结果为 5，这意味着哈希值 5 将存储在数组的索引位置 5 处。

这样做保留了hash低位
ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？

ConcurrentHashMap的底层实现是基于分段锁的技术，是 Java 并发编程中常用的线程安全的哈希表实现。它的底层实现采用了一种称为分段锁（Segment）的机制来实现并发访问。它将整个数据结构分成多个段（Segment），每个段都相当于一个小的HashMap，各自管理一部分数据。在读操作时，并不需要加锁，因为每个段都是独立的，只会锁定当前操作的段，而其他段的数据不受影响，可以并发读取。在写操作时，只会锁定当前操作的段，而其他段仍然可以被其他线程访问。

这样的设计有效地减小了锁的粒度，提高了并发性能。同时，在JDK8及以后的版本中，ConcurrentHashMap采用了CAS操作和volatile变量来保证线程安全，进一步提升了性能。
为什么HashMap中String、Integer这样的包装类适合作为K？如果使用Object作为HashMap的Key，应该怎么办呢？

String、Integer等包装类适合作为HashMap的Key，因为它们重写了 hashCode() 和 equals() 方法，保证了在HashMap中作为Key时的正确性和性能。另外，这些类一般是不可变的，也就是说它们的值在创建后不可改变，这样可以保证在作为Key时不会出现意外的行为。

如果使用Object作为HashMap的Key，应该确保Object正确地重写了 hashCode() 和 equals() 方法，以保证HashMap的正确性和性能。如果没有重写，会使用Object类默认的 hashCode() 和 equals() 方法，这样可能导致相同内容的对象在HashMap中被视为不同的Key，或者哈希冲突增多，影响性能。