Lambda表达式入门,详细介绍样例

 
package com.ruoyi.demo.service.impl;
/*
*/
/***
 * lambda表达式学习
 * 注解限定函数式接口
 *//*
//这个是注解，注解了之后，这个方法，没有其他第二种抽象方法，除了默认和eq方法之外
//具体可以参考这个Comparator
@FunctionalInterface 
interface TestInterFace{
    void  testMethod();
}
class  MyClass implements  TestInterFace3{
 
    @Override
    public int testMethod2(int num1 , int num2) {
        System.out.println("我重新实现了testMethod方法！");
 
     return num1+num2;
    }
}
interface  TestInterFace2{
    void testMethod2(int num);
}
@FunctionalInterface
interface  TestInterFace3{
    int testMethod2(int num1 , int num2);
    boolean equals(Object obj);
}
 
 
public class Test {
 
    public static void main(String[] args) {
       */
/* TestInterFace t  = new MyClass();
        t.testMethod();*//*
 
       //匿名内部类
        */
/*TestInterFace t = new TestInterFace() {
            @Override
            public void testMethod() {
                System.out.println("我重新实现了testMethod方法11111！");
            }
        };
        t.testMethod();*//*
 
       */
/* TestInterFace t = () ->  System.out.println("lambda表达");
        t.testMethod();*//*
 
 
       */
/* TestInterFace2 t2 = (int num) -> System.out.println("这个方法得参数："+num);
        t2.testMethod2(2);*//*
 
        //一个参数，这个可以省略（）
       */
/* TestInterFace2 t2 =  num ->    System.out.println("这个方法得参数："+num);
        t2.testMethod2(2);*//*
 
 
      */
/* TestInterFace2 t2 = () -> {
           String name = "2";
 
           return name;
       };
        String s = t2.testMethod2();
        System.out.println(s);*//*
 
        TestInterFace3 t  = (x,y) ->{
            System.out.println("俩个参数的值分别"+ x + y);
            return x+y;
        };
        int i = t.testMethod2(3, 5);
        System.out.println(i);
 
    }
}
*/
 
 
import java.io.PrintStream;
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
 
/**
 * 内置四个函数式接口
 * 1.消费型接口   Consumer - void accept(T t)
 * 2.供给型接口   Supplier - T get()
 * 3.函数型接口   Function - R apply(T t)
 * 4.断言型接口  断定型接口 predicate teat
 *
 *
 *
 */
/*
@FunctionalInterface
interface SpendMoney{
    void buy(BigDecimal money);
}
public class Test {
 
    public static void bath(BigDecimal money,SpendMoney spendMoney){
        spendMoney.buy(money);
 
    }
 
    public static void main(String[] args) {
        bath(new BigDecimal(100), new SpendMoney() {
            @Override
            public void buy(BigDecimal money) {
                System.out.println("本次按摩消费为"+money);
            }
        });
        bath(new BigDecimal(100),
    }
}
 
*/
 
 
/*
public class Test {
 
    public static void bath(BigDecimal money,Consumer<BigDecimal> spendMoney){
        spendMoney.accept(money);
 
    }
 
    public static void main(String[] args) {
        bath(new BigDecimal(100), new Consumer<BigDecimal>() {
 
            @Override
            public void accept(BigDecimal bigDecimal) {
                System.out.println("本次按摩消费为"+bigDecimal);
            };
        });
 
        bath(new BigDecimal(100), x ->  System.out.println("本次按摩消费为"+x) );
 
 
    }
}
*/
 
/***
 *  * 内置四个函数式接口
 *  * 1.消费型接口   Consumer - void accept(T t)
 *  * 2.供给型接口   Supplier - T get()
 *  * 3.函数型接口   Function - R apply(T t)
 *  * 4.断言型接口  断定型接口 predicate teat
 *  *
 * 方法引用
 * 三种使用情况  主要是方法和方法体返回需要保持一致
 * 1.对象::实例方法名（非静态方法）
 * 2.类::静态方法名
 * 3.类::实例方法名
 *
 */
public class Test {
 
 
    public static void main(String[] args) {
        Consumer<String> con  =  x -> System.out.println("去啥地方了？"+x);
        con.accept("惠州");
        //1.对象::实例方法名（非静态方法）
        PrintStream out = System.out;
        Consumer<String> con2 = out::println;
        Consumer<String> con3 = System.out::println;
 
        con2.accept("惠州");
        // 2.类::静态方法命
        Comparator<Integer> con4 = (x, y) -> Integer.compare(x,y);
        System.out.println(con4.compare(1, 3));
        Comparator<Integer> con5 = Integer::compare;
        System.out.println(con5.compare(434, 3));
        //3.类::实例方法名
        BiPredicate<String,String> bp = (x,y) -> x.equals(y);
        System.out.println(bp.test("asb", "aa"));
 
        BiPredicate<String,String> bp2 = String::equals;
        System.out.println(bp2.test("asb", "asb"));
 
 
    }
}