Java中List介绍及常见方法和五种遍历方式详解

Java的List介绍

在Java中，List接口是集合框架的一部分，它定义了一个有序的集合，允许存储重复的元素，并且可以通过索引访问这些元素。List继承自Collection接口，提供了额外的功能来处理有序集合。List的主要特点包括：

• 有序性：存取元素的顺序与插入时的顺序一致。
• 可重复性：允许存储重复的元素。
• 索引访问：可以通过整数索引来访问和操作元素。

常见的List实现类有ArrayList、LinkedList、Vector和Stack等。其中，ArrayList基于动态数组实现，适合频繁的随机访问；而LinkedList基于双向链表实现，更适合频繁的插入和删除操作。

List常见方法

以下是List接口的一些常用方法及其示例代码：

• 添加元素

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

  import java.util.ArrayList;
  import java.util.List;
  
  public class ListAddExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add(1, "Orange"); // 在索引1处插入"Orange"
          System.out.println("After adding elements: " + list);
  
          List<String> moreFruits = new ArrayList<>();
          moreFruits.add("Grape");
          moreFruits.add("Peach");
          list.addAll(moreFruits); // 添加到末尾
          list.addAll(1, moreFruits); // 从索引1开始添加
          System.out.println("After adding all elements: " + list);
      }
  }
  

• 获取元素

  • get(int index)：返回列表中指定位置的元素。
  • indexOf(Object o)：返回首次出现的指定元素的索引；如果未找到，则返回-1。
  • lastIndexOf(Object o)：返回最后一次出现的指定元素的索引；如果未找到，则返回-1。

  import java.util.ArrayList;
  import java.util.List;
  
  public class ListGetExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          String fruit = list.get(1); // 获取索引1处的元素
          System.out.println("Element at index 1: " + fruit);
  
          int index = list.indexOf("Orange"); // 查找"Orange"的索引
          System.out.println("Index of 'Orange': " + index);
  
          int lastIndex = list.lastIndexOf("Banana"); // 查找最后一个"Banana"的索引
          System.out.println("Last index of 'Banana': " + lastIndex);
      }
  }
  

• 修改元素

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

  import java.util.ArrayList;
  import java.util.List;
  
  public class ListSetExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          String oldFruit = list.set(1, "Grape"); // 修改索引1处的元素
          System.out.println("Replaced element: " + oldFruit);
          System.out.println("Updated list: " + list);
      }
  }
  

• 删除元素

  • remove(int index)：移除列表中指定位置的元素，并返回被移除的元素。
  • remove(Object o)：移除列表中第一次出现的指定元素（仅当存在时），并返回true，否则返回false。

  import java.util.ArrayList;
  import java.util.List;
  
  public class ListRemoveExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          String removedFruit = list.remove(1); // 移除索引1处的元素
          System.out.println("Removed element: " + removedFruit);
          System.out.println("Updated list: " + list);
  
          boolean isRemoved = list.remove("Apple"); // 移除第一个"Apple"
          System.out.println("Is 'Apple' removed? " + isRemoved);
          System.out.println("Final list: " + list);
      }
  }
  

• 查询元素

  • contains(Object o)：如果列表包含指定的元素，则返回true。
  • isEmpty()：如果列表不包含任何元素，则返回true。

  import java.util.ArrayList;
  import java.util.List;
  
  public class ListQueryExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          boolean containsBanana = list.contains("Banana");
          System.out.println("Does the list contain 'Banana'? " + containsBanana);
  
          boolean isEmpty = list.isEmpty();
          System.out.println("Is the list empty? " + isEmpty);
      }
  }
  

• 其他操作

  • clear()：从列表中移除所有元素。
  • size()：返回列表中的元素个数。
  • iterator()：返回一个迭代器，用于遍历列表中的元素。
  • listIterator()：返回一个ListIterator，可以双向遍历列表，并支持在遍历过程中添加或删除元素。

  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  
  public class ListOtherOperationsExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          System.out.println("List size: " + list.size());
  
          Iterator<String> iterator = list.iterator();
          while (iterator.hasNext()) {
              System.out.println("Iterator: " + iterator.next());
          }
  
          ListIterator<String> listIterator = list.listIterator();
          while (listIterator.hasNext()) {
              System.out.println("ListIterator forward: " + listIterator.next());
          }
          while (listIterator.hasPrevious()) {
              System.out.println("ListIterator backward: " + listIterator.previous());
          }
  
          list.clear(); // 清空列表
          System.out.println("Is the list empty after clearing? " + list.isEmpty());
      }
  }
  

五种遍历方式

• 迭代器（Iterator）

  • 使用Iterator接口提供的hasNext()和next()方法来遍历列表。这种方式适用于需要在遍历过程中移除元素的情况，因为Iterator提供了安全地移除元素的能力，避免了ConcurrentModificationException的风险。

  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  public class IteratorTraversalExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          Iterator<String> iterator = list.iterator();
          while (iterator.hasNext()) {
              String item = iterator.next();
              System.out.println(item);
              if ("Banana".equals(item)) {
                  iterator.remove(); // 安全地移除当前元素
              }
          }
          System.out.println("List after removal: " + list);
      }
  }
  

• 增强for循环（Enhanced for loop）

  • 增强for循环（也称为foreach循环）提供了一种更简洁的方式来遍历List，无需显式地管理索引。代码更加清晰易读，适合不需要索引信息的场景。

  import java.util.ArrayList;
  import java.util.List;
  
  public class EnhancedForLoopTraversalExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          for (String item : list) {
              System.out.println(item);
          }
      }
  }
  

• 普通for循环

  • 使用传统的for循环是遍历List最直接的方式之一。这种方式允许你通过索引访问列表中的元素，适用于需要知道当前元素位置或需要根据索引进行操作的情况。

  import java.util.ArrayList;
  import java.util.List;
  
  public class ForLoopTraversalExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          for (int i = 0; i < list.size(); i++) {
              System.out.println("Index " + i + ": " + list.get(i));
          }
      }
  }
  

• Stream API（Java 8+）

  • 自Java 8起引入的Stream API为集合操作提供了强大的功能，包括但不限于过滤、映射、排序等。它允许以声明式的方式编写复杂的集合操作逻辑，并且可以轻松地转换成并行流（parallel stream），从而利用多核处理器的优势加速处理速度。

  import java.util.ArrayList;
  import java.util.List;
  
  public class StreamApiTraversalExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          list.stream().forEach(System.out::println); // 单线程遍历
          // 或者使用并行流
          // list.parallelStream().forEach(System.out::println);
      }
  }
  

• 列表迭代器（ListIterator）

  • ListIterator是Iterator的一个子接口，专门用于List集合。它不仅支持双向遍历（向前和向后），还可以在遍历过程中添加或删除元素。这使得ListIterator在某些特定场景下非常有用。

  import java.util.ArrayList;
  import java.util.List;
  import java.util.ListIterator;
  
  public class ListIteratorTraversalExample {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          ListIterator<String> listIterator = list.listIterator();
          while (listIterator.hasNext()) {
              String item = listIterator.next();
              System.out.println("Forward: " + item);
              if ("Banana".equals(item)) {
                  listIterator.add("Grape"); // 在当前元素后添加新元素
              }
          }
          System.out.println("List after addition: " + list);
  
          while (listIterator.hasPrevious()) {
              String item = listIterator.previous();
              System.out.println("Backward: " + item);
              if ("Banana".equals(item)) {
                  listIterator.remove(); // 移除当前元素
              }
          }
          System.out.println("List after removal: " + list);
      }
  }
  

总结

List接口及其常见实现类如ArrayList和LinkedList是Java编程中不可或缺的部分，提供了丰富的API来处理有序集合。通过理解List的特点和常用方法，以及掌握五种遍历方式，开发者可以根据具体需求选择最合适的方式来操作List集合。无论是简单的遍历还是复杂的集合操作，Java都提供了灵活且高效的解决方案。

到此这篇关于Java中List介绍及常见方法和五种遍历方式的文章就介绍到这了,更多相关Java List常见方法和遍历方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论