Java List 详解：从基础到最佳实践

简介

在 Java 编程中，List 是一个非常重要的接口，它是 Collection 接口的子接口。List 提供了一种有序的集合方式，允许存储重复的元素。这种特性使得 List 在处理需要保持元素顺序，或者需要存储多个相同元素的场景中非常有用。本文将详细介绍 Java List 的基础概念、使用方法、常见实践以及最佳实践，帮助你更好地掌握和运用这一强大的工具。

目录

1. 基础概念
   • List 接口概述
   • List 与其他集合接口的区别
2. 使用方法
   • 创建 List 对象
   • 添加元素
   • 访问元素
   • 修改元素
   • 删除元素
   • 遍历 List
3. 常见实践
   • 排序
   • 搜索
   • 去重
4. 最佳实践
   • 选择合适的实现类
   • 避免不必要的装箱和拆箱
   • 优化遍历操作
5. 小结

基础概念

List 接口概述

List 接口继承自 Collection 接口，它定义了一个有序的集合，也称为序列。在 List 中，每个元素都有一个索引位置，通过索引可以方便地访问、插入和删除元素。List 允许存储重复的元素，这与 Set 接口不同，Set 接口中的元素是唯一的。

List 与其他集合接口的区别

• 与 Set 接口的区别：Set 接口中的元素是无序且唯一的，而 List 接口中的元素是有序的，可以包含重复元素。
• 与 Map 接口的区别：Map 接口存储的是键值对（key-value pairs），通过键来访问值，而 List 是通过索引来访问元素。

使用方法

创建 List 对象

在 Java 中，List 是一个接口，不能直接实例化。通常使用它的实现类，如 ArrayList 和 LinkedList。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListCreation {
    public static void main(String[] args) {
        // 创建一个 ArrayList
        List<String> arrayList = new ArrayList<>();

        // 创建一个 LinkedList
        List<String> linkedList = new LinkedList<>();
    }
}

添加元素

可以使用 add() 方法向 List 中添加元素。

import java.util.ArrayList;
import java.util.List;

public class ListAddElement {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        System.out.println(list);
    }
}

输出结果：[Apple, Banana, Cherry]

访问元素

可以使用 get() 方法通过索引访问 List 中的元素。

import java.util.ArrayList;
import java.util.List;

public class ListAccessElement {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        String element = list.get(1);
        System.out.println(element);
    }
}

输出结果：Banana

修改元素

使用 set() 方法可以修改 List 中指定索引位置的元素。

import java.util.ArrayList;
import java.util.List;

public class ListModifyElement {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        list.set(1, "Durian");
        System.out.println(list);
    }
}

输出结果：[Apple, Durian, Cherry]

删除元素

使用 remove() 方法可以删除 List 中的元素，可以通过索引或元素本身来删除。

import java.util.ArrayList;
import java.util.List;

public class ListRemoveElement {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 通过索引删除
        list.remove(1);
        System.out.println(list);

        // 通过元素本身删除
        list.remove("Cherry");
        System.out.println(list);
    }
}

输出结果：

[Apple, Cherry]
[Apple]

遍历 List

有多种方式可以遍历 List。

传统 for 循环

import java.util.ArrayList;
import java.util.List;

public class ListTraversalForLoop {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

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

foreach 循环

import java.util.ArrayList;
import java.util.List;

public class ListTraversalForEachLoop {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

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

使用迭代器

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTraversalIterator {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

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

常见实践

排序

可以使用 Collections.sort() 方法对 List 进行排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ListSorting {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(1);
        list.add(2);

        // 自然排序
        Collections.sort(list);
        System.out.println(list);

        // 自定义排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list);
    }
}

输出结果：

[1, 2, 3]
[3, 2, 1]

搜索

可以使用 Collections.binarySearch() 方法在有序 List 中进行二分查找。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListSearching {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        int index = Collections.binarySearch(list, 2);
        System.out.println(index);
    }
}

输出结果：1

去重

可以使用 Set 来实现 List 的去重。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ListDuplicateRemoval {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Apple");

        Set<String> set = new HashSet<>(list);
        List<String> newList = new ArrayList<>(set);
        System.out.println(newList);
    }
}

输出结果：[Apple, Banana]

最佳实践

选择合适的实现类

• ArrayList：适用于随机访问频繁的场景，因为它基于数组实现，通过索引访问元素的时间复杂度为 O(1)。但在插入和删除元素时效率较低，因为需要移动元素。
• LinkedList：适用于频繁插入和删除元素的场景，因为它基于链表实现，插入和删除操作的时间复杂度为 O(1)。但随机访问效率较低，需要从头遍历链表。

避免不必要的装箱和拆箱

在使用泛型 List 时，尽量使用包装类的基本数据类型版本，以避免自动装箱和拆箱带来的性能开销。

// 推荐使用
List<Integer> intList = new ArrayList<>();

// 避免使用
List<int[]> badIntList = new ArrayList<>();

优化遍历操作

• 对于随机访问为主的 List（如 ArrayList），使用传统 for 循环进行遍历效率更高，因为可以直接通过索引访问元素。
• 对于频繁插入和删除元素的 List（如 LinkedList），使用迭代器进行遍历更合适，因为迭代器可以更高效地处理这些操作。

小结

本文详细介绍了 Java List 的基础概念、使用方法、常见实践以及最佳实践。通过掌握这些知识，你可以在实际编程中更加灵活、高效地使用 List 来解决各种问题。希望本文能对你理解和运用 Java List 有所帮助，让你在 Java 编程的道路上更进一步。