Java 按属性搜索ArrayList中的特定对象

你好

假设我有以下代码： （这些显然不是所有属性）

对象将添加到ArrayList：

ArrayList<Car> cars = new ArrayList<>();

现在的问题是：

我如何制定一个方法，以便只列出所有值为isClean“true”的汽车

如何创建具有以下签名的方法： public static void PrintCars Specific（ArrayList Cars，字符串fuelType） 例如，如果我输入： 印刷品专用（“汽油”）； 打印ArrayList时只显示这些汽车

附言：这不是家庭作业。只是为了教育 我自己输入了上面的代码，没有复制粘贴，因为它会变得太大

我尝试了以下方法：

public static void printBedrijfsautosMetType(ArrayList<Auto> autos, String brandstof) {
    Iterator<Auto> iter = autos.iterator();
    while (iter.hasNext()) {
        Auto auto = iter.next();

        if (auto instanceof BrandstofAuto) {
            String brandstof1 = ((BrandstofAuto) auto).getBrandstof();
            if (!brandstof1.equals(brandstof) || brandstof1 == null) {
                iter.remove();
            }
        }
        for (int i = 0; i < autos.size(); i++) {
            System.out.println(autos.get(i));
        }

    }
}

public static void printbedrijfsautomettype（ArrayList autos，String brandstof）{
迭代器iter=autos.Iterator（）；
while（iter.hasNext（））{
自动=iter.next（）；
if（BrandstofAuto的自动实例）{
字符串brandstof1=（（BrandstofAuto）auto.getBrandstof（）；
如果（！brandstof1.equals（brandstof）| | brandstof1==null）{
iter.remove（）；
}
}
对于（int i=0；i

及

publicstaticvoidprintschoneaeutos（arraylistautos）{
迭代器iter=autos.Iterator（）；
while（iter.hasNext（））{
自动=iter.next（）；
if（BrandstofAuto的自动实例）{
布尔值isschoon=（（BrandstofAuto）auto）.isschoon（）；
布尔值isschoon3=auto.isSchoon（）；
如果（isschoon3==false | | isschoon==false）{
iter.remove（）；
}
}
对于（int i=0；i

---

我想我不必像下面的例子那样删除这些项目。

这似乎是一个家庭作业，但我会咬一口

最简单的方法是遍历原始列表并从中选择匹配的项

ArrayList<Car> cleanCars = new ArrayList<Car>();
for (Car car : scars) {
    if (car.isClean()) {
        cleanCars.add(car);
    }
}

---

车辆硬编码过滤列表：

public static List<Car> filterCleanFuelCars(List<Car> cars) {
    List<Car> filtered = new LinkedList<>();
    for (Car c : cars) {
        if (c instanceof FuelCar) {
            FuelCar fuelCar = (FuelCar) c;
            if (fuelCar.isClean()) {
                filtered.add(fuelCar);
            }
        }
    }
    return filtered;
}  

用法示例：

List<Car> cleanCars = filterCars(cars, new Predicate<Car>() {
    @Override
    public boolean apply(Car c) {
        return c.isClean();
    }
});

您还可以使用

filterCars

方法将

printcarssspecific

重写为更通用的方法：

public static void printCarsSpecific(List<Car> cars, Predicate<Car> p) {
    List<Car> filtered = filterCars(cars, p);
    for (Car c : filtered) {
        System.out.println(c);
    }
}

---

如果您使用的是java 8，则可以使用奇特的流，例如：

List<Car> cleanCars = carList.stream().filter(car -> car.isClean()).collect(Collectors.toList());

List<Car> carsFilteredOnFuelType = carList.stream().filter(car -> fueltype.equals(car.fueltype)).collect(Collectors.toList));

List cleanCars=carList.stream（）.filter（car->car.isClean（））.collect（collector.toList（））；
列表carsFilteredOnFuelType=carList.stream（）.filter（car->fueltype.equals（car.fueltype））.collect（Collectors.toList））；

如果不需要，我建议您不要将变量声明为

ArrayList

。抽象越大，代码就越通用，因此程序的功能就越强大。看看这个例子：

ArrayList<Car> cars = new ArrayList<>();

ArrayList

实现了
AbstractList
，您以后可能会决定将
cars
切换到另一种类型的
AbstractList
实现

此外，阅读/观看一些教程，因为即使是最基本的语法，您也很难掌握

现在让我们看看你们的问题。您的第一个问题要求列出仅清洁
汽车的方法。此任务不是原子任务，您需要将任务分开。首先，很高兴得到
汽车的干净子集。即使您不打算列出这些任务，这种类型的任务也可能很有用。因此，让我们独立实施：

public static AbstractList<Car> getCleanCars(AbstractList<Car> cars) {
    AbstractList<Car> cleanCars = new ArrayList<Car>();
    for (Car car : cars) {
        if (car.isClean()) {
            cleanCars.add(car);
        }
    }
    return cleanCars;
}

您需要像这样调用
displayCars
：
Car.displayCars（Car.getCleanCars（cars））

您的第二个问题是不合逻辑的，因为您希望使用一个参数调用一个用两个参数声明的方法。由于您的代码中充满了错误，因此确实无法读取，因此我无法帮助您解决这一问题，但是，如果可以通过
Car
对象确定燃油类型，则您需要迭代如上所示的车辆列表，而不是调用
isClean
，您需要使用
.equals（）
方法将
汽车的燃油类型作为
字符串
与接收到的参数进行比较。
您尝试过什么吗？@R.Schouten您至少应该先缩进代码。此外，您的语法是错误的，为什么像
class
和
private
这样的词是大写的？在我看来，你甚至不知道最基本的东西。也许你应该发布你迄今为止尝试过的内容。这看起来确实可疑地像是家庭作业…@TomMorris家庭作业可能是有效的StackOverflow问题的主题，前提是OP包括他/她迄今为止为解决问题所做工作的摘要，以及他/她解决问题的困难的描述。。当您呈现“代码”时，应该是正确编译的代码（大括号正确闭合，注释前面是
/
，而不是
==
（Java）），并且代码应该正确缩进。
public static List<Car> filterCars(List<Car> cars, Predicate<Car> condition) {
    return cars.stream()
               .filter(condition)
               .collect(Collectors.toList());
}

List<Car> cleanCars = filterCars(cars, new Predicate<Car>() {
    @Override
    public boolean apply(Car c) {
        return c.isClean();
    }
});

List<Car> cleanCars = filterCars(cars, (Car c) -> c.isClean());

List<Car> cleanFuelCars = filterCars(cars, (Car c) -> {
    if (c instanceof FuelCar) {
        FuelCar fuelCar = (FuelCar) c;
        return c.isClean();
    }
    return false;
});

public static void printCarsSpecific(List<Car> cars, String fuelType) {
    for (Car c : cars) {
        if (c instanceof FuelCar) {
            FuelCar fuelCar = (FuelCar) c;
            if (fuelCar.fuelType.equals(fuelType)) {
                System.out.println(fuelCar);
            }
        }
    }
}

public static void printCarsSpecific(List<Car> cars, Predicate<Car> p) {
    List<Car> filtered = filterCars(cars, p);
    for (Car c : filtered) {
        System.out.println(c);
    }
}

printCarsSpecific(cars, (Car c) -> {
    if (c instanceof FuelCar) {
        FuelCar fuelCar = (FuelCar) c;
        retur fuelCar.fuelType.equals("gasoline");
    }
    return false;
});

List<Car> cleanCars = carList.stream().filter(car -> car.isClean()).collect(Collectors.toList());

List<Car> carsFilteredOnFuelType = carList.stream().filter(car -> fueltype.equals(car.fueltype)).collect(Collectors.toList));

ArrayList<Car> cars = new ArrayList<>();

AbstractList<Car> cars = new ArrayList<Car>();

public static AbstractList<Car> getCleanCars(AbstractList<Car> cars) {
    AbstractList<Car> cleanCars = new ArrayList<Car>();
    for (Car car : cars) {
        if (car.isClean()) {
            cleanCars.add(car);
        }
    }
    return cleanCars;
}

public static void displayCars(AbstractList<Car> cars) {
    //Display the cars
}