1. 行为参数化
2. lambda表达式
3. 如何改造程序
4. Java 8 提供的函数式接口
5. 局部变量与闭包
6. 方法引用
7. 复合lambda表达式

行为参数化

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

public class Apple {

    private String color;

    public Apple() {
        Random random = new Random();
        if (random.nextBoolean()) {
            color = "red";
        } else {
            color = "green";
        }
    }

    public String getColor() {
        return color;
    }

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

    public static void main(String[] args) {

        List<Apple> apples = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            apples.add(new Apple());
        }
        System.out.println(apples);

        List<Apple> greenApples = filterGreenApples(apples);
        System.out.println(greenApples);

    }

    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;
    }

}

public static List<Apple> filterApples(List<Apple> inventory, Condition condition) {
    List<Apple> result = new ArrayList<>();
    for (Apple apple : inventory) {
        if (condition.test(apple)) {
            result.add(apple);
        }
    }
    return result;
}

public interface Condition {

    boolean test(Apple apple);
}

public static void main(String[] args) {

    //随机准备10个颜色的苹果
    List<Apple> apples = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        apples.add(new Apple());
    }


    List<Apple> greenApples = filterApples(apples, new Condition() {
        @Override
        public boolean test(Apple apple) {
            return "green".equals(apple.getColor());
        }
    });
}

public class GreenCondition implements Condition {

    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}

List<Apple> greenApples = filterApples(apples, new GreenCondition());

"green".equals(apple.getColor())

List<Apple> greenApples = filterApples(apples, (apple) -> "green".equals(apple.getColor()));

List<Apple> greenApples = filterApples(apples, GreenCondition::test);

lambda表达式

public interface Condition {

    boolean test(Apple apple);

    boolean test2(Apple apple);
}

如何改造程序

1. 捕捉不同行为下的相同点, 无论读取一行, 还是读取两行, 最后返回的都是一个字符串, 因此 这是一个接受一个Reader对象, 返回字符串的行为
2. 用函数式接口来规范行为
3. 编写使用函数式接口对象的方法
4. 在实际使用方法的时候, 传递lambda表达式

@FunctionalInterface
public interface ReadFile {

    String read(BufferedReader bufferedReader) throws IOException;

}

public static String getContent(String filename, ReadFile p) {
    String result = "";
    try {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filename));
        result = p.read(bufferedReader);
    } catch (IOException e) {
        System.out.println("处理错误");
    }
    return result;
}

public static void main(String[] args) {
    String result = getContent("program.txt", bufferedReader -> bufferedReader.readLine()+ "\n"+bufferedReader.readLine());

    System.out.println(result);

    String result2 = getContent("program.txt", bufferedReader -> bufferedReader.readLine());

    System.out.println(result2);
}

Java 8 提供的函数式接口

1. Predicate<T>, 这个接口定义了test方法, 接受泛型T, 返回boolean类型. 这个类似于一个测试, 凡是需要过滤和判断的地方, 都可以采用此接口
2. Consumer<T>, 这个接口定义了一个accept的方法, 接受泛型T, 返回void, 其实顾名思义, 就相当于消费掉了这个数据, 没有返回值.
3. Function<T, R>, 这个顾名思义, 就是一个抽象的函数, 其中有一个apply方法, 接受T类型, 返回R类型, 相当于从T到R的映射. 当然这其中还有一个compose和一个andthen, 属于高级的用法
4. 类型特化接口, 这个是针对java.util.function中所有的泛型接口, 在操作基本类型的时候, 因为自动装箱拆箱机制造成的性能低下, 直接会接受泛型返回基本类型或者在基本类型之间转换, 具体有很多, 只要记住涉及到基本类型, 就要想起类型特化接口
5. Supplier<T>, 其中定义了get()方法, 无参数, 返回T类型, 由于这个函数的意义就是无中生有, 创造出T类型, 所以顾名思义称作Supplier接口
6. UnaryOperator<T>, 这其中定义了一个:

       static <T> UnaryOperator<T> identity() {
           return (t) -> {
               return t;
           };
       }
   

   本质就是接受一个T返回一个T, 是一个对一个对象进行某些操作的抽象. 这个接口实际上是继承了Function<T,T>接口.
7. BiFunction<T, U, R>, 二元得到一元, 其中也是apply方法, 接受T和U类型参数, 返回R参数.
8. BinaryOperator<T>, 这个接口实际上继承BiFunction<T, T, T>, 即接受两个T类型, 返回一个T类型, 可以用于聚合. 还提供了minBy和maxBy两个方法.
9. BiPredicate<L, R>, 这个接口的方法是 test(T var1, U var2);接受L和R类型, 返回boolean, 用来同时测试两个对象. 此外还有几个默认方法.
10. BiConsumer<T, U>, 和Consumer接口一样, 方法是accept(T var1, U var2);接受T和U类型, 返回void, 所以也是一个Consumer

局部变量与闭包

方法引用

public interface ConsumeApple extends Consumer<Apple> {
}

public class UseApple {

    public static void processApple(Apple apple, ConsumeApple consumeApple) {
        consumeApple.accept(apple);
    }

}

public static void main(String[] args) {

    Apple apple = new Apple();

    processApple(apple, apple1 -> {
        System.out.println("apple is" + apple);
    });
}

public static void main(String[] args) {

    Apple apple = new Apple();

    processApple(apple, System.out::println);
}

1. 指向静态方法的方法引用, 使用类名::方法名. 注意这个类名和方法名都是不会改变的, 所以就直接用类名::方法名
2. 第二种比较特殊, 指向不特定对象的实例方法, 指的是这个方法能够接受一个任意的类的实例, 然后调用对应的方法, 这个对应lambda表达式的关系如下:

       (arg0, rest) -> arg0.instanceMethod(rest)
   

   简单的说, lambda表达式接受两个参数, 一个是对象, 一个是目标参数, 在程序中会调用对象的实例方法, 传入目标参数, 这个时候就需要用arg0所属的类名::实例方法. 第二种是最让人迷惑的, 我之前自学的时候就没有区分这三类, 导致看不懂, 现在就明白多了.
3. 第三类, 是指向现有特定对象的实例方法, 使用实例变量名::方法名.

复合Lambda表达式

1. 比较器复合, inventory.sort(comparing(Apple::getWeight).reversed());
2. 比较器链, inventory.sort(comparing(Apple::getWeight).reversed().thenComparing(Apple::getCountry));
3. 谓词复合, negate、and和or, 用来重用Predicte<T>:Predicate<Apple> notRedApple = redApple.negate();Predicate<Apple> redAndHeavyApple = redApple.and(a -> a.getWeight() > 150);Predicate<Apple> redAndHeavyAppleOrGreen = redApple.and(a -> a.getWeight() > 150).or(a -> "green".equals(a.getColor()));
4. 函数复合, Function接口提供了andThen和compose, 返回Function的一个实例, 例如可以很方便的实现 g(f(x)):<br> Function<Integer, Integer> f = x -> x + 1; Function<Integer, Integer> g = x -> x * 2; Function<Integer, Integer> h = f.andThen(g); int result = h.apply(1); 而compose表示自己把作为compose参数的函数当成自己的参数, 即自己的组成部件是g, 例如: Function<Integer, Integer> f = x -> x + 1; Function<Integer, Integer> g = x -> x * 2; Function<Integer, Integer> h = f.compose(g); int result = h.apply(1); 这表示的是f(g(x))