Java 动态数组：深入解析与实践

简介

在 Java 编程中，数组是一种基本的数据结构，用于存储固定大小的同类型元素序列。然而，在许多实际应用场景下，我们需要能够动态调整大小的数组，这就是动态数组发挥作用的地方。本文将深入探讨 Java 中的动态数组，包括其基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一重要的编程工具。

目录

1. 基础概念
2. 使用方法
   • 2.1 使用 ArrayList 类
   • 2.2 自定义动态数组
3. 常见实践
   • 3.1 数据存储与检索
   • 3.2 动态添加与删除元素
4. 最佳实践
   • 4.1 初始容量设置
   • 4.2 性能优化
5. 小结
6. 参考资料

基础概念

动态数组（Dynamic Array），也称为可变数组（Resizable Array），是一种在运行时能够改变大小的数据结构。与传统的固定大小数组不同，动态数组可以根据需要自动增加或减少其容量。在 Java 中，虽然没有原生的动态数组类型，但提供了一些类和接口来实现类似的功能，其中最常用的是 ArrayList 类。

ArrayList 类是 Java 集合框架的一部分，它实现了 List 接口。它基于数组实现，但能够动态地调整大小。当 ArrayList 中的元素数量超过其当前容量时，它会自动创建一个更大的数组，并将原数组中的所有元素复制到新数组中。

使用方法

2.1 使用 ArrayList 类

要使用 ArrayList 类，首先需要导入 java.util.ArrayList 包。以下是一个简单的示例：

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建一个 ArrayList 对象
        ArrayList<String> list = new ArrayList<>();

        // 添加元素到 ArrayList
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 访问 ArrayList 中的元素
        System.out.println("第一个元素: " + list.get(0));

        // 修改 ArrayList 中的元素
        list.set(1, "Mango");
        System.out.println("修改后的第二个元素: " + list.get(1));

        // 删除 ArrayList 中的元素
        list.remove(2);
        System.out.println("删除第三个元素后的列表: " + list);

        // 获取 ArrayList 的大小
        System.out.println("列表的大小: " + list.size());
    }
}

2.2 自定义动态数组

虽然 ArrayList 类已经能够满足大多数动态数组的需求，但有时候我们可能需要自定义动态数组。以下是一个简单的自定义动态数组实现：

public class CustomDynamicArray {
    private int[] array;
    private int size;
    private int capacity;

    public CustomDynamicArray() {
        capacity = 10;
        array = new int[capacity];
        size = 0;
    }

    public void add(int element) {
        if (size == capacity) {
            resize();
        }
        array[size++] = element;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of range");
        }
        return array[index];
    }

    public void resize() {
        capacity *= 2;
        int[] newArray = new int[capacity];
        for (int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
    }

    public int size() {
        return size;
    }

    public static void main(String[] args) {
        CustomDynamicArray customArray = new CustomDynamicArray();
        customArray.add(1);
        customArray.add(2);
        customArray.add(3);

        System.out.println("第一个元素: " + customArray.get(0));
        System.out.println("数组的大小: " + customArray.size());
    }
}

常见实践

3.1 数据存储与检索

动态数组常用于存储和检索大量数据。例如，在一个学生管理系统中，可以使用 ArrayList 来存储学生信息：

import java.util.ArrayList;

class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class StudentManagementSystem {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 22));
        students.add(new Student("Charlie", 21));

        for (Student student : students) {
            System.out.println("Name: " + student.getName() + ", Age: " + student.getAge());
        }
    }
}

3.2 动态添加与删除元素

动态数组的一个重要特性是能够在运行时动态添加和删除元素。例如，在一个购物车系统中，可以使用 ArrayList 来管理商品：

import java.util.ArrayList;

class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

public class ShoppingCart {
    public static void main(String[] args) {
        ArrayList<Product> cart = new ArrayList<>();

        cart.add(new Product("iPhone", 999.99));
        cart.add(new Product("MacBook Pro", 1999.99));

        System.out.println("购物车中的商品:");
        for (Product product : cart) {
            System.out.println("Name: " + product.getName() + ", Price: " + product.getPrice());
        }

        // 删除商品
        cart.remove(1);
        System.out.println("删除商品后的购物车:");
        for (Product product : cart) {
            System.out.println("Name: " + product.getName() + ", Price: " + product.getPrice());
        }
    }
}

最佳实践

4.1 初始容量设置

在创建 ArrayList 时，可以指定初始容量。如果能够预先知道大概需要存储的元素数量，设置合适的初始容量可以减少动态扩容的次数，提高性能。例如：

ArrayList<String> list = new ArrayList<>(100);

4.2 性能优化

尽量避免在循环中频繁调用 add 方法，因为每次调用 add 方法时，如果当前容量不足，会触发扩容操作，这会带来性能开销。可以先预估元素数量，设置合适的初始容量，或者使用 ensureCapacity 方法来确保有足够的容量：

ArrayList<String> list = new ArrayList<>();
list.ensureCapacity(100);
for (int i = 0; i < 100; i++) {
    list.add("Element " + i);
}

小结

本文详细介绍了 Java 中的动态数组，包括基础概念、使用方法、常见实践以及最佳实践。通过使用 ArrayList 类或自定义动态数组，我们可以在编程中灵活地处理动态大小的数据集合。在实际应用中，合理设置初始容量和优化性能可以提高程序的效率和稳定性。希望本文能帮助读者更好地理解和使用 Java 动态数组。

参考资料

• Oracle Java 教程 - ArrayList
• Effective Java, Second Edition