java8学习：行为参数化

将“行为“作为参数，传进函数，然后去执行

直接上例子

目标：获取所有颜色为绿色的苹果

对象：苹果列表

行为：筛选出颜色为绿色的苹果

我只是想获取绿色的苹果

法1：for循环直接遍历

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

要是想获取color为红色的苹果咋整？

简单，

if("red".equals(apple.getColor())){

然后再写一遍

显然，我们将color作为参数传入的话，那么筛选五颜六色的苹果都只需要一个方法了。

不管什么颜色，我全都要

法2：将color作为参数传入

public static List<Apple> filterAppleByColor(List<Apple> apples,
                                                 String color){
        List<Apple> result = new ArrayList<Apple>();
        for(Apple apple : apples){
            if(color.equals(apple.getColor())){
                result.add(apple);
            }
        }
        return result;
    }

是不是和法1没什么不同，但是这样子可以扩展为所有颜色都可用了。

不管是什么苹果，我全都要

那么，问题来了，我想找出重量大于150g的苹果，就像上面的代码再写一遍嘛？

是不是可以尝试，把筛选的标准给他抽象出来进行建模

比如把

"red".equals(apple.getColor()) 或者 apple.getWeight>150

作为一个参数传给函数，这样子管他怎么筛选，我们只要把筛选标准传给方法就实现了

首先，定义一个接口

public interface ApplePredicate {java
    boolean test(Apple apple);
}

然后去实现它

//获取绿色的苹果
public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple){
        return "green".equals(apple.getColor());
    }
}

//获取重量大于150g的苹果
public class AppleHeavyWeightPredicate implements ApplePredicate {

    @Override
    public boolean test(Apple apple){
        return apple.getWeight()>150;
    }
}

这个时候，通过实现不同接口来达到不同的筛选标准

public static List<Apple> filterApplesByPredicate(List<Apple> apples, ApplePredicate predicate){
        List<Apple> result = new ArrayList<>();
        for(Apple apple : apples){
            if(predicate.test(apple)){
                result.add(apple);
            }
        }
        return result;
    }

在这里，我们把ApplePredicate作为参数传进来，通过实现不同的类来达到不同的筛选标准

List<Apple> resultList3 = FilterApple.filterApplesByPredicate(apples,new AppleGreenColorPredicate());

传入 AppleGreenColorPredicate实现类从而打到筛选绿色苹果的目的。

这个时候筛选标准和对象就已经分离开了。

不管是什么苹果，我全都要之简化代码

当然，回过头看一下，一个筛选标准一个实现类，那代码量也没比之前少多少啊，何必多此一举，此时，终于轮到匿名函数了。

匿名函数：把接口给👴定义好，实现类俺自个来

List<Apple> resultList4 = FilterApple.filterApplesByPredicate(apples,new ApplePredicate(){
            @Override
            public boolean test(Apple apple){
                return apple.getWeight()>90;
            }
        });

lambda表达式：把接口给👴定义好，其他给👴爬

List<Apple> resultList5 = FilterApple.filterApplesByPredicate(apples,(Apple apple)-> apple.getWeight()>150);

终于，见到了lambda，但实际上本次lambda初体验还是有点云里雾里的，之后继续学吧，至少lambda让我一行代码实现行为参数化了。

不管什么是什么，我全都要

本章的最后一步，那么，能不能把苹果也抽象了呢？

当然可以

定义行为接口

public interface Predicate<T> {
    boolean test(T t);
}

do something on something这一方法：

public static <T> List<T> filter(List<T> list, Predicate<T> p){
        List<T> result = new ArrayList<>();
        for(T t : list){
            if(p.test(t)){
                result.add(t);
            }
        }
        return result;
    }

直接调

List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10,11);
        List<Integer> result6 = FilterApple.filter(numbers,(Integer i)-> i%2==0);
        for(Integer integer : result6){
            System.out.println(integer);
        }

甭管苹果橘子梨，全给他抽象了。

最终：

目标：获取所有属性A为a的对象

对象：对象列表

行为：筛选出A为a的对象

总结：以上是java8实战的第二章内容，与书无二，也没什么比较深的内容，我会开始把书重新抄一遍，增进理解吧

下一章：lambda表达式