Lambda表达式

java.util.function包中是通用性函数接口，它满足一下几种基本的使用。

         函数型T ->R，完成参数类型T向结果类型R的转换。核心函数接口Function、operater

    判断型T->boolean，核心函数接口Predicate

    消费型T->void，核心函数接口Consumer

供给型void->T，核心函数接口Supplier

同时也有单参数和双参数之分，前缀加”bi”是双参数，前缀不加或加”Unary”的是单参数。

使用function保重的通用函数接口，在业务中基本可以不用再创建函数接口了。Function中的函数接口如下

类别	小类别	介绍	接口
function	function	有参数，有返回值，参数和返回值类型自定，可不同	Function BiFunction DoubleFunction DoubleToIntFunction DoubleToLongFunction IntFunction IntToDoubleFunction IntToLongFunction LongFunction LongToDoubleFunction LongToIntFunction ToDoubleBiFunction ToDoubleFunction ToIntBiFunction ToIntFunction ToLongBiFunction ToLongFunction
	operator	继承function，为参数、返回值类型都相同的function	BinaryOperator DoubleBinaryOperator DoubleUnaryOperator IntBinaryOperator IntUnaryOperator LongBinaryOperator LongUnaryOperator UnaryOperator
Perdicate		返回boolean值，判断	Predicate BiPredicate DoublePredicate IntPredicate LongPredicate
Supplier		生产者，不带任何参数	Supplier BooleanSupplier DoubleSupplier IntSupplier LongSupplier
Consumer		消费者，没有任何返回值	Consumer BiConsumer DoubleConsumer IntConsumer LongConsumer ObjDoubleConsumer ObjIntConsumer ObjLongConsumer

Function的通用函数接口满足的大部分的需求，直接实现通用函数接口就好。下面是函数接口的示例。这些示例包含了Predicate、BiConsumer、BiFunction、BinaryOperator、DoubleFunction、DoubleUnaryOperator、DoubleConsumer、DoubleSupplier。

 

public void evenNumTest() {
        List<Integer> numlist = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        printEvenNum(numlist, (Integer a) -> {
            return a % 2 == 0;
        });
    }
 
    /**
     * Predicate实现求偶数
     */
    public void printEvenNum(List<Integer> numlist, Predicate<Integer> evenNumPredicate) {
        for (Integer num : numlist) {
            if (evenNumPredicate.test(num)) {
                System.out.println(num);
            }
        }
    }
 

    public void stringAddIntegerTest() {
        Integer in = 3;
        String us = "5";
        printStringAddInteger(in, us, (String u, Integer i) -> {
            System.out.println("i+u=" + (i + Integer.valueOf(u)));
        });
    }
 
    /**
     * Consumer实现加法运算
     */
    public void printStringAddInteger(int i, String u, BiConsumer<String, Integer> biConsumer) {
        biConsumer.accept(u, i);
    }
 

    public void returnStringAddIntTest() {
        Integer result = returnStringAddInt(3, "5", (String st, Integer in) -> {
            return in + Integer.valueOf(st);
        });
        System.out.println("result:" + result);
    }
 
    /**
     * Function实现带返回值的加法运算
     */
    public Integer returnStringAddInt(int i, String u, BiFunction<String, Integer, Integer> biConsumer) {
        return biConsumer.apply(u, i);
    }

    
    public void returnStringAddTest() {
        System.out.println("result:" + returnStringAdd("1", "2", (a, b) -> {
            return String.valueOf(Integer.valueOf(a) + Integer.valueOf(b));
        }));
    }
 
    /**
     * Operator实现两个参数、返回值类型相同的加法运算
     */
    public String returnStringAdd(String a, String b, BinaryOperator<String> binaryOperator) {
        return binaryOperator.apply(a, b);
    }
 

    public void returnDateStringTest() {
        returnDateString(() -> {
            return new Random().nextInt(10);
        });
    }
 
    /**
     * supplier模拟抽奖系统
     */
    public void returnDateString(Supplier<Integer> supplier) {
        Integer caipiao = 5;
        Integer kaijiancaipiao = supplier.get();
        System.out.println("开奖数字：" + kaijiancaipiao);
        switch (Math.abs(caipiao - kaijiancaipiao)) {
            case 0:
                System.out.println("一等奖");
                break;
            case 1:
                System.out.println("二等奖");
                break;
            case 2:
                System.out.println("三等奖");
                break;
            default:
                System.out.println("没有中奖");
        }
    }
 

    public void doubleFunctionTest() {
        String result = doubleFunction(3.0, (double a) -> {
            return a + "xxx";
        });
    }
 
    //DoubleFunction的案例
    public String doubleFunction(Double param, DoubleFunction<String> doubleFunction) {
        String result = doubleFunction.apply(param);
        return result;
    }
 

    public void toDoubleBiFunctionTest() {
        Double result = toDoubleBiFunction("12", (byte) '1', (s, b) -> {
            return Double.valueOf(Integer.valueOf(s) - Integer.valueOf(b));
        });
        System.out.println("result:" + result);
    }
 
    //ToDoubleBiFunction的案例
    public Double toDoubleBiFunction(String ss, Byte bb, ToDoubleBiFunction<String, Byte> toDoubleBiFunction) {
        Double result = toDoubleBiFunction.applyAsDouble(ss, bb);
        return result;
    }
 

    public void doubleUnaryOperatorTest() {
        Double result = doubleUnaryOperator(3.9, (a) -> {
            return a + 1;
        });
        System.out.println("result:" + result);
    }
 
    //DoubleUnaryOperator的案例
    public Double doubleUnaryOperator(double s, DoubleUnaryOperator doubleUnaryOperator) {
        Double result = doubleUnaryOperator.applyAsDouble(s);
        return result;
    }
 

    public void doubleConsumerTest() {
        doubleConsumer(3.4, (d) -> {
            System.out.println(d + 1.0);
        });
    }
 
    //DoubleConsumer的案例
    public void doubleConsumer(Double d, DoubleConsumer doubleConsumer) {
        doubleConsumer.accept(d);
    }
 

    public void doubleSupplierTest() {
        Double result = doubleSupplier(()->{
           return 2.4;
        });
        System.out.println("result:" + result);
    }
 
    //DoubleSupplier的案例
    public Double doubleSupplier(DoubleSupplier doubleSupplier) {
        Double result = doubleSupplier.getAsDouble();
        return result;
    }