List接口

List接口

• List 接口是 Java 集合框架中的一个核心接口，继承自 Collection 接口。它表示一个 有序的集合（序列），允许存储重复的元素，并且可以通过索引（下标）访问元素

List接口特点

1. 有序性：元素按照插入顺序存储，可以通过索引访问元素。
2. 允许重复元素：同一个元素可以多次添加到 List 中。
3. 支持索引操作：提供了基于索引的增删改查方法。
4. 允许 null 元素：List中可以存储 null 值。并且可以存储多个null值。

List接口方法

List 接口继承了 Collection 接口的所有方法，并添加了一些基于索引的操作方法。

1. 添加元素

   • boolean add(E e)：在列表末尾添加一个元素。
   • void add(int index, E element)：在指定索引位置插入一个元素。
   • boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到列表末尾。
   • boolean addAll(int index, Collection<? extends E> c)：从指定索引位置开始，插入指定集合中的所有元素。

2. 删除元素

   • E remove(int index)：移除指定索引位置的元素，并返回该元素。
   • boolean remove(Object o)：移除列表中第一个匹配的元素。
   • boolean removeAll(Collection<?> c)：移除列表中所有包含在指定集合中的元素。
   • boolean retainAll(Collection<?> c)：仅保留列表中包含在指定集合中的元素。
   • void clear()：清空列表中的所有元素。

3. 修改元素

   • E set(int index, E element)：用指定元素替换列表中指定索引位置的元素，并返回被替换的元素

4. 查询元素

   • E get(int index)：返回指定索引位置的元素。
   • int indexOf(Object o)：返回指定元素在列表中第一次出现的索引，如果不存在则返回 -1。
   • int lastIndexOf(Object o)：返回指定元素在列表中最后一次出现的索引，如果不存在则返回 -1。
   • boolean contains(Object o)：判断列表是否包含指定元素。
   • boolean containsAll(Collection<?> c)：判断列表是否包含指定集合中的所有元素。
   • boolean isEmpty()：判断列表是否为空。
   • int size()：返回列表中的元素数量

5. 遍历元素

   • Iterator<E> iterator()：返回一个用于遍历列表的迭代器。
   • ListIterator<E> listIterator()：返回一个列表迭代器，支持双向遍历和修改操作。
   • ListIterator<E> listIterator(int index)：从指定索引位置开始，返回一个列表迭代器

6. 子列表操作

   • List<E> subList(int fromIndex, int toIndex)：返回列表中从 fromIndex（包含）到 toIndex（不包含）的子列表

List接口的扩展

List 接口的列表迭代器 ListIterator 提供了更多功能，包括：

• 双向遍历：支持从前往后和从后往前遍历。

• 添加和修改元素：支持在遍历过程中添加和修改元素

• ListIterator 内部维护一个指针（游标），初始时指向列表的某个位置（默认是列表的开头）。每次调用 next() 或 previous() 时，指针会向后或向前移动，并返回当前指向的元素

• 由于指针的位置是动态的，因此可以在遍历过程中随时切换方向

• ListIterator 的指针指向两个元素之间的位置。

• 调用void add(E e)方法后在指针的当前位置插入元素，插入后，指针会移动到新插入的元素之后

• 如果指针在 A | B, C，调用 add("X") 会在 A 和 B 之间插入 X，结果为 [A, X, B, C]

  • 插入后，指针指向 X | B, C

• 如果指针在 A, B | C，（next()方法调用后）调用 remove() 会删除 B，结果为 [A, C]

  • 删除后，指针指向 A | C

  import java.util.ArrayList;
  import java.util.List;
  import java.util.ListIterator;
  
  public class ListIteratorBackwardExample {
      public static void main(String[] args) {
          // 创建一个 ArrayList
          List<String> list = new ArrayList<>();
          list.add("A");
          list.add("B");
          list.add("C");
  
          // 获取 ListIterator
          ListIterator<String> listIterator = list.listIterator();
  
          // 先正向遍历到末尾
          while (listIterator.hasNext()) {
              listIterator.next();
          }
  
          // 从后往前遍历
          System.out.println("从后往前遍历：");
          while (listIterator.hasPrevious()) {
              String item = listIterator.previous();
              System.out.println(item);
  
              // 在遍历过程中修改或添加元素
              if (item.equals("B")) {
                  listIterator.set("B-Updated"); // 修改元素
                  listIterator.add("B-New");    // 添加元素
              }
          }
  
          // 输出修改后的集合
          System.out.println("\n修改后的集合：");
          for (String item : list) {
              System.out.println(item);
          }
      }
  }
  

List接口的常见实现类

1. ArrayList：
   • 基于动态数组实现，支持快速随机访问。
   • 适合频繁查询和遍历的场景。
2. LinkedList：
   • 基于双向链表实现，支持高效的插入和删除操作。
   • 适合频繁增删的场景。
3. Vector：
   • 基于动态数组实现，线程安全（方法使用 synchronized 修饰）。
   • 性能较低，通常被 ArrayList 取代
4. Stack：
   • 继承自 Vector，表示后进先出（LIFO）的栈结构