List 接口的实现类

在 Java 中，List 是一个非常常用的接口，提供了有序、可重复的元素聚集。List 接口有多个实现类，每个实现类都有其特定的特性和适用场景。以下是 Java 中重要实现了 List 接口的类及其详细先容。
1. 常见的 List 实现类

1.1 ArrayList

• 简介：
  
  
  
  • 基于动态数组实现。
    
  • 提供快速的随机访问（get 和 set 利用时间复杂度为 O(1)）。
    
  • 适合频仍的读取利用，但在插入和删除时可能较慢，尤其是在列表中间位置。
    
  
  
• 特点：
  
  
  
  • 动态扩容：当数组容量不足时，会自动扩展（通常是当前容量的 1.5 倍）。
    
  • 允许 null 元素。
    
  • 非同步：不适合多线程环境下的并发访问，除非外部同步。
    
  
  
• 示例：
  
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class ArrayListExample {
  5.     public static void main(String[] args) {
  6.         List<String> arrayList = new ArrayList<>();
  7.         arrayList.add("Apple");
  8.         arrayList.add("Banana");
  9.         arrayList.add("Cherry");
  10.         arrayList.add("Apple"); // 允许重复元素
  12.         System.out.println("ArrayList: " + arrayList);
  13.     }
  14. }

  复制代码
  输出：
  
  1. ArrayList: [Apple, Banana, Cherry, Apple]

  复制代码

1.2 LinkedList

• 简介：
  
  
  
  • 基于双向链表实现。
    
  • 适合频仍的插入和删除利用，特殊是在列表的开头和中间位置。
    
  • 支持作为队列（FIFO）和双端队列（Deque）的实现。
    
  
  
• 特点：
  
  
  
  • 插入和删除效率高：在已知位置的插入和删除利用时间复杂度为 O(1)。
    
  • 随机访问较慢：get 和 set 利用时间复杂度为 O(n)，由于需要遍历链表。
    
  • 允许 null 元素。
    
  
  
• 示例：
  
  1. import java.util.LinkedList;
  2. import java.util.List;
  4. public class LinkedListExample {
  5.     public static void main(String[] args) {
  6.         List<String> linkedList = new LinkedList<>();
  7.         linkedList.add("Apple");
  8.         linkedList.add("Banana");
  9.         linkedList.add("Cherry");
  10.         linkedList.add("Apple"); // 允许重复元素
  12.         System.out.println("LinkedList: " + linkedList);
  13.     }
  14. }

  复制代码
  输出：
  
  1. LinkedList: [Apple, Banana, Cherry, Apple]

  复制代码

1.3 Vector

• 简介：
  
  
  
  • 类似于 ArrayList，也是基于动态数组实现。
    
  • 是同步的，线程安全的。
    
  • 适合需要线程安全的场景，但由于同步开销，性能略低于 ArrayList。
    
  
  
• 特点：
  
  
  
  • 同步：所有的公开方法都是同步的，适用于多线程环境。
    
  • 动态扩容：默认扩容战略与 ArrayList 略有差别（通常是当前容量的两倍）。
    
  • 允许 null 元素。
    
  
  
• 示例：
  
  1. import java.util.List;
  2. import java.util.Vector;
  4. public class VectorExample {
  5.     public static void main(String[] args) {
  6.         List<String> vector = new Vector<>();
  7.         vector.add("Apple");
  8.         vector.add("Banana");
  9.         vector.add("Cherry");
  10.         vector.add("Apple"); // 允许重复元素
  12.         System.out.println("Vector: " + vector);
  13.     }
  14. }

  复制代码
  输出：
  
  1. Vector: [Apple, Banana, Cherry, Apple]

  复制代码

1.4 Stack

• 简介：
  
  
  
  • 继承自 Vector，表现后进先出（LIFO）的堆栈。
    
  • 提供了额外的方法，如 push、pop 和 peek。
    
  
  
• 特点：
  
  
  
  • 继承自 Vector：具备线程安全性。
    
  • LIFO 结构：适用于需要堆栈举动的场景。
    
  • 已过时：由于继承自 Vector，不推荐使用。Java 推荐使用 Deque 接口及其实现类（如 ArrayDeque）来实现堆栈。
    
  
  
• 示例：
  
  1. import java.util.Stack;
  3. public class StackExample {
  4.     public static void main(String[] args) {
  5.         Stack<String> stack = new Stack<>();
  6.         stack.push("Apple");
  7.         stack.push("Banana");
  8.         stack.push("Cherry");
  10.         System.out.println("Stack: " + stack);
  12.         String top = stack.pop();
  13.         System.out.println("Popped element: " + top);
  14.         System.out.println("Stack after pop: " + stack);
  15.     }
  16. }

  复制代码
  输出：
  
  1. Stack: [Apple, Banana, Cherry]
  2. Popped element: Cherry
  3. Stack after pop: [Apple, Banana]

  复制代码

1.5 CopyOnWriteArrayList

• 简介：
  
  
  
  • 线程安全的 List 实现，适用于读多写少的并发场景。
    
  • 基于“写时复制”机制，每次修改利用都会创建一个新的数组副本。
    
  
  
• 特点：
  
  
  
  • 线程安全：无需外部同步。
    
  • 高效的迭代：迭代时不会抛出 ConcurrentModificationException，适归并发读取。
    
  • 写利用开销大：每次写利用都会复制整个数组，适合读多写少的场景。
    
  
  
• 示例：
  
  1. import java.util.List;
  2. import java.util.concurrent.CopyOnWriteArrayList;
  4. public class CopyOnWriteArrayListExample {
  5.     public static void main(String[] args) {
  6.         List<String> cowList = new CopyOnWriteArrayList<>();
  7.         cowList.add("Apple");
  8.         cowList.add("Banana");
  9.         cowList.add("Cherry");
  11.         System.out.println("CopyOnWriteArrayList: " + cowList);
  12.     }
  13. }

  复制代码
  输出：
  
  1. CopyOnWriteArrayList: [Apple, Banana, Cherry]

  复制代码

1.6 Stack 和 Deque 的对比

尽管 Stack 是 List 的一个实现类，但 Java 推荐使用 Deque 接口及其实现类（如 ArrayDeque）来替代 Stack，由于它们提供了更全面和灵活的堆栈和队列利用。

• 示例（使用 ArrayDeque 作为堆栈）：
  
  1. import java.util.ArrayDeque;
  2. import java.util.Deque;
  4. public class ArrayDequeExample {
  5.     public static void main(String[] args) {
  6.         Deque<String> stack = new ArrayDeque<>();
  7.         stack.push("Apple");
  8.         stack.push("Banana");
  9.         stack.push("Cherry");
  11.         System.out.println("ArrayDeque as Stack: " + stack);
  13.         String top = stack.pop();
  14.         System.out.println("Popped element: " + top);
  15.         System.out.println("Stack after pop: " + stack);
  16.     }
  17. }

  复制代码
  输出：
  
  1. ArrayDeque as Stack: [Cherry, Banana, Apple]
  2. Popped element: Cherry
  3. Stack after pop: [Banana, Apple]

  复制代码

2. List 实现类的选择依据

选择符合的 List 实现类取决于具体的使用场景和性能需求。以下是一些常见的选择依据：

• 需要快速的随机访问：
  
  
  
  • 选择：ArrayList
    
  • 理由：ArrayList 基于动态数组，实现了 O(1) 时间复杂度的随机访问。
    
  
  
• 需要频仍的插入和删除利用，特殊是在列表中间：
  
  
  
  • 选择：LinkedList
    
  • 理由：LinkedList 基于双向链表，在已知位置的插入和删除利用时间复杂度为 O(1)。
    
  
  
• 需要线程安全的列表：
  
  
  
  • 选择：Vector 或 CopyOnWriteArrayList
    
  • 理由：
    
    
    
    • Vector：适用于需要同步访问且写利用较多的场景。
      
    • CopyOnWriteArrayList：适用于读多写少的并发场景。
      
    
    
  
  
• 需要作为堆栈或队列使用：
  
  
  
  • 选择：Deque 的实现类（如 ArrayDeque）
    
  • 理由：Deque 提供了比 Stack 更灵活和高效的堆栈和队列利用。
    
  
  

3. List 实现类的性能对比

3.1 ArrayList 与 LinkedList

特性ArrayListLinkedList随机访问快速（O(1)）较慢（O(n)）插入和删除末尾插入和删除较快（O(1)），中间位置较慢（O(n)）快速（O(1)）内存使用较低（仅存储元素）较高（存储元素及前后节点的引用）迭代性能良好良好适用场景需要频仍随机访问的场景需要频仍插入和删除的场景 3.2 Vector 与 CopyOnWriteArrayList

特性VectorCopyOnWriteArrayList同步性方法级别同步基于写时复制的同步机制性能较低（由于同步开销）适用于读多写少的场景迭代安全性在迭代期间修改会抛出 ConcurrentModificationException迭代期间修改不会影响当前迭代适用场景需要线程安全且写利用频仍的场景需要线程安全且读利用频仍的场景 4. List 接口的常用方法

以下是 List 接口的一些常用方法及其说明：
方法描述add(E e)在列表末尾添加一个元素。add(int index, E element)在指定位置插入一个元素。get(int index)返回指定位置的元素。set(int index, E element)替换指定位置的元素。remove(int index)移除指定位置的元素。remove(Object o)移除第一个匹配的元素。size()返回列表中的元素个数。isEmpty()查抄列表是否为空。contains(Object o)查抄列表是否包含指定元素。clear()移除列表中的所有元素。indexOf(Object o)返回顾次出现指定元素的索引，如果不存在则返回 -1。lastIndexOf(Object o)返回最后一次出现指定元素的索引，如果不存在则返回 -1。subList(int fromIndex, int toIndex)返回列表的一个子视图，包含从 fromIndex（包含）到 toIndex（不包含）的元素。 4.1 示例：List 的常用利用

1. import java.util.List;
2. import java.util.ArrayList;
4. public class ListMethodsExample {
5.     public static void main(String[] args) {
6.         List<String> fruits = new ArrayList<>();
8.         // 添加元素
9.         fruits.add("Apple");
10.         fruits.add("Banana");
11.         fruits.add("Cherry");
12.         fruits.add("Date");
13.         fruits.add("Elderberry");
15.         System.out.println("Initial List: " + fruits);
17.         // 插入元素
18.         fruits.add(2, "Coconut");
19.         System.out.println("After inserting Coconut at index 2: " + fruits);
21.         // 获取元素
22.         String fruitAt3 = fruits.get(3);
23.         System.out.println("Element at index 3: " + fruitAt3);
25.         // 修改元素
26.         fruits.set(1, "Blueberry");
27.         System.out.println("After setting index 1 to Blueberry: " + fruits);
29.         // 删除元素（按索引）
30.         fruits.remove(4);
31.         System.out.println("After removing element at index 4: " + fruits);
33.         // 删除元素（按对象）
34.         fruits.remove("Date");
35.         System.out.println("After removing 'Date': " + fruits);
37.         // 查询操作
38.         System.out.println("List size: " + fruits.size());
39.         System.out.println("List contains 'Apple': " + fruits.contains("Apple"));
40.         System.out.println("List contains 'Date': " + fruits.contains("Date"));
42.         // 获取子列表
43.         List<String> subFruits = fruits.subList(1, 3);
44.         System.out.println("Sublist from index 1 to 3: " + subFruits);
46.         // 清空列表
47.         fruits.clear();
48.         System.out.println("After clearing, is list empty? " + fruits.isEmpty());
49.     }
50. }

复制代码

输出：

1. Initial List: [Apple, Banana, Cherry, Date, Elderberry]
2. After inserting Coconut at index 2: [Apple, Banana, Coconut, Cherry, Date, Elderberry]
3. Element at index 3: Cherry
4. After setting index 1 to Blueberry: [Apple, Blueberry, Coconut, Cherry, Date, Elderberry]
5. After removing element at index 4: [Apple, Blueberry, Coconut, Cherry, Elderberry]
6. After removing 'Date': [Apple, Blueberry, Coconut, Cherry, Elderberry]
7. List size: 5
8. List contains 'Apple': true
9. List contains 'Date': false
10. Sublist from index 1 to 3: [Blueberry, Coconut]
11. After clearing, is list empty? true

复制代码

5. List 与其他聚集的对比

5.1 List vs Set

特性ListSet元素重复性允许重复元素不允许重复元素元素顺序保持元素的插入顺序，并支持按索引访问一般不保证元素的顺序（某些实现如 LinkedHashSet 保持插入顺序，TreeSet 按自然顺序或自界说顺序排序）实现类ArrayList、LinkedList、Vector 等HashSet、LinkedHashSet、TreeSet 等适用场景需要有序且可重复的元素聚集需要确保元素唯一性且不关心顺序（或有特定顺序要求） 5.2 List vs Queue

特性ListQueue元素访问方式支持按索引访问元素重要支持FIFO（先进先出）或其他特定的访问顺序常用实现类ArrayList、LinkedListLinkedList、PriorityQueue、ArrayDeque适用场景需要按恣意顺序访问和利用元素需要按特定顺序处置惩罚元素，如使命调理、消息队列等 6. 线程安全的 List 实现

在多线程环境下，选择符合的 List 实现类和同步机制非常重要，以确保数据的划一性和克制并发问题。
6.1 使用 Collections.synchronizedList

通过 Collections.synchronizedList 方法可以将任何 List 实现类包装为线程安全的列表。

• 示例：
  
  1. import java.util.List;
  2. import java.util.ArrayList;
  3. import java.util.Collections;
  5. public class SynchronizedListExample {
  6.     public static void main(String[] args) {
  7.         List<String> syncList = Collections.synchronizedList(new ArrayList<>());
  9.         syncList.add("Apple");
  10.         syncList.add("Banana");
  11.         syncList.add("Cherry");
  13.         // 迭代时需要手动同步
  14.         synchronized (syncList) {
  15.             for (String fruit : syncList) {
  16.                 System.out.println(fruit);
  17.             }
  18.         }
  19.     }
  20. }

  复制代码

6.2 使用 CopyOnWriteArrayList

CopyOnWriteArrayList 是一个线程安全的 List 实现，适用于读多写少的并发场景。

• 示例：
  
  1. import java.util.List;
  2. import java.util.concurrent.CopyOnWriteArrayList;
  4. public class CopyOnWriteArrayListThreadSafeExample {
  5.     public static void main(String[] args) {
  6.         List<String> cowList = new CopyOnWriteArrayList<>();
  7.         cowList.add("Apple");
  8.         cowList.add("Banana");
  9.         cowList.add("Cherry");
  11.         // 迭代时无需额外同步
  12.         for (String fruit : cowList) {
  13.             System.out.println(fruit);
  14.         }
  15.     }
  16. }

  复制代码

6.3 性能考虑

• Collections.synchronizedList：
  
  
  
  • 长处：适用于需要全面同步的场景。
    
  • 缺点：需要手动同步迭代利用，可能导致性能瓶颈。
    
  
  
• CopyOnWriteArrayList：
  
  
  
  • 长处：读利用无需同步，迭代时不会抛出 ConcurrentModificationException。
    
  • 缺点：写利用开销较大，每次写利用都会复制整个数组。
    
  
  

7. List 的泛型与范例安全

List 接口是泛型接口，可以指定存储的元素范例，从而在编译时提供范例安全，克制范例转换错误。
7.1 使用泛型的优势

• 范例安全：在编译时查抄元素范例，克制运行时范例错误。
  
• 无需范例转换：获取元素时无需举行显式的范例转换。
  
• 示例：
  
  1. import java.util.List;
  2. import java.util.ArrayList;
  4. public class GenericListExample {
  5.     public static void main(String[] args) {
  6.         List<String> stringList = new ArrayList<>();
  7.         stringList.add("Hello");
  8.         stringList.add("World");
  9.         // stringList.add(123); // 编译错误
  11.         for (String str : stringList) {
  12.             System.out.println(str.toUpperCase());
  13.         }
  14.     }
  15. }

  复制代码

7.2 未使用泛型的风险

如果不使用泛型，List 将存储 Object 范例，可能导致运行时范例错误，需要举行范例转换。

• 示例：
  
  1. import java.util.List;
  2. import java.util.ArrayList;
  4. public class RawListExample {
  5.     public static void main(String[] args) {
  6.         List list = new ArrayList();
  7.         list.add("Hello");
  8.         list.add(123); // 允许添加不同类型的元素
  10.         for (Object obj : list) {
  11.             String str = (String) obj; // 可能抛出 ClassCastException
  12.             System.out.println(str.toUpperCase());
  13.         }
  14.     }
  15. }

  复制代码
  输出：
  
  1. HELLO
  2. Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
  3.     at RawListExample.main(RawListExample.java:10)

  复制代码

8. 综合示例：List 的各种利用

以下是一个综合示例，展示了 List 的常用利用，包罗添加、插入、删除、修改、查询和遍历等。

1. import java.util.List;
2. import java.util.ArrayList;
3. import java.util.Iterator;
5. public class ComprehensiveListExample {
6.     public static void main(String[] args) {
7.         // 创建一个 ArrayList
8.         List<String> fruits = new ArrayList<>();
9.         
10.         // 添加元素
11.         fruits.add("Apple");
12.         fruits.add("Banana");
13.         fruits.add("Cherry");
14.         fruits.add("Date");
15.         fruits.add("Elderberry");
16.         System.out.println("Initial List: " + fruits);
17.         
18.         // 插入元素
19.         fruits.add(2, "Coconut");
20.         System.out.println("After inserting Coconut at index 2: " + fruits);
21.         
22.         // 获取元素
23.         String fruitAt3 = fruits.get(3);
24.         System.out.println("Element at index 3: " + fruitAt3);
25.         
26.         // 修改元素
27.         fruits.set(1, "Blueberry");
28.         System.out.println("After setting index 1 to Blueberry: " + fruits);
29.         
30.         // 删除元素（按索引）
31.         fruits.remove(4);
32.         System.out.println("After removing element at index 4: " + fruits);
33.         
34.         // 删除元素（按对象）
35.         fruits.remove("Date");
36.         System.out.println("After removing 'Date': " + fruits);
37.         
38.         // 查询操作
39.         System.out.println("List size: " + fruits.size());
40.         System.out.println("List contains 'Apple': " + fruits.contains("Apple"));
41.         System.out.println("List contains 'Date': " + fruits.contains("Date"));
42.         
43.         // 获取子列表
44.         List<String> subFruits = fruits.subList(1, 3);
45.         System.out.println("Sublist from index 1 to 3: " + subFruits);
46.         
47.         // 遍历列表（使用增强的 for 循环）
48.         System.out.println("Iterating using enhanced for loop:");
49.         for (String fruit : fruits) {
50.             System.out.println(fruit);
51.         }
52.         
53.         // 遍历列表（使用 Iterator）
54.         System.out.println("Iterating using Iterator:");
55.         Iterator<String> iterator = fruits.iterator();
56.         while (iterator.hasNext()) {
57.             System.out.println(iterator.next());
58.         }
59.         
60.         // 使用 Lambda 表达式和 forEach 方法遍历
61.         System.out.println("Iterating using forEach and Lambda:");
62.         fruits.forEach(fruit -> System.out.println(fruit));
63.         
64.         // 清空列表
65.         fruits.clear();
66.         System.out.println("After clearing, is list empty? " + fruits.isEmpty());
67.     }
68. }

复制代码

输出：

1. Initial List: [Apple, Banana, Cherry, Date, Elderberry]
2. After inserting Coconut at index 2: [Apple, Banana, Coconut, Cherry, Date, Elderberry]
3. Element at index 3: Cherry
4. After setting index 1 to Blueberry: [Apple, Blueberry, Coconut, Cherry, Date, Elderberry]
5. After removing element at index 4: [Apple, Blueberry, Coconut, Cherry, Elderberry]
6. After removing 'Date': [Apple, Blueberry, Coconut, Cherry, Elderberry]
7. List size: 5
8. List contains 'Apple': true
9. List contains 'Date': false
10. Sublist from index 1 to 3: [Blueberry, Coconut]
11. Iterating using enhanced for loop:
12. Apple
13. Blueberry
14. Coconut
15. Cherry
16. Elderberry
17. Iterating using Iterator:
18. Apple
19. Blueberry
20. Coconut
21. Cherry
22. Elderberry
23. Iterating using forEach and Lambda:
24. Apple
25. Blueberry
26. Coconut
27. Cherry
28. Elderberry
29. After clearing, is list empty? true

复制代码

9. 性能优化与最佳实践

9.1 预设容量

在已知大致元素数目时，可以在创建 ArrayList 时预设初始容量，以淘汰扩容次数，提拔性能。

• 示例：
  
  1. List<String> largeList = new ArrayList<>(1000); // 预设初始容量为 1000

  复制代码

9.2 使用接口范例声明

在声明变量时，使用接口范例（如 List）而不是具体实现类（如 ArrayList），提高代码的灵活性和可维护性。

• 示例：
  
  1. List<String> list = new ArrayList<>();
  2. // 未来可以轻松切换为其他实现类，如 LinkedList
  3. list = new LinkedList<>();

  复制代码

9.3 克制频仍的自动装箱与拆箱

对于存储根本数据范例的 List，使用其包装类（如 Integer、Double）时，应留意克制频仍的自动装箱与拆箱，以提拔性能。

• 示例：
  
  1. List<Integer> numbers = new ArrayList<>();
  2. for (int i = 0; i < 1000; i++) {
  3.     numbers.add(i); // 自动装箱
  4. }

  复制代码
  优化：如果需要大量的数值数据处置惩罚，考虑使用 IntStream 或其他专用的数据结构。
  

10. 总结

List 接口在 Java 聚集框架中占据重要职位，提供了有序、可重复的元素聚集。通过了解差别 List 实现类的特性、性能和适用场景，可以在项目中选择最符合的实现类，从而优化代码的性能和可维护性。以下是关键要点：

• 选择符合的实现类：
  
  
  
  • ArrayList：适用于需要快速随机访问和较少插入删除利用的场景。
    
  • LinkedList：适用于需要频仍插入和删除利用，尤其是在列表中间位置的场景。
    
  • Vector：适用于需要线程安全的场景，但由于同步开销，性能较低。
    
  • CopyOnWriteArrayList：适用于读多写少的并发场景。
    
  
  
• 使用泛型：提高范例安全，克制运行时范例错误。
  
• 遵循接口编程：使用接口范例声明变量，增强代码的灵活性和可维护性。
  
• 性能优化：根据具体需求预设容量，克制不必要的装箱与拆箱。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。