Java8InAction_Chapter03

import static java.util.Comparator.comparing;

import java.util.Arrays;
import java.util.List;
import java.util.function.DoubleFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 在这里编写类的功能描述
 *
 * @author shangjinyu
 * @created 2017/10/3
 */
public class Notes {
    public static void main(String ... args){
    //构造一个待筛选的list
    List<Apple> inventory = Arrays.asList(new Apple(80, "green"),
            new Apple(155, "green"),
            new Apple(120, "red"));

    /**
     * Lambda的语法是
     * (parameters) -> expression
     * 
     * 函数式接口就是只定义一个抽象方法的接口
     * 
     * 　　　　　　　　Java8中的常用函数式接口
     * 函数式接口            函数描述符            原始类型特化
     * Predicae<T>          T->boolean          IntPredicate,LongPredicate,DoublePredicate
     * Consumer<T>          T->void             IntConsumer,LongConsumer,DoubleConsumer
     *
     * Function<T,R>        T->R                IntFunction<R>,
     *                                          IntToDoubleFunction,
     *                                          IntToLongFunction,
     *                                          LongFunction<R>,
     *                                          LongToDoubleFunction,
     *                                          LongToIntFunction,
     *                                          DoubleFunction<R>,
     *                                          ToIntFunction<T>,
     *                                          ToDoubleFunction<T>,
     *                                          ToLongFunction<T>,
     *
     * Supplier<T>          ()->T               BooleanSupplier,IntSupplier, LongSupplier,
     * DoubleSupplier
     *
     * UnaryOperator<T>     T->T                IntUnaryOperator,
     *                                          LongUnaryOperator,
     * DoubleUnaryOperator
     *
     * BinaryOperator<T>    (T,T)->T            IntBinaryOperator,
     *                                          LongBinaryOperator,
     *                                          DoubleBinaryOperator
     * BiPredicate<L,R>     (L,R)->boolean
     * BiConsumer<T,U>      (T,U)->void         ObjIntConsumer<T>,
     *                                          ObjLongConsumer<T>,
     *                                          ObjDoubleConsumer<T>
     * BiFunction<T,U,R>    (T,U)->R            ToIntBiFunction<T,U>,
     *                                          ToLongBiFunction<T,U>,
     *                                          ToDoubleBiFunction<T,U>
     */
    //针对构造函数的方法引用
    Supplier<Apple> c1 = Apple::new; //= () -> new Apple();
    System.out.println(c1.get());
    Function<Integer, Apple> c2 = Apple::new;//= (weight) -> new Apple(weight);
    System.out.println(c2.apply(10));

    //复合比较器
    inventory.sort(comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor));
    //inventory.sort((a, b) -> a.getWeight().compareTo(b.getWeight()));
    System.out.println(inventory);

    Predicate<Apple> redApple = apple -> apple.getColor().equals("red");
    Predicate<Apple> redAndHeavyAppleOrGreen =redApple.or(a -> a.getWeight().equals(100));
    //and和or方法是按照在表达式中的位置，从左向右确定优先级的，即a.or(b).and(c)可以 作(a || b) && c

    //函数复合
    Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h1 = f.andThen(g);
    int result1 = h1.apply(1);//result1 = 4;

    Function<Integer, Integer> h2 = f.compose(g);
    int result2 = h2.apply(1);//result2 = 3;

    //计算 f(x) = x * 3 + 10 在x=3 到 x=7 上的积分
    double integrate = integrate(a ->  a * 3 + 10, 3 , 7);
    System.out.println(integrate);
    }

    public static double integrate(DoubleFunction<Double> f, double a, double b) {
        return (f.apply(a) + f.apply(b)) * (b-a) / 2.0;
    }

    //一个实体类
    public static class Apple {
        private int weight = 0;
        private String color = "";

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

        public Apple() {

        }

        public Apple(Integer weight) {
            this.weight = weight;
        }

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