精准匹配与移除：高效清空列表的车辆停放策略

import java.util.ArrayList;
import java.util.List;

// 假设 Vehicle 和 Garage 类已经定义，并包含相应的方法
class Vehicle {
    private int space;
    private String vehicleType;
    private String destinationSpace; // 假设有目的地空间属性

    public Vehicle(int space, String vehicleType, String destinationSpace) {
        this.space = space;
        this.vehicleType = vehicleType;
        this.destinationSpace = destinationSpace;
    }

    public int getSpace() {
        return space;
    }

    public String getvehiclesType() {
        return vehicleType;
    }

    public String getDestinationSpace() {
        return destinationSpace;
    }

    @Override
    public String toString() {
        return "Vehicle [type=" + vehicleType + ", space=" + space + "]";
    }
}

class Garage {
    private int space;
    private String garageType; // 假设车库有类型限制
    private int limit; // 车库容量
    private List<Vehicle> parkedVehicles; // 停放的车辆

    public Garage(int space, String garageType, int limit) {
        this.space = space;
        this.garageType = garageType;
        this.limit = limit;
        this.parkedVehicles = new ArrayList<>();
    }

    public int getSpace() {
        return space;
    }

    public boolean garageRequest(String vehicleType) {
        // 假设车库类型与车辆类型匹配
        return this.garageType.equals(vehicleType);
    }

    public int getLimit() {
        return limit - parkedVehicles.size(); // 返回剩余容量
    }

    public void addvehicles(Vehicle v) {
        if (getLimit() > 0) {
            parkedVehicles.add(v);
            System.out.println("Parked " + v + " in Garage [space=" + space + ", type=" + garageType + "]");
        }
    }

    public List<Vehicle> getCarry() {
        return parkedVehicles;
    }

    // 假设有方法来设置当前空间或移除车辆，但在此解决方案中未直接使用
    public void setCurrentSpace(String newSpace) {
        // 示例方法，实际逻辑根据需求实现
        System.out.println("Garage " + space + " changed current space to " + newSpace);
    }

    public boolean removeVehicles(Vehicle v) {
        boolean removed = parkedVehicles.remove(v);
        if (removed) {
            System.out.println("Removed " + v + " from Garage [space=" + space + ", type=" + garageType + "]");
        }
        return removed;
    }

    @Override
    public String toString() {
        return "Garage [space=" + space + ", type=" + garageType + ", available=" + getLimit() + "]";
    }
}


public class VehicleParkingManager {

    private List<Vehicle> vehicles;
    private List<Garage> garage;

    public VehicleParkingManager(List<Vehicle> vehicles, List<Garage> garage) {
        this.vehicles = vehicles;
        this.garage = garage;
    }

    public void parkAllVehicles() {
        System.out.println("--- Starting Parking Process ---");
        System.out.println("Initial Vehicles: " + vehicles.size());
        System.out.println("Available Garages: " + garage.size());

        while (vehicles.size() > 0) { // 外层循环：只要还有车辆未停放，就继续尝试
            boolean parkedInThisIteration = false; // 标记本轮是否有车辆被停放

            for (int i = 0; i < vehicles.size(); i++) { // 内层循环：遍历当前待停放车辆列表
                Vehicle v = vehicles.get(i); // 获取当前车辆
                boolean vehicleParked = false; // 标记当前车辆是否已停放

                for (int j = 0; j < garage.size(); j++) { // 最内层循环：遍历所有车库
                    Garage g = garage.get(j); // 获取当前车库

                    // 检查停放条件：车库空间匹配、车辆类型匹配、车库有容量
                    if (g.getSpace() == v.getSpace() && g.garageRequest(v.getvehiclesType()) && g.getLimit() > 0) {
                        g.addvehicles(v); // 将车辆停放到车库
                        vehicles.remove(i); // 从待停放列表中移除已停放的车辆
                        i--; // 关键：移除元素后，当前索引i指向了下一个元素，为了不跳过，需要将i减1
                        parkedInThisIteration = true;
                        vehicleParked = true;
                        break; // 跳出车库循环，因为当前车辆已停放
                    }
                }
                // 如果当前车辆在本轮循环中没有找到车库停放，则继续检查下一辆车
                // 如果车辆已被停放，且i被调整，for循环的i++会抵消调整，继续正确迭代
            }

            if (!parkedInThisIteration && vehicles.size() > 0) {
                System.out.println("No more vehicles could be parked in this iteration. Remaining vehicles: " + vehicles.size());
                // 如果一整轮for循环都没有车辆被停放，且列表仍不为空，说明无法再停放，跳出while循环
                break; 
            }
        }
        System.out.println("--- Parking Process Finished ---");
        System.out.println("Remaining Vehicles: " + vehicles.size());
    }

    public static void main(String[] args) {
        List<Vehicle> vehicles = new ArrayList<>();
        vehicles.add(new Vehicle(1, "Car", "A1"));
        vehicles.add(new Vehicle(2, "Truck", "B2"));
        vehicles.add(new Vehicle(1, "Car", "A3"));
        vehicles.add(new Vehicle(3, "Motorcycle", "C1"));
        vehicles.add(new Vehicle(2, "Car", "B4")); // 无法停放，因为车库2只接受Truck
        vehicles.add(new Vehicle(1, "Car", "A5")); // 无法停放，因为车库1容量已满

        List<Garage> garages = new ArrayList<>();
        garages.add(new Garage(1, "Car", 1)); // 只能停一辆Car
        garages.add(new Garage(2, "Truck", 2)); // 只能停两辆Truck
        garages.add(new Garage(3, "Motorcycle", 1)); // 只能停一辆Motorcycle

        VehicleParkingManager manager = new VehicleParkingManager(vehicles, garages);
        manager.parkAllVehicles();

        System.out.println("\n--- Final State ---");
        System.out.println("Vehicles left in list: " + manager.vehicles);
        for (Garage g : garages) {
            System.out.println(g + " Parked vehicles: " + g.getCarry());
        }
    }
}