智能车辆调度：基于条件迭代的停车系统实现-java教程-PHP中文网

智能车辆调度：基于条件迭代的停车系统实现

本文探讨如何通过迭代处理机制，将车辆列表中的车辆根据特定条件（如车位匹配、车型兼容性、车位容量限制）高效地分配到可用的停车位中。我们将分析一种常见的迭代停车策略，并提供示例代码，旨在解决在列表操作中动态移除元素并重复尝试直至所有车辆完成停放的问题。

1. 问题背景与挑战

在车辆管理系统中，常见需求是将待停放车辆（存储在一个列表中）分配到一系列停车位（存储在另一个列表中）中。这个分配过程通常涉及多个条件判断，例如车辆类型与车位兼容性、车位是否已满以及车辆与车位的空间匹配等。一个核心挑战在于，并非所有车辆都能在第一次尝试时就找到合适的车位。此外，当一辆车成功停放后，它应该从待停放列表中移除，而停车位的状态也需要更新。如果简单地使用嵌套循环进行一次性处理，可能会遗漏那些在初次循环中因条件不满足而未能停放的车辆。

原始的实现尝试通过复杂的嵌套循环和索引管理（如 i-- 和 j++）来处理这些情况，并在外部使用 while 循环确保列表清空。然而，这种方法往往导致代码难以理解和维护，并且在列表动态修改时容易引入索引错乱或跳过元素的错误。特别是在一个循环中移除元素并同时调整索引的逻辑，极易出错。

2. 迭代式停车策略

为了解决上述挑战，一种更健壮和易于理解的策略是采用迭代式处理。其核心思想是：在一个外部循环中，只要还有待停放的车辆，就反复尝试将它们停放到合适的车位。内部循环则负责遍历当前所有待停放的车辆，并尝试为每辆车找到一个匹配的车位。

2.1 核心逻辑解析

外部 while 循环：while (vehicles.size() > 0)：这个循环是整个策略的关键。它确保只要 vehicles 列表中还有车辆，停车过程就会持续进行。这意味着即使在某一次内部循环中未能停放所有车辆，外部循环也会触发下一次尝试，从而为那些之前未找到车位的车辆提供新的机会。
内部 for 循环（遍历车辆）：for (int i = 0; i < vehicles.size(); i++)：这个循环遍历当前 vehicles 列表中的每一辆车。
- 动态列表修改与索引： 值得注意的是，当 vehicles.remove(i) 被调用时，列表的大小会减小，并且 i 之后的元素会向前移动一个位置。如果 i 随后正常递增，那么紧接着被移除元素之后的那个元素将被跳过。
- 缓解策略： 在本场景中，这种跳过行为并非致命缺陷，因为外部 while 循环的存在。任何被跳过的车辆都会在 while 循环的下一次迭代中，当内部 for 循环重新从 i=0 开始时，再次被考虑。虽然这不是最高效的单次遍历方式（例如，使用迭代器或逆向遍历可以避免跳过），但对于“反复尝试直到所有可停放车辆都停好”的需求，它简单有效。
内嵌 for 循环（遍历车位）：for (int j = 0; j < garage.size(); j++)：对于每一辆待停放的车辆 v，这个循环遍历所有可用的停车位 garage，寻找合适的停放位置。

阿贝智能
阿贝智能是基于AI技术辅助创作儿童绘本、睡前故事和有声书的平台，助你创意实现、梦想成真。

17

查看详情
条件判断：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<Vehicle> 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<Vehicle> getCarry() { // 假设此方法用于获取已停放车辆
//         return parkedVehicles;
//     }
//     public void setCurrentSpace(String newSpace) { /* 模拟设置新空间 */ }
//     public boolean removeVehicles(Vehicle v) { /* 模拟移除车辆 */ return true; }
// }

public class VehicleParkingSystem {

    private List<Vehicle> vehicles; // 待停放车辆列表
    private List<Garage> garage;   // 停车位列表

    public VehicleParkingSystem(List<Vehicle> vehicles, List<Garage> 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<Vehicle> 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<Vehicle> getCarry() { return parkedVehicles; }
        public void setCurrentSpace(String newSpace) { /* 模拟设置新空间 */ }
        public boolean removeVehicles(Vehicle v) { return parkedVehicles.remove(v); }
    }

    public static void main(String[] args) {
        List<Vehicle> 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<Garage> 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 进行更安全的列表移除操作，或引入更复杂的调度算法。

以上就是智能车辆调度：基于条件迭代的停车系统实现的详细内容，更多请关注php中文网其它相关文章！