Question

让我们来看看我的节目。这有一些假想的.txt文件与汽车模型。

public class Car {
    private String model;

    public String getModel() {
        return this.model;
    }
}

public class Main {
    public static void Main(String[] args) {
        ArrayList<Car> cars = loadCars(path); //imaginary func and file
        String someModel = generateSomeModel(); //imaginart func

        for (Car c : cars) 
            if (c.getModel.equals(someModel))
                System.out.println("Hit!");

        for (Car c : cars) 
            if (!c.getModel.equals(someModel))
                System.out.println("Hit!");

    }
}

让我们假设我必须经历我的汽车列表100次并且每次在if语句中对它们进行比较以获得一些不同的属性，这意味着我必须编写100个不同的for循环，这些循环将是90％相同。有没有办法编写一个将作为参数布尔方程的函数？这样的事情。

public static void printCars(Boolean equation) {
    for (Car c : cars) 
        if (Boolean equation)
            System.out.println("Hit!");
}

Answer 1

您可以使用Predicate接口将函数（或lambda）作为参数传递给函数：

https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html

使用谓词，您可以通过以下方式重写函数：

public static void printCars(Predicate<Car> filter) {
    for (Car c : cars) 
        if (filter.test(car))
            System.out.println("Hit!");
}

然后按以下方式传递所需的功能：

printCars(c -> c.getModel().equals("bmw"));

Answer 2

如果您使用的是Java 8，则可以将Stream API与Predicate一起使用：

cars.stream()
    .filter(c -> c.getModel().equals(someModel))
    .forEach(c -> System.out.println("Hit!"));

Stream.filter方法的参数是Predicate，表示为lambda表达式，在本例中为car -> someModel.equals(car.getModel())。

您可以更改lambda表达式以匹配第二个示例：

cars.stream()
    .filter(c -> !c.getModel().equals(someModel))
    .forEach(c -> System.out.println("Hit!"));

将此抽象为方法的方法是传递列表，谓词，如果需要，还可以对匹配元素采取一些操作Consumer。这里有一些代码可以作为起点使用：

public static void handleCars(
        List<Car> cars, 
        Predicate<Car> condition, 
        Consumer<Car> action) {

    cars.stream().filter(condition).forEach(action);
}

您可以将以下代码行读取为： 流式传输汽车列表，仅过滤与给定条件匹配的汽车，并针对每个汽车执行给定操作 < /强>

您可以按如下方式调用handleCars方法：

handleCars( cars, c -> c.getModel().equals(someModel), c -> System.out.println("Car with model " + someModel + " hit!"));

或者：

handleCars( cars, c -> c.getBrand().toLowerCase().contains("mercedes"), // assume brand is String c -> System.out.println("Mercedes model found: " + c.getModel()));

如您所见，谓词和消费者可以根据需要进行复杂化。

Answer 3

如果您需要将汽车与多个属性进行比较，则只需覆盖 Car 类的等于方法。

@Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Car) {
            Car anotherCar = (Car)obj;
            return this.model.equals(anotherCar.model) &&
                    this.color.equals(anotherCar.color) &&
                    this.year == anotherCar.year;
        }
        return false;
    }

通过这种方式，您将在一个步骤中比较所有必要的属性：

List<Car> cars = //cars list
Car someCar = //bmw car
for (Car c : cars) {
    if (c.equals(someCar)) {
        System.out.println("Hit!");
    } else {
        System.out.println("Another Hit!");
    }
}

Java布尔方程作为函数的参数

3 个答案: