List基本介绍是什么呢

发布时间：2021-10-20 17:29:14 作者：柒染
来源：亿速云阅读：198

# List基本介绍是什么呢

## 目录
1. [什么是List](#什么是list)
2. [List的主要特性](#list的主要特性)
3. [List的常见实现类](#list的常见实现类)
4. [List的基本操作](#list的基本操作)
5. [List的遍历方式](#list的遍历方式)
6. [List的性能分析](#list的性能分析)
7. [List的使用场景](#list的使用场景)
8. [List与数组的比较](#list与数组的比较)
9. [List的线程安全性](#list的线程安全性)
10. [List的最佳实践](#list的最佳实践)
11. [总结](#总结)

## 什么是List

List（列表）是Java集合框架中最常用的数据结构之一，它继承自`Collection`接口，是一个有序的集合（也称为序列）。List允许存储重复的元素，并且每个元素都有其特定的索引位置，用户可以通过整数索引（列表中的位置）来访问、搜索、插入和删除元素。

List接口在Java中定义在`java.util`包中，它提供了一系列方法来操作列表中的元素。由于List是一个接口，因此它不能被实例化，必须通过其实现类（如ArrayList、LinkedList等）来创建具体的列表对象。

List的主要特点包括：
- 有序性：元素按照插入顺序排列
- 可重复性：允许存储相同的元素
- 索引访问：可以通过索引快速访问元素
- 动态扩容：大多数实现类支持自动扩容

## List的主要特性

### 有序性（Ordered）
List中的元素按照它们被插入的顺序进行存储，并且这个顺序是稳定的。这意味着第一个添加的元素索引为0，第二个为1，依此类推。

### 可重复性（Allow Duplicates）
与Set不同，List允许存储相同的元素多次。例如，可以创建一个包含多个相同字符串的List。

### 基于索引的操作（Index-based Operations）
List提供了基于索引的各种操作方法：
```java
E get(int index);          // 获取指定位置的元素
E set(int index, E element); // 替换指定位置的元素
void add(int index, E element); // 在指定位置插入元素
E remove(int index);       // 移除指定位置的元素

动态大小（Dynamic Sizing）

大多数List实现（如ArrayList）会根据需要自动调整容量，无需手动管理大小。

支持null元素

大多数List实现允许存储null值，但使用时需要注意NullPointerException。

List的常见实现类

1. ArrayList

List<String> arrayList = new ArrayList<>();

基于动态数组实现
随机访问速度快（O(1)）
在列表中间插入/删除元素较慢（O(n)）
默认初始容量为10，扩容时增加50%

2. LinkedList

List<String> linkedList = new LinkedList<>();

基于双向链表实现
在任意位置插入/删除元素快（O(1)）
随机访问速度慢（O(n)）
实现了Deque接口，可用作队列或栈

3. Vector

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

线程安全的动态数组
方法使用synchronized修饰
性能较差，已被ArrayList取代

4. Stack

Stack<String> stack = new Stack<>();

继承自Vector
实现了后进先出（LIFO）的栈结构
推荐使用Deque接口的实现类替代

5. CopyOnWriteArrayList

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

线程安全的List实现
所有修改操作都会创建底层数组的新副本
适合读多写少的场景

List的基本操作

创建List

// 使用具体实现类创建
List<String> list1 = new ArrayList<>();
List<String> list2 = new LinkedList<>();

// 使用Arrays工具类
List<String> list3 = Arrays.asList("A", "B", "C");

// Java 9+ 的工厂方法
List<String> list4 = List.of("A", "B", "C");

添加元素

list.add("Element");          // 添加到末尾
list.add(0, "FirstElement");  // 添加到指定位置
list.addAll(otherList);       // 添加另一个集合的所有元素

访问元素

String element = list.get(0);  // 获取第一个元素
int index = list.indexOf("A"); // 获取元素的索引
boolean exists = list.contains("B"); // 检查元素是否存在

修改元素

list.set(0, "NewValue");  // 替换指定位置的元素

删除元素

list.remove(0);           // 按索引删除
list.remove("A");         // 按元素值删除
list.removeAll(otherList);// 删除所有匹配的元素
list.clear();             // 清空列表

其他操作

int size = list.size();       // 获取元素数量
boolean empty = list.isEmpty(); // 检查是否为空
List<String> subList = list.subList(1, 3); // 获取子列表

List的遍历方式

1. for循环（索引遍历）

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

2. 增强for循环

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

3. 迭代器（Iterator）

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

4. ListIterator（双向遍历）

ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String element = listIterator.next();
    System.out.println(element);
}
// 反向遍历
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

5. Java 8+ forEach

list.forEach(element -> System.out.println(element));
// 或使用方法引用
list.forEach(System.out::println);

6. Stream API

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

List的性能分析

ArrayList vs LinkedList 性能对比

操作	ArrayList	LinkedList
get(int index)	O(1)	O(n)
add(E element)	O(1) 分摊	O(1)
add(int index, E e)	O(n)	O(1)
remove(int index)	O(n)	O(1)
remove(Object o)	O(n)	O(n)
contains(Object o)	O(n)	O(n)

内存占用

ArrayList：连续内存，每个元素占用空间固定
LinkedList：每个元素需要额外存储前后节点的引用

选择建议

频繁随机访问 → ArrayList
频繁在中间插入/删除 → LinkedList
不确定时 → 优先选择ArrayList（大多数场景表现更好）

List的使用场景

适用场景

需要保持元素插入顺序：如用户操作记录
需要允许重复元素：如购物车中的商品
需要频繁按索引访问元素：如学生成绩列表
需要动态调整大小：不确定元素数量的情况

实际应用示例

// 1. 分页查询
List<User> users = userDao.getUsers();
int pageSize = 10;
int pageNum = 2;
List<User> page = users.subList((pageNum-1)*pageSize, pageNum*pageSize);

// 2. 数据缓存
List<Product> hotProducts = new ArrayList<>(cacheManager.getHotProducts());

// 3. 批量操作
List<Order> orders = orderService.getPendingOrders();
orders.forEach(order -> processOrder(order));

List与数组的比较

特性	数组	List
大小	固定	动态
类型安全	编译时检查	泛型提供运行时安全
性能	略快	略慢
功能	基本操作	丰富的方法
多态	不支持	支持
原始类型	支持	不支持（需用包装类）

转换方法

// 数组转List
String[] array = {"A", "B", "C"};
List<String> listFromArray = Arrays.asList(array); // 固定大小
List<String> mutableList = new ArrayList<>(Arrays.asList(array));

// List转数组
String[] arrayFromList = list.toArray(new String[0]);

List的线程安全性

非线程安全的实现

ArrayList
LinkedList

线程安全的实现

Vector：所有方法同步，性能差

Collections.synchronizedList


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

CopyOnWriteArrayList


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

多线程环境下建议

读多写少 → CopyOnWriteArrayList
写操作频繁 → 使用显式同步或并发集合
避免在迭代过程中修改列表

List的最佳实践

初始化时指定容量

List<String> list = new ArrayList<>(100); // 避免频繁扩容

使用不可变列表

List<String> immutableList = Collections.unmodifiableList(list);
List<String> immutableList = List.of("A", "B", "C");

避免在循环中修改列表 “`java // 错误方式 - 可能抛出ConcurrentModificationException for (String item : list) { if (condition) { list.remove(item); } }

// 正确方式 - 使用迭代器的remove方法 Iterator it = list.iterator(); while (it.hasNext()) { String item = it.next(); if (condition) { it.remove(); } }


4. **合理选择实现类**
   - 默认选择ArrayList
   - 频繁插入删除选择LinkedList
   - 线程安全需求选择CopyOnWriteArrayList

5. **利用工具类简化操作**
   ```java
   Collections.sort(list);
   Collections.shuffle(list);
   Collections.reverse(list);

总结

List作为Java集合框架中最基础也最重要的接口之一，提供了有序、可重复的元素集合。通过本文的详细介绍，我们了解了：

List的核心特性：有序性、可重复性和索引访问
主要实现类的特点及适用场景
各种基本操作和遍历方式
性能分析和优化建议
线程安全处理方案
实际开发中的最佳实践

掌握List的合理使用，能够帮助我们编写出更高效、更健壮的Java代码。在实际开发中，应根据具体需求选择合适的List实现类，并遵循最佳实践来避免常见问题。

无论是简单的数据存储，还是复杂的业务逻辑处理，List都是Java开发者不可或缺的工具。希望本文能帮助你全面理解并有效使用List集合。 “`