Java中动态管理数组元素：从固定数组到ArrayList的实践指南

碧海醫心

发布时间：2025-10-17 08:29:13

883人浏览过

来源于php中文网

原创

Java中动态管理数组元素：从固定数组到ArrayList的实践指南

本文深入探讨了在java中处理动态数组元素（如菜单项）的策略。针对固定大小数组的局限性，文章详细介绍了使用`java.util.arraylist`进行动态增删改查的方法，并提供了手动实现数组元素移除以及逻辑隐藏元素的替代方案。通过披萨点餐程序的示例，演示了如何优化代码以实现更灵活、可读性更强的菜单管理。

在Java编程中，我们经常需要处理集合数据。对于初学者而言，数组（Array）是接触到的第一种数据结构。然而，Java中的原生数组是固定大小的，一旦创建，其长度便无法改变。这在需要动态增删元素的场景中（例如，一个披萨点餐程序中，用户选择配料后，该配料应从可用菜单中移除）会带来挑战。本文将详细探讨解决这一问题的多种策略，并着重介绍如何利用java.util.ArrayList这一动态数据结构来优雅地管理元素。

1. Java原生数组的局限性

原生数组在Java中是静态的，这意味着它们的长度在声明时就已经确定。例如：

String[] toppings = {"diced onion", "green pepper", "pepperoni"};

这个数组只能容纳3个元素。如果我们需要移除一个元素，或者添加一个新的元素，原生数组本身无法直接支持这种操作。尝试直接移除一个元素会导致数组中出现空洞，或者需要手动创建新数组并复制元素，这无疑增加了代码的复杂性和维护成本。

2. 核心解决方案：拥抱java.util.ArrayList

ArrayList是Java集合框架中最常用的动态数组实现。它克服了原生数组固定大小的限制，允许在运行时动态地添加、删除和修改元素。ArrayList在内部使用一个原生数组来存储元素，但当元素数量超出当前容量时，它会自动创建一个更大的新数组并将旧数组的元素复制过去。

立即学习“Java免费学习笔记（深入）”；

2.1 ArrayList的基本操作

使用ArrayList非常简单，以下是一些常用操作：

创建ArrayList：

import java.util.ArrayList;
import java.util.List; // 通常使用List接口声明

List myDynamicArray = new ArrayList<>(); // 创建一个存储String类型的ArrayList

或者从现有数组初始化：

import java.util.Arrays;
List toppings = new ArrayList<>(Arrays.asList("diced onion", "green pepper", "pepperoni"));

添加元素： add(E element)

myDynamicArray.add("element1");
myDynamicArray.add("element2");

获取元素： get(int index)

String firstElement = myDynamicArray.get(0); // 获取第一个元素

移除元素：
- remove(int index)：根据索引移除元素。
- remove(Object o)：根据对象内容移除第一个匹配的元素。
```
myDynamicArray.remove(0); // 移除第一个元素
myDynamicArray.remove("element2"); // 移除值为"element2"的元素
```
修改元素： set(int index, E element)

ImgCreator AI
一款AI图像生成工具，适合创建插图、动画和概念设计图像。

下载
```
myDynamicArray.set(0, "newElement"); // 将第一个元素修改为"newElement"
```

获取大小： size()

int size = myDynamicArray.size(); // 获取当前ArrayList中的元素数量

2.2 实战示例：优化披萨配料选择程序

让我们将原有的披萨点餐程序改造为使用ArrayList，以实现已选配料自动从菜单中移除的功能。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class PizzaOrderOptimized {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("---------------------");
        System.out.println("Create Your Own Pizza");
        System.out.println("---------------------");

        // 使用 ArrayList 存储可用配料，实现动态增删
        List availableToppings = new ArrayList<>(Arrays.asList(
                "diced onion", "green pepper", "pepperoni", "sliced mushrooms",
                "jalapenos", "pineapple", "dry red pepper", "basil"
        ));

        // 用于存储用户已选择的配料及其数量
        List selectedToppings = new ArrayList<>();
        List selectedAmounts = new ArrayList<>();

        char userChar = 'y';
        while (userChar == 'y' && !availableToppings.isEmpty()) {
            System.out.println("\nChoose your favorite toppings:");

            // 动态生成菜单，只显示未选择的配料
            for (int i = 0; i < availableToppings.size(); ++i) {
                System.out.println((char) ('A' + i) + ". " + availableToppings.get(i));
            }
            System.out.println("---------------------");

            System.out.print("Enter a choice: ");
            // 注意：为避免Scanner的nextLine()和next()混合使用问题，统一使用nextLine()
            String userChoiceStr = sc.nextLine().trim().toUpperCase();

            if (userChoiceStr.length() == 1) {
                int toppingIndex = userChoiceStr.charAt(0) - 'A';

                if (toppingIndex >= 0 && toppingIndex < availableToppings.size()) {
                    String chosenTopping = availableToppings.get(toppingIndex);
                    System.out.println("You chose: " + chosenTopping);

                    System.out.println("Please choose one amount: ");
                    System.out.println("a. 1/8 cup                 b. 1/4 cup");
                    System.out.print("Enter amount choice: ");
                    String amountChoice = sc.nextLine().trim().toLowerCase();

                    String amount = "";
                    if (amountChoice.equals("a")) {
                        amount = "1/8 cup";
                    } else if (amountChoice.equals("b")) {
                        amount = "1/4 cup";
                    } else {
                        System.out.println("Invalid amount choice. Defaulting to 1/8 cup.");
                        amount = "1/8 cup";
                    }

                    selectedToppings.add(chosenTopping);
                    selectedAmounts.add(amount);

                    // 关键步骤：从可用配料列表中移除已选择的配料
                    availableToppings.remove(toppingIndex);

                    System.out.println("Would you like to add more toppings? Type Y for yes or any other key to submit your recipe.");
                    String continueChoice = sc.nextLine().trim().toLowerCase();
                    userChar = continueChoice.isEmpty() ? 'n' : continueChoice.charAt(0);
                } else {
                    System.out.println("You did not enter a valid topping choice (out of range).");
                }
            } else {
                System.out.println("You did not enter a valid topping choice (invalid format).");
            }
        }

        // 打印最终配方
        System.out.println("\n---------------------");
        System.out.println("Your pizza recipe is:");
        if (selectedToppings.isEmpty()) {
            System.out.println("No toppings selected.");
        } else {
            for (int i = 0; i < selectedToppings.size(); i++) {
                System.out.println(selectedToppings.get(i) + "\t\t" + selectedAmounts.get(i));
            }
        }
        System.out.println("---------------------");

        sc.close();
    }
}

在这个优化后的版本中，availableToppings是一个ArrayList。每次用户选择一个配料并指定数量后，我们使用availableToppings.remove(toppingIndex)将其从列表中移除。这样，在下一次循环打印菜单时，该配料将不再显示，实现了动态更新菜单的需求。

3. 替代方案：手动实现数组元素移除

尽管ArrayList是首选，但在某些特定场景或为理解底层机制，也可以选择手动实现数组元素的移除功能。这通常涉及创建一个新数组，并将旧数组中除了要移除的元素之外的所有元素复制过去。

3.1 按值移除元素

此方法会移除数组中与指定元素值相等的所有项。

import java.util.Arrays;

public class ArrayManipulation {
    public static String[] removeElementByValue(String[] array, String elementToRemove) {
        // 计算新数组的长度
        int count = 0;
        for (String s : array) {
            if (!s.equals(elementToRemove)) {
                count++;
            }
        }

        String[] newArray = new String[count];
        int newArrayIndex = 0;
        for (String s : array) {
            if (!s.equals(elementToRemove)) {
                newArray[newArrayIndex++] = s;
            }
        }
        return newArray;
    }

    public static void main(String[] args) {
        String[] arr = {"hello", "world", ":)", "world"};
        String[] temp = removeElementByValue(arr, "world");
        System.out.println(Arrays.toString(temp)); // 输出: [hello, :)]
    }
}

3.2 按索引移除元素

此方法根据指定的索引移除数组中的一个元素。

import java.util.Arrays;

public class ArrayManipulation {
    public static String[] removeElementByIndex(String[] array, int indexToRemove) {
        if (indexToRemove < 0 || indexToRemove >= array.length) {
            System.out.println("Invalid index for removal.");
            return array; // 返回原数组或抛出异常
        }

        String[] newArray = new String[array.length - 1];
        for (int i = 0, j = 0; i < array.length; i++) {
            if (i == indexToRemove) {
                continue; // 跳过要移除的元素
            }
            newArray[j++] = array[i];
        }
        return newArray;
    }

    public static void main(String[] args) {
        String[] arr = {"hello", "world", ":)"};
        String[] temp = removeElementByIndex(arr, 0);
        System.out.println(Arrays.toString(temp)); // 输出: [world, :)]
    }
}

优缺点： 手动实现数组移除虽然能达到目的，但代码量大，且每次操作都需要创建新数组并复制元素，对于频繁的增删操作，性能开销较大。

4. 替代方案：逻辑隐藏元素

在某些情况下，我们可能不想真正从内存中移除元素，而只是想在用户界面上“隐藏”它们。这种方法被称为逻辑移除。

4.1 通过null标记隐藏

最简单的方法是将要隐藏的元素位置设置为null，然后在遍历时跳过null元素。

public class HideElements {
    public static void main(String[] args) {
        String[] myArray = {"apple", "banana", "cherry"};

        // 隐藏 "banana" (假设其索引为1)
        myArray[1] = null;

        System.out.println("Printing array with null elements hidden:");
        for (int i = 0; i < myArray.length; i++) {
            if (myArray[i] != null) {
                System.out.println(myArray[i]);
            }
        }
        // 输出:
        // apple
        // cherry
    }
}

优缺点： 简单易行，但被标记为null的元素仍然占用数组空间，并且一旦设置为null，就无法轻易恢复其原始值（除非提前备份）。