JAVA集合知识总结(一)

文章目录

JAVA集合知识总结(一)
- - 集合相关类
- Collection
- - [1. Collection 接口的方法](#1. Collection 接口的方法)
  - - [1.1 添加元素](#1.1 添加元素)
    - [1.2 删除元素](#1.2 删除元素)
    - [1.3 查找元素](#1.3 查找元素)
    - [1.4 遍历集合](#1.4 遍历集合)
    - [1.5 集合操作](#1.5 集合操作)
    - [1.6 转换为其他格式](#1.6 转换为其他格式)
  - [2. 遍历方式](#2. 遍历方式)
  - - [2.1 使用 Iterator 遍历](#2.1 使用 Iterator 遍历)
    - [2.2 使用增强型 for 循环](#2.2 使用增强型 for 循环)
    - [2.3 使用 forEach 和 Lambda 表达式](#2.3 使用 forEach 和 Lambda 表达式)
- List
- - [1. List 接口的核心方法](#1. List 接口的核心方法)
  - [2. List 的常用实现类](#2. List 的常用实现类)
  - - [2.1 ArrayList](#2.1 ArrayList)
    - [2.2 LinkedList](#2.2 LinkedList)
    - [2.3 Vector(不建议使用)](#2.3 Vector(不建议使用))
    - [2.4 CopyOnWriteArrayList](#2.4 CopyOnWriteArrayList)
  - [3. List 的特性](#3. List 的特性)
  - - [3.1 有序性](#3.1 有序性)
    - [3.2 允许重复](#3.2 允许重复)
    - [3.3 基于索引的操作](#3.3 基于索引的操作)
  - [4. List 与数组的对比](#4. List 与数组的对比)
  - [5. 线程安全与 List](#5. 线程安全与 List)
  - - [非线程安全的 List](#非线程安全的 List)
    - [线程安全的 List](#线程安全的 List)
  - [6. 遍历 List 的方式](#6. 遍历 List 的方式)
  - - [6.1 使用 for 循环](#6.1 使用 for 循环)
    - [6.2 使用增强 for 循环](#6.2 使用增强 for 循环)
    - [6.3 使用迭代器](#6.3 使用迭代器)
    - [6.4 使用 Stream](#6.4 使用 Stream)
  - [7. 常见的 List 操作](#7. 常见的 List 操作)
  - - [7.1 排序](#7.1 排序)
    - [7.2 替换所有元素](#7.2 替换所有元素)
    - [7.3 集合转数组](#7.3 集合转数组)
    - [7.4 反转 List](#7.4 反转 List)
  - [8. 总结](#8. 总结)

JAVA集合知识总结(一)

Java 集合框架是一组用于存储和操作数据的类和接口。核心接口包括 Collection、List、Set、Queue 和 Map 等。这些接口有多种实现，满足不同的数据结构需求。

集合相关类

plaintext 复制代码

java.util.Collection(接口)
├── List(接口)
│   ├── ArrayList
│   ├── LinkedList
│   ├── Vector
│   │   └── Stack
├── Set(接口)
│   ├── HashSet
│   │   └── LinkedHashSet
│   └── SortedSet
│       └── NavigableSet
│           └── TreeSet
└── Queue(接口)
    ├── PriorityQueue
    ├── Deque
    │   ├── ArrayDeque
    │   └── LinkedList  (实现了 List 和 Deque)
    
java.util.Map (接口)
├── HashMap
│   └── LinkedHashMap
├── Hashtable
│   └── Properties
└── SortedMap
    └── NavigableMap
        └── TreeMap

Collection

Collection 是 Java 单列集合框架的根接口，定义了操作一组对象（元素）的通用方法。Collection 作为集合类的基础接口，它有多个子接口和实现类，主要用于表示一组单一对象的集合，如 List、Set 和 Queue。

1. Collection 接口的方法

1.1 添加元素

boolean add(E e)：向集合中添加元素。如果集合因添加操作而发生变化，则返回 true。
boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到当前集合中。

1.2 删除元素

boolean remove(Object o)：删除集合中指定的元素，成功删除则返回 true。
boolean removeAll(Collection<?> c)：删除当前集合中与指定集合中的元素相同的元素。
boolean retainAll(Collection<?> c)：保留当前集合中与指定集合中相同的元素，删除其他元素。

1.3 查找元素

boolean contains(Object o)：判断集合中是否包含指定的元素。
boolean containsAll(Collection<?> c)：判断当前集合是否包含指定集合中的所有元素。

1.4 遍历集合

Iterator<E> iterator()：返回一个用于遍历集合中元素的迭代器。
void forEach(Consumer<? super E> action)：对集合中的每个元素执行给定操作（使用 lambda 表达式时非常有用）。

1.5 集合操作

int size()：返回集合中的元素个数。
boolean isEmpty()：判断集合是否为空。
void clear()：清空集合中的所有元素。

1.6 转换为其他格式

Object[] toArray()：将集合转换为一个数组。
<T> T[] toArray(T[] a)：将集合转换为指定类型的数组。

2. 遍历方式

2.1 使用 Iterator 遍历

Iterator 是 Collection 提供的一种遍历集合的机制。使用时通过 hasNext() 判断是否有下一个元素，通过 next() 获取元素。

java 复制代码

Collection<String> collection = new ArrayList<>();
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

2.2 使用增强型 for 循环

增强型 for 循环（即 "for-each"）是一种简化的遍历集合的方式。

java 复制代码

for (String element : collection) {
    System.out.println(element);
}

2.3 使用 forEach 和 Lambda 表达式

Lambda 表达式 是 Java 8 引入的一种简洁的遍历集合方式。

java 复制代码

collection.forEach(element -> System.out.println(element));

List

List 是 Java 集合框架中的一个接口，表示有序的元素集合，允许包含重复元素。List 提供基于索引的操作，允许插入、删除和访问元素。

1. List 接口的核心方法

add(E e)：将元素添加到列表末尾。
get(int index)：返回指定索引处的元素。
set(int index, E element)：替换指定索引处的元素。
remove(int index)：移除指定索引处的元素。
size()：返回列表中元素的个数。
indexOf(Object o)：返回指定元素第一次出现的索引。
contains(Object o)：检查列表是否包含某个元素。

2. List 的常用实现类

2.1 ArrayList

特点：
- 底层基于动态数组，支持快速随机访问。
- 支持 null 元素。
- 查询性能好，插入/删除性能较差（特别是中间操作）。
适用场景：读操作频繁，插入和删除较少的场景，例如：缓存数据、频繁查询的列表。

2.2 LinkedList

特点：
- 基于双向链表实现，增删操作性能好，尤其是在头尾操作。
- 随机访问性能差，遍历时需要从头或尾逐个查找。
- 同时实现了 Deque 接口，支持栈和队列操作。
适用场景：需要频繁插入和删除操作的场景，例如：队列、堆栈、双端队列。

2.3 Vector(不建议使用)

特点：
- 基于动态数组，和 ArrayList 类似，但所有方法都同步，线程安全。
- 比 ArrayList 性能差，因为加了同步锁。
适用场景：在多线程环境中需要线程安全的动态数组。

2.4 CopyOnWriteArrayList

特点：
- 线程安全的 List 实现，每次修改都会复制底层数组，读操作无锁。
- 适合读多写少的并发场景。
适用场景：高并发读操作，多线程环境下的常用数据容器。

3. List 的特性

3.1 有序性

List 保持插入顺序，元素可以通过索引进行访问。

3.2 允许重复

List 允许包含重复元素，不同于 Set，可以多次存储相同的元素。

3.3 基于索引的操作

List 提供基于索引的插入、删除和访问功能，允许直接操作指定位置的元素。

4. List 与数组的对比

长度变化 ：ArrayList 可以动态增长，数组的长度固定。
存储效率 ：数组在空间上更节省，但操作灵活性较差；ArrayList 需要一定的扩容机制，可能会浪费空间。
线程安全 ：数组本身是非线程安全的；Vector、CopyOnWriteArrayList 是线程安全的。

5. 线程安全与 List

非线程安全的 List

ArrayList 和 LinkedList 是非线程安全的，多线程并发操作可能导致数据不一致。

线程安全的 List

Vector、CopyOnWriteArrayList 是线程安全的。
也可以使用 Collections.synchronizedList() 将非线程安全的 List 变为线程安全。

java 复制代码

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

6. 遍历 List 的方式

6.1 使用 for 循环

java 复制代码

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

6.2 使用增强 for 循环

java 复制代码

for (String element : list) {
    System.out.println(element);
}

6.3 使用迭代器

java 复制代码

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

6.4 使用 Stream

java 复制代码

list.stream().forEach(System.out::println);

7. 常见的 List 操作

7.1 排序

使用 Collections.sort(list) 或 list.sort(comparator) 对列表进行排序。

7.2 替换所有元素

使用 Collections.replaceAll(list, oldVal, newVal) 来替换所有出现的元素。

7.3 集合转数组

java 复制代码

String[] array = list.toArray(new String[0]);

7.4 反转 List

使用 Collections.reverse(list) 可以反转列表顺序。

8. 总结

Collection 是 Java 单列集合框架的根接口，定义了操作一组对象（元素）的通用方法。
List 是 Java 集合框架中的一个接口，继承Collection接口。List表示有序的元素集合，允许包含重复元素。List有多种实现类(ArrayList, LinkedList等)，对应于不同场景对集合的使用。