Introduction to the usage of predicate in java8 (code example)

This article brings you an introduction to the usage of predicate in java8 (code examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Pass code

Let’s first look at an example. Suppose you have an Apple class, which has a getColor method, and a variable inventory that holds a list of Apples. . You might want to select all green apples and return a list. Usually we use the word filter to express this concept. Before Java 8, you might write such a method filterGreenApples:

public static List<apple> filterGreenApples(List<apple> inventory){
List<apple> result = new ArrayList();
for (Apple apple: inventory){
if ("green".equals(apple.getColor())) {
result.add(apple);
        }
    }
return result;
}</apple></apple></apple>

But then, someone might want to select heavy apples, such as more than 150 grams, so you wrote the following with a heavy heart
method, even using copy and paste:

public static List<apple> filterHeavyApples(List<apple> inventory){
List<apple> result = new ArrayList();
for (Apple apple: inventory){
if (apple.getWeight() > 150) {
result.add(apple);
        }      
    }
return result;
}</apple></apple></apple>

We all know the dangers of copy and paste in software engineering - updating and correcting one, but forgetting about the other. Hey, there is only one line difference between the two methods: the highlighted line of condition in if. If the difference between the two highlighted methods is only the weight range of the accepted
, then you only need to pass the upper and lower limits of the accepted weight as parameters to the filter, such as specifying
(150, 1000) to select heavier apples (over 150 grams), or specify (0, 80) to select light apples (under 80 grams).
However, as we mentioned before, Java 8 will pass the conditional code as a parameter, which can avoid duplicate code in the filter method
. Now you can write:

public static boolean isGreenApple(Apple apple) {
    return "green".equals(apple.getColor());
}
public static boolean isHeavyApple(Apple apple) {
    return apple.getWeight() > 150;
}
static List<apple> filterApples(List<apple> inventory, Predicate<apple> p) {
    List<apple> result = new ArrayList();
    for (Apple apple: inventory){
        if (p.test(apple)) {
            result.add(apple);
        }
    }
    return result;
}</apple></apple></apple></apple>

To use it, you can write:

filterApples(inventory, Apple::isGreenApple);
or
filterApples(inventory, Apple::isHeavyApple) ;
What is a predicate?

The previous code passes the method Apple::isGreenApple (which accepts the parameter Apple and returns a

boolean) to filterApples, which expects to accept a Predicate parameter. The word predicate
is often used in mathematics to represent something like a function, which accepts a parameter value and returns true or false. As you
will see later, Java 8 will also allow you to write Function - readers who have learned functions in school but not
predicates may be more familiar with this, but use Predicate is a more standard way and is a little more efficient. It avoids encapsulating boolean in Boolean.

Passing methods to Lambda

Passing methods as values ​​is obviously useful, but if it is short methods like isHeavyApple and isGreenApple that

can only be used once or twice Writing a bunch of definitions is a bit annoying. However, Java 8 also solves this problem. It introduces a new

notation (anonymous function or Lambda), allowing you to write
filterApples(inventory, (Apple a) -> "green".equals (a.getColor()) );
or
filterApples(inventory, (Apple a) -> a.getWeight() > 150 );
or even
filterApples(inventory, (Apple a) -> a.getWeight() "brown".equals(a.getColor()) );
The complete code is:

public class FilteringApples1 {
    public static void main(String[] args) {
        List<filteringapples1.apple> inventory = Arrays.asList(new FilteringApples1.Apple(80, "green"),
                new FilteringApples1.Apple(155, "green"),
                new FilteringApples1.Apple(120, "red"));

        List<filteringapples1.apple> greenApples2 = filterApples(inventory, (FilteringApples1.Apple a) -> "green".equals(a.getColor()));
        System.out.println(greenApples2);

        // [Apple{color='green', weight=155}]
        List<filteringapples1.apple> heavyApples2 = filterApples(inventory, (FilteringApples1.Apple a) -> a.getWeight() > 150);
        System.out.println(heavyApples2);

        // []
        List<filteringapples1.apple> weirdApples = filterApples(inventory, (FilteringApples1.Apple a) -> a.getWeight()  filterApples(List<filteringapples1.apple> inventory, Predicate<filteringapples1.apple> p) {
        List<filteringapples1.apple> result = new ArrayList();
        for (FilteringApples1.Apple apple : inventory) {
            if (p.test(apple)) {
                result.add(apple);
            }
        }
        return result;
    }

    public static class Apple {
        private int weight = 0;
        private String color = "";

        public Apple(int weight, String color) {
            this.weight = weight;
            this.color = color;
        }

        public Integer getWeight() {
            return weight;
        }

        public void setWeight(Integer weight) {
            this.weight = weight;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public String toString() {
            return "Apple{" +
                    "color='" + color + '\'' +
                    ", weight=" + weight +
                    '}';
        }
    }

}</filteringapples1.apple></filteringapples1.apple></filteringapples1.apple></filteringapples1.apple></filteringapples1.apple></filteringapples1.apple></filteringapples1.apple>

Built in java8 filter function

static <t> Collection<t> filter(Collection<t> c, Predicate<t> p);</t></t></t></t>

This way you don’t even need to write filterApples, because for example, the previous call

filterApples(inventory, (Apple a) -> a.getWeight() > 150 );

can directly call the library method filter:

filter(inventory, (Apple a) -> a.getWeight() > 150 );

The above is the detailed content of Introduction to the usage of predicate in java8 (code example). For more information, please follow other related articles on the PHP Chinese website!