1. 问题背景与挑战
在车辆管理系统中，常见需求是将待停放车辆（存储在一个列表中）分配到一系列停车位（存储在另一个列表中）中。这个分配过程通常涉及多个条件判断，例如车辆类型与车位兼容性、车位是否已满以及车辆与车位的空间匹配等。一个核心挑战在于，并非所有车辆都能在第一次尝试时就找到合适的车位。此外，当一辆车成功停放后，它应该从待停放列表中移除，而停车位的状态也需要更新。如果简单地使用嵌套循环进行一次性处理，可能会遗漏那些在初次循环中因条件不满足而未能停放的车辆。
原始的实现尝试通过复杂的嵌套循环和索引管理（如 i-- 和 j++）来处理这些情况，并在外部使用 while 循环确保列表清空。然而，这种方法往往导致代码难以理解和维护，并且在列表动态修改时容易引入索引错乱或跳过元素的错误。特别是在一个循环中移除元素并同时调整索引的逻辑，极易出错。
2. 迭代式停车策略
为了解决上述挑战，一种更健壮和易于理解的策略是采用迭代式处理。其核心思想是：在一个外部循环中，只要还有待停放的车辆，就反复尝试将它们停放到合适的车位。内部循环则负责遍历当前所有待停放的车辆，并尝试为每辆车找到一个匹配的车位。
2.1 核心逻辑解析
外部 while 循环：while (vehicles.size() > 0)：这个循环是整个策略的关键。它确保只要 vehicles 列表中还有车辆，停车过程就会持续进行。这意味着即使在某一次内部循环中未能停放所有车辆，外部循环也会触发下一次尝试，从而为那些之前未找到车位的车辆提供新的机会。
-
内部 for 循环（遍历车辆）：for (int i = 0; i
- 动态列表修改与索引： 值得注意的是，当 vehicles.remove(i) 被调用时，列表的大小会减小，并且 i 之后的元素会向前移动一个位置。如果 i 随后正常递增，那么紧接着被移除元素之后的那个元素将被跳过。
- 缓解策略： 在本场景中，这种跳过行为并非致命缺陷，因为外部 while 循环的存在。任何被跳过的车辆都会在 while 循环的下一次迭代中，当内部 for 循环重新从 i=0 开始时，再次被考虑。虽然这不是最高效的单次遍历方式（例如，使用迭代器或逆向遍历可以避免跳过），但对于“反复尝试直到所有可停放车辆都停好”的需求，它简单有效。
内嵌 for 循环（遍历车位）：for (int j = 0; j
-
条件判断：if (g.getSpace() == v.getSpace() && g.garageRequest(v.getvehiclesType()) && g.getLimit() > 0)：这是停车的核心业务逻辑，它检查以下三个条件是否同时满足：
- g.getSpace() == v.getSpace()：车辆所需的空间与停车位提供的空间是否匹配。
- g.garageRequest(v.getvehiclesType())：停车位是否接受该车辆类型。
- g.getLimit() > 0：停车位是否还有剩余容量。
-
成功停放操作：g.addvehicles(v); vehicles.remove(i); break;：
- 如果所有条件都满足，车辆 v 被添加到停车位 g 中。
- 车辆 v 从 vehicles 列表中移除，表示它已被成功停放。
- break; 语句至关重要，它会立即跳出当前的内嵌 for (j) 循环。这意味着一旦为一辆车找到了合适的车位，就不需要再检查其他车位，可以直接转向处理 vehicles 列表中的下一辆车。
3. 示例代码
以下是实现上述迭代式停车策略的示例代码：
import java.util.ArrayList;
import java.util.List;
// 假设 Vehicle 和 Garage 类已经定义，并包含以下方法：
// class Vehicle {
// private String vehicleType;
// private String space; // 车辆所需空间类型
// // ... 构造函数, getters
// public String getvehiclesType() { return vehicleType; }
// public String getSpace() { return space; }
// }
// class Garage {
// private String space; // 车位提供的空间类型
// private int limit; // 车位剩余容量
// private List parkedVehicles; // 已停放车辆列表
// // ... 构造函数, getters
// public Garage(String space, int limit) {
// this.space = space;
// this.limit = limit;
// this.parkedVehicles = new ArrayList<>();
// }
// public String getSpace() { return space; }
// public boolean garageRequest(String vehicleType) {
// // 示例：假设某些车位只接受特定类型的车辆
// return true; // 简化处理，实际中会有更复杂的逻辑
// }
// public int getLimit() { return limit; }
// public void addvehicles(Vehicle v) {
// if (limit > 0) {
// parkedVehicles.add(v);
// limit--;
// System.out.println("停放成功: " + v.getvehiclesType() + " 在 " + this.getSpace() + " 车位. 剩余容量: " + limit);
// }
// }
// public List getCarry() { // 假设此方法用于获取已停放车辆
// return parkedVehicles;
// }
// public void setCurrentSpace(String newSpace) { /* 模拟设置新空间 */ }
// public boolean removeVehicles(Vehicle v) { /* 模拟移除车辆 */ return true; }
// }
public class VehicleParkingSystem {
private List vehicles; // 待停放车辆列表
private List garage; // 停车位列表
public VehicleParkingSystem(List vehicles, List garage) {
this.vehicles = vehicles;
this.garage = garage;
}
public void parkAllVehicles() {
System.out.println("开始停车过程...");
int initialVehicleCount = vehicles.size();
int passCount = 0;
// 外部 while 循环：只要还有车辆未停放，就持续尝试
while (vehicles.size() > 0) {
passCount++;
System.out.println("\n--- 第 " + passCount + " 轮尝试停车 ---");
int vehiclesParkedThisPass = 0;
// 使用一个临时列表来收集本轮无法停放的车辆，或者使用迭代器安全移除
// 为了保持与原答案逻辑一致，我们直接在原列表上操作，并依赖外层while循环
// 更好的做法是使用 Iterator 或逆向遍历来避免跳过元素
// 但此处的逻辑是：如果跳过了，下一轮while循环会再次处理
// 内部 for 循环：遍历当前所有待停放的车辆
for (int i = 0; i < vehicles.size(); i++) {
Vehicle v = vehicles.get(i); // 获取当前车辆
boolean parkedInThisAttempt = false;
// 内嵌 for 循环：遍历所有停车位
for (int j = 0; j < garage.size(); j++) {
Garage g = garage.get(j); // 获取当前停车位
// 条件判断：车位空间匹配、车辆类型兼容、车位有空余
if (g.getSpace().equals(v.getSpace()) &&
g.garageRequest(v.getvehiclesType()) &&
g.getLimit() > 0) {
// 停放成功
g.addvehicles(v);
vehicles.remove(i); // 从待停放列表中移除车辆
i--; // 关键：移除元素后，需要将索引 i 减一，以补偿列表元素前移，确保不跳过下一个元素
vehiclesParkedThisPass++;
parkedInThisAttempt = true;
break; // 找到车位后，跳出内嵌的 garage 循环，处理下一辆车
}
}
// 如果本轮尝试中没有找到车位，v 会保留在列表中，等待下一轮 while 循环处理
if (!parkedInThisAttempt) {
System.out.println("未能停放: " + v.getvehiclesType() + " " + v.getSpace() + " (本轮未找到合适车位)");
}
}
// 如果一轮下来没有任何车辆被停放，说明剩余车辆都无法找到车位，避免无限循环
if (vehiclesParkedThisPass == 0 && vehicles.size() > 0) {
System.out.println("\n--- 警告：本轮未停放任何车辆，且仍有车辆剩余。可能存在无法停放的车辆。---");
break; // 跳出 while 循环，避免无限循环
}
}
System.out.println("\n停车过程结束。");
System.out.println("初始车辆数: " + initialVehicleCount);
System.out.println("剩余未停放车辆数: " + vehicles.size());
if (vehicles.size() > 0) {
System.out.println("未停放车辆:");
for (Vehicle v : vehicles) {
System.out.println(" - " + v.getvehiclesType() + " " + v.getSpace());
}
}
}
// 辅助类定义 (为了让代码可运行)
static class Vehicle {
private String vehicleType;
private String space;
public Vehicle(String type, String space) {
this.vehicleType = type;
this.space = space;
}
public String getvehiclesType() { return vehicleType; }
public String getSpace() { return space; }
@Override
public String toString() { return vehicleType + " (" + space + ")"; }
}
static class Garage {
private String space;
private int limit;
private List parkedVehicles;
public Garage(String space, int limit) {
this.space = space;
this.limit = limit;
this.parkedVehicles = new ArrayList<>();
}
public String getSpace() { return space; }
public boolean garageRequest(String vehicleType) {
// 示例：假设小型车位只接受轿车，大型车位接受卡车和轿车
if (this.space.equals("小型车位")) {
return vehicleType.equals("轿车");
} else if (this.space.equals("大型车位")) {
return vehicleType.equals("轿车") || vehicleType.equals("卡车");
}
return false; // 默认不接受
}
public int getLimit() { return limit; }
public void addvehicles(Vehicle v) {
if (limit > 0) {
parkedVehicles.add(v);
limit--;
}
}
// 以下方法是为了兼容原始问题中的 Garage 接口，实际在此场景中可能不直接使用
public List getCarry() { return parkedVehicles; }
public void setCurrentSpace(String newSpace) { /* 模拟设置新空间 */ }
public boolean removeVehicles(Vehicle v) { return parkedVehicles.remove(v); }
}
public static void main(String[] args) {
List vehiclesToPark = new ArrayList<>();
vehiclesToPark.add(new Vehicle("轿车", "小型车位"));
vehiclesToPark.add(new Vehicle("卡车", "大型车位"));
vehiclesToPark.add(new Vehicle("轿车", "小型车位"));
vehiclesToPark.add(new Vehicle("卡车", "小型车位")); // 无法停放
vehiclesToPark.add(new Vehicle("轿车", "大型车位"));
vehiclesToPark.add(new Vehicle("轿车", "小型车位")); // 可能会被跳过，但在下一轮处理
List availableGarages = new ArrayList<>();
availableGarages.add(new Garage("小型车位", 1));
availableGarages.add(new Garage("大型车位", 1));
availableGarages.add(new Garage("小型车位", 1));
availableGarages.add(new Garage("小型车位", 0)); // 已满
VehicleParkingSystem system = new VehicleParkingSystem(vehiclesToPark, availableGarages);
system.parkAllVehicles();
}
} 注意事项：
- i-- 的重要性： 在 vehicles.remove(i) 之后立即执行 i-- 是为了抵消列表元素前移的影响。当一个元素被移除时，它后面的所有元素都会向前移动一个位置。如果 i 不减一，在下一次循环迭代中 i 正常递增后，就会跳过原本位于 i+1 的元素。通过 i--，我们确保在 i 递增之前，它指向的仍然是当前位置（即原 i+1 元素现在的新位置），从而避免跳过。
- 无限循环检测： 在 while 循环内部，如果一轮尝试下来没有任何车辆被停放 (vehiclesParkedThisPass == 0)，但 vehicles 列表仍不为空，这通常意味着剩余的车辆都无法找到合适的车位。此时应跳出 while 循环，避免程序陷入无限等待。
4. 总结
通过采用外部 while 循环结合内部 for 循环的迭代式停车策略，我们能够有效地处理动态列表修改和条件性分配问题。这种方法虽然在内部 for 循环中通过 i-- 来处理元素移除时的索引变化，但其核心优势在于 while 循环的重试机制，确保所有可停放的车辆最终都能被处理。这种结构清晰、逻辑严谨的解决方案，为复杂的资源分配场景提供了可靠的实现范例。在实际应用中，可以根据具体需求进一步优化性能，例如使用 Iterator 进行更安全的列表移除操作，或引入更复杂的调度算法。
