本文深入探讨了在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
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 
