java集合知识整理1：Java集合概览

最新推荐文章于 2024-10-16 10:13:45 发布

深入原理理解

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量1.1k

点赞数 35

文章标签： java windows 开发语言

本文链接：https://blog.csdn.net/LSP20020926/article/details/142454595

版权

Java集合概览

java集合也叫做容器，主要由两大接口派生而来：一个是Collection接口，主要用于存放单一元素，另一个是Map接口，主要存放键值对。对于Collection接口，下面又有三个主要的子接口：List、Set、Queue。
在这里插入图片描述

List，Set，Queue，Map四者的区别？

List: 存储的元素是有序的，可重复的。
Set: 存储的元素不可重复，无序。
Queue: 有序，可重复，先进先出。
Map: 使用键值对（key-value）存储，key是无序的、不可重复的，value是无需的、可重复的，每个键最多映射到一个值。

注意：有序、无序指的是是否按存放顺序存储。

List 接口

List 接口表示有序的集合，允许重复的元素，并可以通过索引访问元素。

主要实现类：

ArrayList：基于动态数组的实现，适合随机访问。
LinkedList：基于双向链表的实现，适合频繁的插入和删除操作。
Vector：实现了与 ArrayList 类似，但它是同步的，适合多线程环境。
Stack：继承自 Vector，实现了后进先出的栈数据结构。

ArrayList 和 LinkedList，默认情况下不是线程安全的。如果你需要一个线程安全且高效的 List 实现，有几种选择：

使用 Collections.synchronizedList
这是最简单的方法，通过包装现有的 List 实现类来提供同步支持。

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());

这个方法为所有的访问方法添加了同步锁，这是线程安全的，但在高并发环境下性能可能不是最优的，因为每次访问都需要获取锁。

使用 CopyOnWriteArrayList
CopyOnWriteArrayList 是 java.util.concurrent 包提供的线程安全的 List 实现，非常适合读多写少的场景。

List<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();

CopyOnWriteArrayList 的特点是:

读操作不加锁：读操作不会阻塞，因为是操作的快照副本。
写操作代价高：每次写操作（添加、修改、删除）会创建整个列表的一个新副本，适合读多写少的场景。

使用 ConcurrentLinkedQueue
虽然 ConcurrentLinkedQueue 不是 List 实现，但它提供了一个高效的、线程安全的队列，如果你需要先进先出的语义，可以考虑这个选项。

Queue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();

使用 Vector
Vector 是线程安全的 List 实现类，每个方法都进行了同步处理，但它相对较老且性能一般，通常不推荐在新项目中使用。

List<String> vector = new Vector<>();

总结
高并发读多写少：选择 CopyOnWriteArrayList。
简单同步：使用 Collections.synchronizedList 包装 ArrayList 或 LinkedList。
FIFO 队列：考虑 ConcurrentLinkedQueue 作为替代。
传统方法：Vector 是线程安全的，但性能较低，建议仅用于维护旧代码。
根据你的具体需求和场景选择适合的 List 实现，可以确保在多线程环境下既满足线程安全要求，又能提供良好的性能。

set接口

Set 接口表示无序的集合，不允许重复元素。

主要实现类：

HashSet：基于哈希表的实现，提供快速的查找和插入操作。
LinkedHashSet：继承自 HashSet 并保留插入顺序。
TreeSet：基于红黑树的实现，元素自动排序。

Set 实现（如 HashSet、TreeSet、LinkedHashSet）都不是线程安全的。如果你需要一个线程安全且高效的 Set 实现，可以考虑以下选项：

使用 Collections.synchronizedSet
这是最简单的方法，通过包装现有的 Set 实现类来提供同步支持。

Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());

这个方法为所有的访问方法添加了同步锁，虽然是线程安全的，但在高并发环境下性能可能不是最优的，因为每次访问都需要获取锁。

使用 ConcurrentSkipListSet
ConcurrentSkipListSet 是 java.util.concurrent 包提供的线程安全的 Set 实现，基于 ConcurrentSkipListMap。

Set<String> concurrentSkipListSet = new ConcurrentSkipListSet<>();

ConcurrentSkipListSet 的特点是:

线程安全：通过细粒度的锁和无锁操作实现高效并发。
自然排序：基于跳跃表，元素按自然顺序排序（或者按提供的比较器排序）。

它是一种基于层级结构的链表，元素按顺序存储，同时具有多层链表辅助实现快速访问。

跳跃表的基本原理

层级结构：跳跃表由多个层构成。底层（Level 0）是一个单链表，包含所有元素。每一层向上，元素数量减少，形成一个塔形结构。每层的节点指向下层链表的一些节点。
快速访问：通过多层索引，跳跃表实现了从高层跳跃到低层的功能，大幅加快了插入、删除和查找操作的速度。
概率性平衡：跳跃表自动平衡自己，通过随机机制决定每个元素所在的层，通常每层的数量是下面一层的一半。

使用 CopyOnWriteArraySet
CopyOnWriteArraySet 是实现了 Set 接口的线程安全集合类，内部是基于 CopyOnWriteArrayList 实现的。特别适合读操作远多于写操作的场景。

Set<String> copyOnWriteArraySet = new CopyOnWriteArraySet<>();

CopyOnWriteArraySet 的特点是:

读操作不加锁：读操作不会阻塞，因为是操作的快照副本。
写操作代价高：每次写操作（添加、删除）都会创建整个集合的一个新副本，适合读多写少的场景。
4. 使用 ConcurrentHashMap 的 KeySet
自 Java 8 以来，ConcurrentHashMap 提供了一种高效的并发 Set 实现，通过 ConcurrentHashMap.keySet(defaultValue)

Set<String> concurrentHashSet = ConcurrentHashMap.newKeySet();

这是一个高效的线程安全 Set，并且继承了 ConcurrentHashMap 的并发性能优势。

总结
简单同步：使用 Collections.synchronizedSet 包装 HashSet 或其他 Set 实现。
高并发读多写少：选择 CopyOnWriteArraySet。
自然排序、高并发：选择 ConcurrentSkipListSet。
高并发且无序：选择基于 ConcurrentHashMap 的 newKeySet() 方法。
通过以上几个实现，你可以根据并发需求和性能考虑选择最合适的线程安全 Set 实现。

Queue接口

Queue 接口表示一个先进先出的队列，用于按顺序处理元素。

主要实现类：

LinkedList：既实现了 List 接口，也实现了 Queue 接口，适合实现双端队列。
PriorityQueue：基于堆排序的实现，元素按自然顺序或指定的比较器排序。
ArrayDeque：实现了双端队列（Deque）接口，提供了比 LinkedList 更高效的队列操作。

如果你需要一个线程安全且高效的 Queue 实现，Java 的并发包 java.util.concurrent 提供了一些强大的工具。选择合适的实现取决于具体的使用场景，例如是否需要阻塞队列，是否对元素的有序性有要求等。

线程安全的 Queue 实现

ConcurrentLinkedQueue
ConcurrentLinkedQueue 是一个基于无锁算法的高效非阻塞队列实现，适用于高并发环境中的生产者-消费者场景。
BlockingQueue 家族

ArrayBlockingQueue
ArrayBlockingQueue 是一个基于数组的阻塞队列，固定容量。队列满时插入操作将阻塞，队列空时移除操作将阻塞。
LinkedBlockingQueue
LinkedBlockingQueue 是一个基于链表的阻塞队列，可指定容量限制。如果未指定容量，默认大小是 Integer.MAX_VALUE。
PriorityBlockingQueue
PriorityBlockingQueue 是一个带优先级的阻塞队列，使用自然排序或提供的比较器对元素进行排序。
DelayQueue
DelayQueue 是一个延迟队列，队列中的元素只能在指定的延迟时间之后才能被消费。通常用于定时任务调度。
SynchronousQueue
SynchronousQueue 是一个不存储元素的队列，每一个 put 操作必须等待一个 take 操作，反之亦然。

TransferQueue

LinkedTransferQueue
LinkedTransferQueue 是 TransferQueue 接口的实现，支持元素的传递。如果消费者已经等待，生产者可以将元素直接传递给消费者。

总结
根据不同使用场景和需求，你可以选择合适的线程安全且高效的 Queue 实现：
高并发、非阻塞队列：使用 ConcurrentLinkedQueue。
需要阻塞行为：使用 BlockingQueue 相关实现，如 ArrayBlockingQueue、LinkedBlockingQueue。
需要优先级：使用 PriorityBlockingQueue。
需要延迟队列：使用 DelayQueue。
点对点通信：使用 SynchronousQueue。
自由传递（生产者可直接传递给消费者）：使用 LinkedTransferQueue。
通过这些高级队列实现，Java 提供了丰富的工具来处理各种多线程场景，确保高效和线程安全。

Map 接口

Map 接口表示键值对的集合，键唯一，值可以重复。

主要实现类：

HashMap：基于哈希表的实现，提供快速的查找和插入操作。
LinkedHashMap：继承自 HashMap 并保留插入顺序。
TreeMap：基于红黑树的实现，键自动排序。
Hashtable：与 HashMap 类似，但它是同步的，适合多线程环境。
ConcurrentHashMap：设计用于并发场景，提供了高效的并发操作支持。

Map 接口的默认实现类（如 HashMap, TreeMap 等）并不是线程安全的。所以在多线程环境中使用的时候，需要考虑线程安全且高效的实现。Java 提供了一些线程安全的 Map 实现，主要在 java.util.concurrent 包中。

ConcurrentHashMap
ConcurrentHashMap 是最常用的线程安全高效 Map 实现。它通过细粒度的锁机制（如分段锁和CAS操作）实现了高效的并发访问，适用于大多数并发场景。

特点：

高效并发：允许并发读取，写操作使用锁分片，减少锁争用。
无锁读取：大多数读取操作是无锁的，通过CAS原子操作更新值，使读写分离。
默认大小：默认初始容量为 16，扩容时通过双倍扩容机制。

Collections.synchronizedMap
Collections.synchronizedMap 提供了一种将现有 Map 转换为线程安全实现的简单方法。它对所有方法进行了同步包装，即每个访问方法都通过对相应同步块加锁来实现线程安全。

特点：

简单易用：能快速将任何 Map 实现转换为线程安全的实现。
全局锁：使用的是单独的全局锁，在高并发情况下性能不佳。

ConcurrentSkipListMap
ConcurrentSkipListMap 是一个基于跳跃表（Skip List）数据结构的线程安全 Map 实现，元素按照键的自然顺序或指定的比较器顺序存储。

特点：

有序性：提供键的自然排序或指定的排序器排序，适合需要顺序访问的场景。
高效并发：支持高效的并发读写操作，使用无锁操作和细粒度锁。
适合应用：适用于需要顺序访问和高并发操作的应用，如缓存、限流控制等。

总结
根据不同的使用场景和需求，你可以选择以下线程安全且高效的 Map 实现：

高并发和无序存储：选择 ConcurrentHashMap。
快速转换现有 Map：使用 Collections.synchronizedMap 包装现有 Map 实现。
高并发和有序存储：选择 ConcurrentSkipListMap，适用于需要顺序操作的场景。
通过理解和应用这些并发 Map 实现，你可以在多线程环境中高效、安全地使用映射集合，确保数据一致性和操作效率。