深入解析 Java 中的 List 集合声明与使用

好事发生

  这里先给大家推荐一篇实用的好文章：《深入掌握栈与队列，用Java构建高效数据处理之道》 来自作者：bug菌

  这篇文章作者详细探讨Java语言下栈和队列的实现与应用，包括两者的特性、源码实现、典型应用场景和常见测试用例。通过通俗易懂的解释和代码实例，帮助你轻松理解栈和队列的工作机制，并应用到实际开发中。

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

在上期的文章中，我们讨论了如何在 Java 中获取 Object 对象中的值，通过类型转换、泛型与反射等技术实现了灵活的对象操作。这次，我们将把目光转向 Java 中最常用的数据结构之一——集合（Collection），尤其是其核心接口之一：List。

在 Java 开发中，List 集合常用于存储有序的元素，具有灵活性、可扩展性等优点。本期文章将深入探讨如何在 Java 中声明 List 集合，分析 List 的源码及其核心方法，分享使用案例与最佳实践，并通过优缺点分析帮助开发者更好地理解与应用 List。

摘要

List 是 Java 集合框架中一个常用的接口，主要用于存储有序、可重复的元素。本文将通过源码解析、案例分享等多种方式，详细介绍如何在 Java 中声明和使用 List 集合，包括其不同的实现类（如 ArrayList、LinkedList）的特点与适用场景。同时，文章还将讨论 List 的优缺点及其常用方法，帮助开发者更好地掌握这一数据结构。

概述

Java 集合框架（Java Collections Framework, JCF）提供了丰富的数据结构，其中 List 是一个重要的接口，用于存储元素的有序集合。List 允许存储重复的元素，并且能通过索引精确定位每个元素。Java 提供了多种 List 的实现类，如：

• ArrayList：基于动态数组实现，支持随机访问。
• LinkedList：基于双向链表实现，适合频繁插入和删除操作。

List 是 Collection 接口的子接口，它继承了集合框架的基本操作并提供了额外的方法来处理有序数据。接下来我们将详细解析如何在 Java 中声明 List，并使用不同的实现类来应对各种开发场景。

源码解析

在 Java 中，声明一个 List 集合通常是通过接口和实现类的组合来实现的。由于 List 是一个接口，我们无法直接实例化它，而是通过其实现类进行实例化。下面我们通过常用的两种 List 实现类 ArrayList 和 LinkedList 来进行解析。

1. 使用 ArrayList 声明 List

ArrayList 是最常用的 List 实现类，内部基于动态数组实现，适合频繁的随机访问操作。

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

public class ListExample {
    public static void main(String[] args) {
        // 声明并初始化 ArrayList
        List<String> arrayList = new ArrayList<>();
        
        // 添加元素
        arrayList.add("Java");
        arrayList.add("Python");
        arrayList.add("C++");

        // 遍历 List 集合
        for (String language : arrayList) {
            System.out.println(language);
        }
    }
}

在上面的代码中，我们声明了一个 List 集合，并使用 ArrayList 作为实现。通过 add 方法可以向集合中添加元素，遍历集合时可以使用增强型 for 循环。

2. 使用 LinkedList 声明 List

LinkedList 是基于链表的 List 实现类，适合频繁的插入和删除操作，因为插入或删除元素时无需移动其他元素。

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

public class LinkedListExample {
    public static void main(String[] args) {
        // 声明并初始化 LinkedList
        List<Integer> linkedList = new LinkedList<>();
        
        // 添加元素
        linkedList.add(10);
        linkedList.add(20);
        linkedList.add(30);

        // 遍历 List 集合
        for (Integer number : linkedList) {
            System.out.println(number);
        }
    }
}

此示例展示了 LinkedList 的使用，与 ArrayList 类似，但内部实现差异较大。由于 LinkedList 基于链表，因此在插入或删除操作中，它表现得比 ArrayList 更高效，特别是在中间位置插入或删除元素时。

使用案例分享

案例 1：基于 ArrayList 的用户管理系统

在一个用户管理系统中，我们可以使用 ArrayList 来存储用户信息。ArrayList 提供了快速随机访问用户信息的能力，适合频繁读取用户数据的场景。

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

public class UserManager {
    private List<String> users;

    public UserManager() {
        users = new ArrayList<>();
    }

    public void addUser(String user) {
        users.add(user);
    }

    public void removeUser(String user) {
        users.remove(user);
    }

    public void printUsers() {
        for (String user : users) {
            System.out.println(user);
        }
    }

    public static void main(String[] args) {
        UserManager userManager = new UserManager();
        userManager.addUser("Alice");
        userManager.addUser("Bob");
        userManager.addUser("Charlie");

        userManager.printUsers();
        
        userManager.removeUser("Bob");
        userManager.printUsers();
    }
}

这个简单的用户管理系统展示了如何使用 ArrayList 来添加、移除和遍历用户信息。ArrayList 的性能适合这种需要频繁查询的场景。

案例 2：基于 LinkedList 的任务调度系统

在一个任务调度系统中，我们可以使用 LinkedList 来处理任务队列。由于 LinkedList 在头部和尾部插入删除元素的性能较好，它适合用于 FIFO（先进先出）队列的场景。

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

public class TaskScheduler {
    private List<String> taskQueue;

    public TaskScheduler() {
        taskQueue = new LinkedList<>();
    }

    public void addTask(String task) {
        taskQueue.add(task);
    }

    public String getNextTask() {
        if (!taskQueue.isEmpty()) {
            return taskQueue.remove(0); // 移除并返回第一个任务
        }
        return null;
    }

    public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler();
        scheduler.addTask("Task 1");
        scheduler.addTask("Task 2");
        scheduler.addTask("Task 3");

        System.out.println("Next task: " + scheduler.getNextTask());
        System.out.println("Next task: " + scheduler.getNextTask());
    }
}

通过 LinkedList，我们实现了一个简单的任务调度器，它能够按照插入顺序处理任务。由于 LinkedList 在头尾元素的操作中性能优异，这使得它非常适合此类队列操作。

应用场景案例

适用场景

• ArrayList 适用场景：
  • 频繁读取操作：ArrayList 允许通过索引快速访问元素，因此适合频繁读取或查询的场景。
  • 有序数据存储：在需要保存元素顺序的场景中（如管理商品列表、用户数据等），ArrayList 是一个理想的选择。
• LinkedList 适用场景：
  • 频繁插入和删除操作：由于 LinkedList 基于链表实现，因此在需要频繁插入或删除元素的场景中具有明显优势。
  • 队列和栈的实现：LinkedList 可以用来实现队列（FIFO）和栈（LIFO）数据结构。

不适用场景

• ArrayList 不适用场景：
  • 频繁插入和删除操作：在 ArrayList 中，插入或删除元素时，可能需要移动大量元素，性能较差。
• LinkedList 不适用场景：
  • 频繁随机访问：由于 LinkedList 需要通过遍历找到指定位置的元素，它不适合频繁的随机访问。

优缺点分析

ArrayList 优缺点

• 优点：
  • 支持快速的随机访问，通过索引可以高效地读取或修改元素。
  • 存储连续的数据，内存消耗较少。
• 缺点：
  • 插入和删除元素效率较低，特别是在中间位置插入或删除时，需要移动后续的元素。
  • 扩容时可能需要重新分配内存，性能可能出现波动。

LinkedList 优缺点

• 优点：
  • 插入和删除元素效率高，特别是在头尾位置操作时性能最优。
  • 不需要连续的内存空间，链表节点的动态分

配可以更灵活地管理内存。

• 缺点：
  • 随机访问性能较差，必须通过遍历才能找到指定位置的元素。
  • 每个节点都需要额外的存储空间来维护链表的前后指针，内存开销较大。

核心类方法介绍

List 接口的常用方法包括：

• add(E e)：向列表中添加元素。
• remove(Object o)：移除列表中的指定元素。
• get(int index)：获取指定位置的元素。
• set(int index, E element)：替换指定位置的元素。
• size()：返回列表中元素的数量。
• isEmpty()：判断列表是否为空。

测试用例

为了确保 List 的功能正常，我们可以编写测试用例来验证其行为。

测试代码

import org.junit.Test;
import java.util.List;
import java.util.ArrayList;
import static org.junit.Assert.*;

public class ListTest {

    @Test
    public void testAddAndRemove() {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        
        assertEquals(2, list.size());
        
        list.remove("Python");
        assertEquals(1, list.size());
        assertEquals("Java", list.get(0));
    }

    @Test
    public void testGetAndSet() {
        List<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        
        assertEquals(200, (int) list.get(1));
        
        list.set(1, 300);
        assertEquals(300, (int) list.get(1));
    }
}

通过这些测试用例，我们验证了 List 集合的添加、删除、获取与设置元素等常用操作。

代码解析：

如下是具体的代码解析，希望对大家有所帮助：这段Java代码定义了一个名为 ListTest 的测试类，其中包含两个测试方法，用于测试Java List 接口的添加、删除、获取和设置元素的功能。

下面是这段代码的详细解读：

第一个测试方法：testAddAndRemove

1. @Test public void testAddAndRemove() { ... }：定义了一个名为 testAddAndRemove 的测试方法。
2. 创建一个空的 ArrayList：
   • List<String> list = new ArrayList<>();：创建一个 ArrayList 实例，用于存储字符串。
3. 添加元素：
   • list.add("Java");：向列表中添加字符串 "Java"。
   • list.add("Python");：向列表中添加字符串 "Python"。
4. 验证列表大小：
   • assertEquals(2, list.size());：使用 assertEquals 断言方法验证列表大小是否为2。
5. 删除元素：
   • list.remove("Python");：从列表中删除字符串 "Python"。
6. 再次验证列表大小和内容：
   • assertEquals(1, list.size());：使用 assertEquals 断言方法验证列表大小是否变为1。
   • assertEquals("Java", list.get(0));：使用 assertEquals 断言方法验证列表中剩余的元素是否为 "Java"。

第二个测试方法：testGetAndSet

1. @Test public void testGetAndSet() { ... }：定义了一个名为 testGetAndSet 的测试方法。
2. 创建一个空的 ArrayList：
   • List<Integer> list = new ArrayList<>();：创建一个 ArrayList 实例，用于存储整数。
3. 添加元素：
   • list.add(100);：向列表中添加整数100。
   • list.add(200);：向列表中添加整数200。
4. 获取元素：
   • assertEquals(200, (int) list.get(1));：使用 assertEquals 断言方法验证获取的第二个元素是否为200。
5. 设置元素：
   • list.set(1, 300);：将列表中第二个元素的值设置为300。
6. 验证设置后的元素：
   • assertEquals(300, (int) list.get(1));：使用 assertEquals 断言方法验证第二个元素的值是否变为300。

详细解读：

1. 测试添加和删除操作：
   • 创建一个空的 ArrayList，添加两个字符串元素。
   • 验证列表大小，删除一个元素，再次验证列表大小和剩余元素。
2. 测试获取和设置操作：
   • 创建一个空的 ArrayList，添加两个整数元素。
   • 获取一个元素，验证其值，然后设置新值，并验证设置后的值。

总结：

这个测试类 ListTest 包含了两个测试方法，分别测试了 List 接口的添加和删除操作以及获取和设置操作。通过创建列表，添加元素，然后执行删除、获取、设置等操作，并使用JUnit断言方法验证预期结果，测试确认了 List 接口的这些功能。

注意：代码中使用了 ArrayList 类的实例来测试 List 接口的方法，因为 ArrayList 是 List 接口的一个常见实现。此外，测试方法的名称表明了它们各自的测试目的。

小结

在本文中，我们详细介绍了如何在 Java 中声明和使用 List 集合，分别解析了 ArrayList 和 LinkedList 两种常用实现的特点与应用场景。通过源代码和案例，我们展示了如何选择合适的 List 实现来应对不同的需求场景。通过测试用例的验证，我们进一步确保了这些集合的功能正确性。

总结

Java 集合框架为开发者提供了灵活高效的数据结构，而 List 是其中最常用的接口之一。通过本文的学习，开发者应该能够在具体场景中正确选择 ArrayList 或 LinkedList，并掌握它们的优缺点，从而在项目中更加高效地处理有序数据。

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

... ...

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

***

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。