跳转至

Java List 之 new 操作：深入解析与最佳实践

简介

在 Java 编程中，List 是一种极为常用的数据结构，它提供了有序且可重复元素的存储方式。而使用 new 关键字来创建 List 对象是开始使用 List 的基础操作。本文将详细探讨 new 关键字在创建 List 时的基础概念、各种使用方法、常见实践场景以及最佳实践建议，帮助读者全面掌握并高效运用这一重要特性。

目录

  1. 基础概念
    • 什么是 List
    • new 关键字的作用
  2. 使用方法
    • 创建 ArrayList
    • 创建 LinkedList
    • 创建不可变 List
  3. 常见实践
    • 添加元素
    • 访问元素
    • 删除元素
    • 遍历 List
  4. 最佳实践
    • 根据需求选择合适的 List 实现类
    • 避免不必要的对象创建
    • 泛型的正确使用
  5. 小结
  6. 参考资料

基础概念

什么是 List

List 是 Java 集合框架中的一个接口，它继承自 Collection 接口。List 的主要特点是有序（元素的存储顺序和插入顺序一致）且允许元素重复。常见的实现类有 ArrayList 和 LinkedList。

new 关键字的作用

在 Java 中，new 关键字用于在堆内存中创建一个对象的实例。当我们使用 new 来创建 List 对象时，实际上是在为 List 的某个实现类（如 ArrayList 或 LinkedList）分配内存空间，并返回一个指向该对象的引用。

使用方法

创建 ArrayList

ArrayList 是基于数组实现的 List，它提供了快速的随机访问。以下是创建 ArrayList 的示例代码：

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

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

        // 创建一个指定初始容量的 ArrayList
        List<Integer> list2 = new ArrayList<>(10);

        // 使用初始化值创建 ArrayList
        List<Double> list3 = new ArrayList<>(List.of(1.1, 2.2, 3.3));
    }
}

创建 LinkedList

LinkedList 是基于双向链表实现的 List，它在插入和删除操作上具有较好的性能。示例代码如下：

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

public class LinkedListExample {
    public static void main(String[] args) {
        // 创建一个空的 LinkedList
        List<String> list1 = new LinkedList<>();

        // 使用初始化值创建 LinkedList
        List<Integer> list2 = new LinkedList<>(List.of(1, 2, 3));
    }
}

创建不可变 List

从 Java 9 开始，可以使用 List.of 方法创建不可变的 List。不可变 List 一旦创建，就不能添加、删除或修改元素。

import java.util.List;

public class ImmutableListExample {
    public static void main(String[] args) {
        List<String> immutableList = List.of("apple", "banana", "cherry");
        // 以下操作会抛出 UnsupportedOperationException
        // immutableList.add("date"); 
    }
}

常见实践

添加元素

可以使用 add 方法向 List 中添加元素。示例如下：

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

public class AddElementExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("item1");
        list.add("item2");
        list.add(1, "item1.5"); // 在指定位置插入元素
    }
}

访问元素

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

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

public class AccessElementExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        String element = list.get(1);
        System.out.println(element); // 输出 "banana"
    }
}

删除元素

使用 remove 方法可以删除 List 中的元素。

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

public class RemoveElementExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("item1");
        list.add("item2");
        list.remove("item2"); // 删除指定元素
        list.remove(0); // 删除指定索引位置的元素
    }
}

遍历 List

常见的遍历 List 的方式有以下几种：

普通 for 循环

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");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

for-each 循环

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

public class ForEachTraversalExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        for (String item : list) {
            System.out.println(item);
        }
    }
}

Iterator

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");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);
        }
    }
}

最佳实践

根据需求选择合适的 List 实现类

  • 如果需要频繁的随机访问，ArrayList 是更好的选择，因为它基于数组实现，访问速度快。
  • 如果需要频繁的插入和删除操作，LinkedList 性能更优，因为它基于链表结构，插入和删除操作无需移动大量元素。

避免不必要的对象创建

尽量重用已有的 List 对象，而不是频繁地创建新的 List。例如，如果只是需要对 List 进行临时操作，可以考虑使用方法参数传递，而不是在方法内部创建新的 List。

泛型的正确使用

始终使用泛型来指定 List 中元素的类型，这样可以提高代码的可读性和安全性，避免运行时的类型转换错误。例如：List<String> list = new ArrayList<>(); 而不是 List list = new ArrayList();

小结

本文围绕 Java 中使用 new 关键字创建 List 的操作，介绍了 List 的基础概念、多种创建方式、常见实践操作以及最佳实践建议。通过深入理解这些内容，读者能够更加熟练地运用 List 来解决实际编程中的问题，提高代码的质量和性能。

参考资料