Java中动态管理数组元素：菜单系统实现指南-java教程-PHP中文网

Java中动态管理数组元素：菜单系统实现指南

本文深入探讨了在java中处理固定大小数组的限制，特别是在需要动态更新菜单或列表的场景。我们将介绍三种核心策略来移除或隐藏数组元素：利用动态数组`arraylist`的便捷性、实现自定义的数组元素移除逻辑，以及通过标记或索引列表进行逻辑上的元素隐藏。通过具体的代码示例，帮助读者理解并选择最适合其应用场景的数组管理方法，以提高程序的功能性和可读性。

Java数组的局限性与动态菜单需求

在Java中，原始数组（如String[]或int[]）一旦创建，其大小就固定不变。这意味着你无法直接增加或减少数组的长度。这对于构建动态菜单系统，例如披萨配料选择器，会带来挑战：当用户选择一个配料后，我们希望该配料不再出现在可用选项列表中。直接从固定大小的数组中“移除”一个元素是不可能的。为了解决这一问题，我们需要采用更灵活的数据结构或实现自定义的逻辑。

下面将介绍三种主要的解决方案，以应对Java中数组的这种局限性，并实现动态的菜单管理。

方案一：使用java.util.ArrayList（动态数组）

ArrayList是Java集合框架中最常用的动态数组实现。它提供了自动扩容和缩容的功能，以及方便的添加、获取、修改和删除元素的方法，非常适合需要动态管理元素的场景。

ArrayList的核心特性

动态大小： ArrayList可以根据需要自动调整其内部数组的大小。
丰富的API： 提供了add(), get(), remove(), set(), size()等方法，简化了元素操作。
泛型支持： 可以指定存储的元素类型，提供编译时类型安全。

ArrayList基本操作示例

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // 声明并初始化一个ArrayList
        ArrayList<String> myArray = new ArrayList<>();

        // 添加元素
        myArray.add("hello");
        myArray.add("world");
        System.out.println("添加后: " + myArray); // 输出: [hello, world]

        // 获取元素
        String firstElement = myArray.get(0);
        System.out.println("第一个元素: " + firstElement); // 输出: hello

        // 移除元素 (按索引或按值)
        myArray.remove(0); // 移除索引为0的元素 "hello"
        System.add("Java");
        myArray.remove("world"); // 移除值为 "world" 的元素
        System.out.println("移除后: " + myArray); // 输出: [Java]

        // 修改元素
        myArray.set(0, "foo"); // 将索引0的元素修改为 "foo"
        System.out.println("修改后: " + myArray); // 输出: [foo]
    }
}

登录后复制

应用于披萨配料菜单

在披萨配料选择的场景中，我们可以使用ArrayList来存储可用的配料和对应的菜单选项。当用户选择一个配料后，我们将其从ArrayList中移除。

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

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

public class PizzaMenuWithArrayList {
    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存储可用的配料和对应的菜单选项
        ArrayList<String> availableToppings = new ArrayList<>(Arrays.asList(
            "diced onion", "green pepper", "pepperoni", "sliced mushrooms",
            "jalapenos", "pineapple", "dry red pepper", "basil"
        ));
        ArrayList<String> availableChoices = new ArrayList<>(Arrays.asList(
            "A", "B", "C", "D", "E", "F", "G", "H"
        ));

        // 用于存储已选配料及其数量的列表
        List<String> selectedToppingsRecipe = 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(availableChoices.get(i) + ". " + availableToppings.get(i));
            }

            System.out.println("\nEnter a choice: ");
            String userToppingChoice = sc.nextLine().toUpperCase(); // 转换为大写方便比较

            int chosenIndex = -1;
            for (int i = 0; i < availableChoices.size(); i++) {
                if (availableChoices.get(i).equals(userToppingChoice)) {
                    chosenIndex = i;
                    break;
                }
            }

            if (chosenIndex != -1) {
                String selectedToppingName = availableToppings.get(chosenIndex);
                System.out.println("Please choose one amount for " + selectedToppingName + ":");
                System.out.println("a. 1/8 cup                 b. 1/4 cup");
                String amountChoice = sc.nextLine().toLowerCase();
                String toppingAmount = amountChoice.equals("a") ? "1/8 cup" : "1/4 cup";

                selectedToppingsRecipe.add(selectedToppingName + " (" + toppingAmount + ")");

                // 从可用列表中移除已选配料及其对应的菜单选项
                availableToppings.remove(chosenIndex);
                availableChoices.remove(chosenIndex); // 保持两个列表同步

                System.out.println("Would you like to add more toppings? Type Y for yes or any other key to submit your recipe.");
                userChar = sc.next().charAt(0);
                sc.nextLine(); // 消费掉换行符
            } else {
                System.out.println("You did not enter a valid topping choice.");
            }
        }

        // 打印最终披萨配方
        System.out.println("\nYour pizza recipe is:");
        // 假设 crustType, sauceType, sauceAmount, cheese, cheeseAmount 已定义
        // System.out.println(crustType + "\t1 ");
        // System.out.println(sauceType + "\t" + sauceAmount);
        // System.out.println(cheese + "\t\t" + cheeseAmount);

        if (selectedToppingsRecipe.isEmpty()) {
            System.out.println("No toppings selected.");
        } else {
            for (String toppingEntry : selectedToppingsRecipe) {
                System.out.println(toppingEntry);
            }
        }
        sc.close();
    }
}

登录后复制

注意事项：

使用ArrayList是处理动态集合最推荐的方式，因为它封装了底层数组操作的复杂性。
当从ArrayList中移除元素时，后续元素的索引会自动调整。
如果同时管理配料名称和菜单字母，需要确保两个ArrayList的移除操作同步，以避免数据错位。

方案二：实现自定义数组元素移除功能

如果由于某些原因不能使用ArrayList（例如，在不允许使用集合框架的特定环境中），或者只是想深入理解底层机制，可以手动实现数组元素的移除功能。由于原始数组大小固定，这里的“移除”实际上是创建一个新的、更小的数组，并将旧数组中除了被移除元素之外的所有元素复制过去。

1. 按值移除元素

此方法通过比较元素的值来决定是否将其复制到新数组。

乾坤圈新媒体矩阵管家

新媒体账号、门店矩阵智能管理系统

查看详情

public class CustomArrayRemoval {

    /**
     * 从数组中移除指定值的元素，并返回一个新的数组。
     * 如果有多个相同值的元素，只会移除第一个匹配项。
     *
     * @param array   原始数组
     * @param element 要移除的元素值
     * @return 移除元素后的新数组
     */
    public static String[] removeElementByValue(String[] array, String element) {
        if (array == null || array.length == 0) {
            return new String[0];
        }

        // 查找要移除的元素是否在数组中
        int removeIndex = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i].equals(element)) {
                removeIndex = i;
                break;
            }
        }

        if (removeIndex == -1) { // 元素不存在，返回原数组
            return array;
        }

        return removeElementByIndex(array, removeIndex); // 转换为按索引移除
    }

    // ... （removeElementByIndex 方法将在下一节介绍）
}

登录后复制

2. 按索引移除元素

此方法根据指定的索引位置移除元素。

public class CustomArrayRemoval {
    // ... (removeElementByValue 方法)

    /**
     * 从数组中移除指定索引的元素，并返回一个新的数组。
     *
     * @param array 原始数组
     * @param index 要移除元素的索引
     * @return 移除元素后的新数组
     * @throws IndexOutOfBoundsException 如果索引超出数组范围
     */
    public static String[] removeElementByIndex(String[] array, int index) {
        if (array == null || array.length == 0) {
            throw new IndexOutOfBoundsException("Array is null or empty.");
        }
        if (index < 0 || index >= array.length) {
            throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length " + array.length);
        }

        String[] temp = new String[array.length - 1];
        for (int i = 0, j = 0; i < array.length; i++) {
            if (i != index) {
                temp[j] = array[i];
                j++;
            }
        }
        return temp;
    }

    public static void main(String[] args) {
        String[] arr1 = {"hello", "world", ":)"};
        String[] newArr1 = removeElementByIndex(arr1, 0); // 移除 "hello"
        System.out.println("移除索引0后: " + Arrays.toString(newArr1)); // 输出: [world, :)]

        String[] arr2 = {"apple", "banana", "orange", "apple"};
        String[] newArr2 = removeElementByValue(arr2, "apple"); // 移除第一个 "apple"
        System.out.println("移除值'apple'后: " + Arrays.toString(newArr2)); // 输出: [banana, orange, apple]
    }
}

登录后复制

应用于披萨配料菜单

当用户选择一个配料后，我们可以通过调用这些自定义函数来更新配料列表。

import java.util.Arrays;
import java.util.List; // 仍然使用List来存储已选配料，因为其数量是动态的
import java.util.ArrayList;
import java.util.Scanner;

public class PizzaMenuWithCustomRemoval {

    // 辅助方法：按索引移除元素，返回新数组
    public static String[] removeElementByIndex(String[] array, int index) {
        if (array == null || array.length == 0 || index < 0 || index >= array.length) {
            // 返回一个空数组或抛出异常，取决于需求
            return new String[0];
        }
        String[] temp = new String[array.length - 1];
        for (int i = 0, j = 0; i < array.length; i++) {
            if (i != index) {
                temp[j++] = array[i];
            }
        }
        return temp;
    }

    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("---------------------");

        String[] availableToppings = {
            "diced onion", "green pepper", "pepperoni", "sliced mushrooms",
            "jalapenos", "pineapple", "dry red pepper", "basil"
        };
        String[] availableChoices = {
            "A", "B", "C", "D", "E", "F", "G", "H"
        };

        List<String> selectedToppingsRecipe = new ArrayList<>();

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

            for (int i = 0; i < availableToppings.length; ++i) {
                System.out.println(availableChoices[i] + ". " + availableToppings[i]);
            }

            System.out.println("\nEnter a choice: ");
            String userToppingChoice = sc.nextLine().toUpperCase();

            int chosenIndex = -1;
            for (int i = 0; i < availableChoices.length; i++) {
                if (availableChoices[i].equals(userToppingChoice)) {
                    chosenIndex = i;
                    break;
                }
            }

            if (chosenIndex != -1) {
                String selectedToppingName = availableToppings[chosenIndex];
                System.out.println("Please choose one amount for " + selectedToppingName + ":");
                System.out.println("a. 1/8 cup                 b. 1/4 cup");
                String amountChoice = sc.nextLine().toLowerCase();
                String toppingAmount = amountChoice.equals("a") ? "1/8 cup" : "1/4 cup";

                selectedToppingsRecipe.add(selectedToppingName + " (" + toppingAmount + ")");

                // 更新数组：移除已选配料及其对应的菜单选项
                availableToppings = removeElementByIndex(availableToppings, chosenIndex);
                availableChoices = removeElementByIndex(availableChoices, chosenIndex);

                System.out.println("Would you like to add more toppings? Type Y for yes or any other key to submit your recipe.");
                userChar = sc.next().charAt(0);
                sc.nextLine(); // 消费掉换行符
            } else {
                System.out.println("You did not enter a valid topping choice.");
            }
        }

        System.out.println("\nYour pizza recipe is:");
        if (selectedToppingsRecipe.isEmpty()) {
            System.out.println("No toppings selected.");
        } else {
            for (String toppingEntry : selectedToppingsRecipe) {
                System.out.println(toppingEntry);
            }
        }
        sc.close();
    }
}

登录后复制

注意事项：

每次调用removeElementByIndex都会创建一个新的数组，并将数据复制过去。对于频繁的移除操作，这可能会导致性能开销，尤其是在大型数组中。
需要手动管理数组的引用，将新数组赋值回原变量。
此方法更适用于对性能要求不极致，或数组元素数量不多的场景。

方案三：逻辑隐藏元素（不实际移除）

这种方法不实际改变数组的大小或创建新数组，而是通过标记或记录要隐藏的元素，在遍历和显示时跳过这些元素。

1. 使用null标记元素

最简单的方法是将已选元素的位置设置为null。在打印菜单时，跳过所有null的元素。

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

        // 隐藏 "banana"
        myArray[1] = null;

        System.out.println("显示非null元素:");
        for (int i = 0; i < myArray.length; i++) {
            if (myArray[i] != null) {
                System.out.println(myArray[i]);
            }
        }
        // 输出:
        // apple
        // orange
    }
}

登录后复制

2. 使用单独的索引列表追踪隐藏元素

此方法维护一个独立的列表（通常是List<Integer>）来存储所有被“隐藏”元素的索引。在遍历原始数组时，检查当前元素的索引是否在隐藏列表中。

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

public class PizzaMenuWithHiddenElements {
    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("---------------------");

        String[] allToppings = {
            "diced onion", "green pepper", "pepperoni", "sliced mushrooms",
            "jalapenos", "pineapple", "dry red pepper", "basil"
        };
        String[] allChoices = {
            "A", "B", "C", "D", "E", "F", "G", "H"
        };

        List<Integer> hiddenIndices = new ArrayList<>(); // 存储已选配料的原始索引
        List<String> selectedToppingsRecipe = new ArrayList<>();

        char userChar = 'y';
        while (userChar == 'y' && hiddenIndices.size() < allToppings.length) {
            System.out.println("\nChoose your favorite toppings:");

            // 打印当前可用的配料菜单，跳过隐藏的元素
            for (int i = 0; i < allToppings.length; ++i) {
                if (!hiddenIndices.contains(i)) { // 如果索引不在隐藏列表中，则打印
                    // 注意：这里需要动态生成A, B, C... 或使用原始的allChoices[i]
                    // 为了简化，我们直接使用原始的allChoices[i]
                    System.out.println(allChoices[i] + ". " + allToppings[i]);
                }
            }

            System.out.println("\nEnter a

登录后复制

以上就是Java中动态管理数组元素：菜单系统实现指南的详细内容，更多请关注php中文网其它相关文章！