java8 lambda表达式和函数型接口

/**
 * @author gc
 * Lambda  表达式的基础语法：java8中引入一个新的操作符 "->" ,该操作符称为箭头操作符或lambda操作符
 *      箭头操作符将lambda拆分成两部分：
 *      左侧：lambda表达式的参数列表
 *      右侧：lambda表达式中所需执行的功能，即lambda体
 *  语法格式一：无参数，无返回值
 *      () -> System.out.println("xxxxxx");
 *  语法格式二：有一个参数，无返回值
 *      (x) -> System.out.println(xxxxxx);
 *  语法格式三：若只有一个参数，小括号可以省略不写
 *      x -> System.out.println(x);
 *  语法格式四：有两个以上的参数，有返回值，并且lambda体中有多条语句    test4
 *      Comparator<Integer> comparator = (x,y) -> {
 *            System.out.println("函数式接口");
 *            return Integer.compare(x, y);
 *        };
 *    语法格式五：若lambda体中只有一条语句，则return和大括号都可以省略不写
 *        Comparator<Integer> comparator = (x,y) -> Integer.compare(x, y);
 *    语法格式六：lambda表达式的参数列表的数据类型可以省略不写，因为jvm编译器可以根据上下文推断出数据类型，即“类型推断”
 *        (Integer x,Integer y) -> Integer.compare(x, y);  == (x,y) -> Integer.compare(x, y);
 *    
 *    左右遇一括号省（左边是一个参数或者右边只有一条语句）， 左侧推断类型省（左边不需要显示指定类型）
 *
 *    二、lambda表达式需要函数式接口的支持
 *        函数式接口：接口中只有一个抽象方法的接口(这样才知道要动态替换哪个方法)，可以使用 @FunctionalInterface 检查一下
 *        反而言之：jdk接口上有@FunctionalInterface注解的都是函数式接口
 */
public class TestLambda {
    
    @Test
    public void test1() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Runnable r1 = () -> System.out.println("hello lambda1");
            }
        }).start();
        
        //相当于实现接口Runable无参方法run的匿名实现类.这里的实现同上面的匿名类效果一样
        Runnable r1 = () -> System.out.println("hello lambda2");
        new Thread(r1).start();
    }
    @Test
    public void test2() {
        //这里因为是一个参数，所以左边的括号省略，右边是一个表达式，所以右边的大括号省略
        //Consumer是一个消费者型的函数式接口，其accept方法可以对接收到的数据进行处理。这里相当于实现其抽象方法accept
        Consumer<String> consumer = x -> System.out.println(x);
        consumer.accept("我很帅");
    }
    
    @Test
    public void test4() {
        //这里左边是两个参数，所以使用括号，右边是两条语句，使用大括号。这里是实现了Comparator接口的compare方法，用于collection排序操作
        Comparator<Integer> comparator = (x,y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };
        //这里是简写，效果同上
        Comparator<Integer> comparator2 = (x,y) -> Integer.compare(x, y);
    }
    
    //通过这里的两个lambda实现，可以发现函数式接口的方法是动态改变的，而且不用继续接口，不用匿名类，实现起来方便快捷
    @Test
    public void test5() {
        //(x) -> (x + 1)是一个lambda表达式，功能是自增。
        //其相当于一个入参和返回值类型相同的函数，这里将其传给MyFun<Integer>，可以作为函数式接口MyFun内方法getValue的实现。
        //可以理解为MyFun内方法getValue的实现变成了整数值自增然后返回
        Integer result = operation(100, (x) -> (x + 1));
        //这里输出101
        System.out.println(result);
        //这里同理，只是getValue的实现变成了自减，所以输出结果为99
        System.out.println(operation(100, (x) -> (x - 1)));
    }
    public Integer operation(Integer num, MyFun<Integer> mf) {
        return mf.getValue(num);
    }

    List<User> users = Arrays.asList(
            new User("gc", 24, 7500),
            new User("gc", 25, 13000),
            new User("gc", 26, 20000));
    
    @Test
    public void test6() {
        //这里第二个参数是lambda表达式，其实现了函数表达式式Comparator的compare方法
        Collections.sort(users, (u1, u2) -> {
            return u1.getAge() - u2.getAge();
        });
        System.out.println(users);
    }
    @Test
    //对两个long型进行处理
    public void test7() {
        //参数3是lambda，用于实现函数式接口。相当于MyFun2的getValue(a,b)功能变成了a+b
        op(100L, 200L, (x,y) -> x + y);
    }
    public void op(Long t1, Long t2, MyFun2<Long, Long> mf2) {
        System.out.println(mf2.getValue(t1, t2));
    }
    @Test
    public void test() {
        //这里是stream配合lambda表达式一起使用。stream这里简单理解为遍历list
        //(e) -> e.getSalary() >= 10000是函数式接口Predicate内方法test的实现,其功能是判断是否正确
        //下面这里就是判断list中的元素的salary是否大于10000，大于的继续往下处理
        //forEach就是遍历打印。这里总体的功能就是遍历list，打印salary大于10000的User
        users.stream().
            filter((e) -> e.getSalary() >= 10000).forEach(System.out::println);
        users.stream().
            map((e) -> e.getName()).forEach(System.out::println);
    }
}

@FunctionalInterface
public interface MyFun<T> {
    
    public T getValue(T value);
}

@FunctionalInterface
public interface MyFun2<T, R> {
    
    public R getValue(T t1, T t2);
}

public class User {
    private String name;
    private int age;
    private int salary;
    private Status status;
    
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status + "]";
    }

    public User(String name, int age, int salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}    

/**
 * @author gc、
 * java8 内置的四大核心函数式接口
 * 
 * Consumer<T>: 消费型接口，接收数据并处理
 *         void accept(T t);
 * Supplier<T>: 供给型接口，对外提供数据
 *         T get()
 * Function<T, R>: 函数型接口，接收参数，返回结果
 *         R apply(T t);
 * Predicate<T>: 断言型接口，检测入参是否符合条件（符合则返回true）
 *         boolean test(T t);
 *
 */
public class TestLambdaFunc {

    @Test
    //Consumer<T> 消费型接口
    public void testConsumer() {
        //Consumer是消费型接口，其可定义对接收到的数据进行不同的处理。这里的处理方式就是打印详细信息。
        //m -> System.out.println("大保健，消费："+m+" 元") 可以理解为Consumer中accept(T t)方法的实现
        happy(10000L, m -> System.out.println("大保健，消费："+m+" 元"));
    }
    public void happy(double money, Consumer<Double> con) {
        con.accept(money);
    }
    
    //Supplier<T> 供给型接口
    @Test
    public void testSupplier() {
        //Supplier是供给型接口。其内部定义对外输出的数据。而且不需要入参
        //() -> (int)(Math.random() * 100) 为这里的供给行为，即返回一个随机数
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
        System.out.println(numList);
    }
    
    public List<Integer> getNumList(int num, Supplier<Integer> sup) {
        List<Integer> list = new ArrayList<>();
        
        for (int i = 0; i < num; i++) {
            Integer n = sup.get();
            list.add(n);
        }
        return list;
    }
    
    //Function<T,R> 函数型接口
    @Test
    public void testFunction() {
        //函数型接口功能相对强大，可以对接收到的数据进行进一步处理，返回类型可以和入参类型不一致（泛型接口，二元组）
        //(x) -> (x + ", 哈哈哈") 这里作为Function接口中apply的实现
        String str = strHandler("我最帅", (x) -> (x + ", 哈哈哈"));
        System.out.println(str);
    }
    private String strHandler(String str, Function<String, String> fun) {
        return fun.apply(str);
    }
    
    //Predicate<T> 断言型接口
    @Test
    public void testPredicate() {
        List<String> list = Arrays.asList("Hello", "World", "www.exact.com");
        //函数式接口Predicate主要用于判断，x -> (x.length() > 5) 这里是判断入参的长度是否大于5
        List<String> filterStr = filterStr(list, x -> (x.length() > 5));
        System.out.println(filterStr);
    }
    
    public List<String> filterStr(List<String> list, Predicate<String> pre) {
        List<String> strList = new ArrayList<>();
        
        for (String str : list) {
            if(pre.test(str)) {
                strList.add(str);
            }
        }
        return strList;
    }
}

/**
 * @author gc
 * 方法引用：若lambda体中的内容有方法已经实现了，我们可以使用“方法引用”
 *         （可以理解为方法引用是lambda表达式的另外一种表达形式）
 * 主要有三种语法格式：
 *         对象::实例方法名
 *         类::静态方法名
 *         类::实例方法名
 * 注意：
 *     1.lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型一致
 *  2.若lambda参数列表 中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用className::method
 *  
 *  二、构造器引用
 *  格式：
 *      ClassName::new
 */
public class TestMethodRef {

    
    //对象::实例方法名
    @Test
    public void test() {
        Consumer<String> consuemr = (x) -> System.out.println(x);
        consuemr.accept("aaaa");
        
        PrintStream ps = System.out;
        Consumer<String> consumer2 = ps::println;
        consumer2.accept("asdf");
    }
    
    @Test
    public void test2() {
        User user= new User("gc",20,200000);
        //这里是无参，所以左边使用了()
        Supplier<String> sup = () -> user.getName();
        System.out.println(sup.get());
        
        //这里对lambda表达式进行了省略。() -> user.getAge() == user::getAge
        Supplier<Integer> sup2 = user::getAge;
        System.out.println(sup2.get());
    }
    
    //类::静态方法名
    public void test3() {
        Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
        
        //这里因为入参和lambda实现方法要调用的入参一样。所以两边都省略了
        Comparator<Integer> com1 = Integer::compare;
    }
    
    //类::实例方法名
    public void test4() {
        BiPredicate<String, String> bp = (x,y) -> x.equals(y);
        
        //这里是两个入参，而且满足第一个参数是新方法调用者，第二个参数是入参的情况
        //理论而言都用上面的表达式即可，看起来比较简单，但是不能避免别人不会使用简写方式，看不懂岂不是很尴尬
        BiPredicate<String, String> bp2 = String::equals;
    }
    
    @Test
    public void test5() {
        //函数式接口生产数据的方式是new User();
        Supplier<User> sup = () -> new User();
        //这里功能同上，简写方式
        Supplier<User> sup2 = User::new;
        System.out.println(sup2.get());
    }
}