Lambda学习---方法引用和其他基本应用

package com.zx;

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * lambdaTest类
 *
 * @author ning
 * @create 2018-06-11 17:19
 **/
public class LambdaTest {

    public static void main(String[] args){

        new Thread(() -> {System.out.println("lambda创建一个新线程");}).start();

        List<String> listStr = Arrays.asList("Java","C","C++","C#","Python","PHP");
        StringBuilder sb = new StringBuilder();
        listStr.forEach(n -> System.out.println(sb.append(",").append(n)));

        /**
         * 用特殊符号拼接
         * */
        String collect = listStr.stream().collect(Collectors.joining(","));
        System.out.println(collect);
        String collect1 = listStr.stream().collect(Collectors.joining("#"));
        System.out.println(collect1);

        listStr.sort((a,b) -> a.compareTo(b));
        System.out.println(listStr);

        String abc = "hello";
        Consumer<String> consumer = (a) -> {};

        Function<String,String> function = x -> x.toUpperCase();
        String zsdf = function.apply("zsdf");
        System.out.println(zsdf);

        /**
         * 静态方法引用
         * 语法格式- - 类目::staticMethod
         */
        //只有一个输出
        Supplier<String> supplier = LambdaTest::put;
        System.out.println(supplier.get());
        //只有一个输入
        Consumer<String> c1 = LambdaTest::consume;
        c1.accept("张三");
        //一个输入，一个输出
        Function<String, String> f1 = LambdaTest::convertUp;
        System.out.println(f1.apply("a"));
        //两个输入，一个输出
        BiFunction<String,String,Integer> biFunction = LambdaTest::getLength;
        System.out.println(biFunction.apply("abc","123"));
        //////////////////////  方法的引用 - start  ////////////////////////
        /**
         * 实例方法引用
         * 语法格式- - 实例::实例Method
         */
        Supplier<String> s1 = new LambdaTest()::put1;
        System.out.println(s1.get());
        LambdaTest lt = new LambdaTest();
        Consumer<String> c2 = lt::consume1;
        c2.accept("王五");

        /**
         * 对象方法引用
         * 定义：抽象方法的第一个参数类型【最好是自定义的类型】刚好是实例方法的类型【言外之意，必需有参数】，抽象方法剩余的参数恰好可以当作实例方法的参数。
         * 如果函数式接口的实现能用上面说的实例方法调用来实现的话，那么就可以使用对象方法引用
         * 语法格式- - 类名::实例Method
         */
        Consumer<Too> c3 = (Too too) -> new Too().too();
        c3.accept(new Too());
        Consumer<Too> c4 = Too::too;
        c4.accept(new Too());
        BiConsumer<Too,String> c5 = (too, ac) -> new Too().too1(ac);
        c5.accept(new Too(),"宁大人");
        //两个输入，一个输出
        BiFunction<Too, String, Integer> biFunction1 = (p,s) -> new Too().too2(s);
        BiFunction<Too, String, Integer> biFunction2 = Too::too2;
        System.out.println(biFunction1.apply(new Too(),"123"));
        System.out.println(biFunction2.apply(new Too(),"123"));
        /**
         * 构造方法的引用
         * 定义：如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用
         * 语法格式- - 类名::new
         */
        Supplier<Person> s2 = () -> new Person();
        s2.get();
        Supplier<Person> s3 = Person::new;
        s3.get();
        //含有无参构造函数都可以使用Supplier，如下：
        Supplier<List> s4 = ArrayList::new;
        Supplier<Thread> s5 = Thread::new;
        Supplier<Set> s6 = HashSet::new;
        Supplier<String> s7 = String::new;

        //含有有参构造函数的
        Consumer<Integer> c6 = Account::new;
        c6.accept(123);

        Function<String, Integer> f2 = Integer::new;
        System.out.println(f2.apply("456"));

        //////////////////////  方法的引用 - end  ////////////////////////

        //////////////////////  Stream API - start  ////////////////////////

        /***
         * stream的创建
         * */
        //1、数组
        String[] arr = {"1","b","c"};
        Integer[] arr1 = {1,2,3,4};
        Stream<String> stream1 = Stream.of(arr);
        Stream<Integer> stream2 = Stream.of(arr1);
        //2、集合
        List<String> list1 = Arrays.asList("1","2","3");
        Stream<String> stream = list1.stream();

        /**
         * 中间操作
         * */
        Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).forEach(System.out::println);
        int max = Arrays.asList(1, 2, 3, 4, 5, 6).stream().max((a1,b1) -> a1-b1).get();
        System.out.println(max);
        Integer min = Arrays.asList(1, 2, 3, 4, 5, 6).stream().min((a1, b1) -> a1 - b1).get();
        System.out.println(min);
        //求集合元素数量
        long count = Arrays.asList(1, 2, 3, 4, 5).stream().count();
        System.out.println(count);
        //截取
        Arrays.asList(1, 2, 3, 4, 5, 6).stream().limit(3).forEach(System.out::println);
        //求平均值
        double asDouble = Arrays.asList(1, 2, 3, 4, 5, 6).stream().mapToInt(x -> x).average().getAsDouble();
        System.out.println(asDouble);
        //查找任意匹配的元素
        Optional<Integer> first = Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).findAny();
        System.out.println(first.get());
        //查找第一个匹配的元素
        Optional<Integer> first1 = Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).sorted((a,b) -> b -a).findFirst();
        System.out.println(first1.get());
        //从1-50里面的所有偶数找出来，放到一个list中
        List<Integer> list2 = Stream.iterate(1, x -> x + 1).limit(50).filter(n -> n % 2 == 0).collect(Collectors.toList());
        list2.forEach(System.out::println);
        //集合元素去重
        Arrays.asList(1,2,3,4,5,4,3,5,6,7,3,8).stream().distinct().forEach(System.out::println);
        //将流转成set集合
        Set<Integer> collect2 = Arrays.asList(1, 2, 3, 4, 5, 4, 3, 5, 6, 7, 3, 8).stream().collect(Collectors.toSet());
        System.out.println(collect2);
        //从1-50里面的所有偶数找出来，忽略前10个，放到一个list中
        List<Integer> list3 = Stream.iterate(1, x -> x + 1).limit(50).filter(n -> n % 2 == 0).skip(10).collect(Collectors.toList());
        System.out.println(list3);
        //类似分页效果, skip(10).limit(10) ：跳过前10条，相当于查询第二页，每页10条
        List<Integer> list4 = Stream.iterate(1, x -> x + 1).limit(50).sorted((a,b) -> b -a).skip(10).limit(10).collect(Collectors.toList());
        System.out.println(list4);
        //////////////////////  Stream API - end  ////////////////////////
    }

    String put1(){
        return "world";
    }

    static String put(){
        return "hello";
    }

    void consume1(String string){
        System.out.println(string + ", 哈哈哈");
    }
    static void consume(String string){
        System.out.println(string + ", 哈哈哈");
    }
    static String convertUp(String a){
        return a.toUpperCase();
    }
    static Integer getLength(String a, String b){
        return a.length() + b.length();
    }
}

class Account{
    public Account(int age){
        System.out.println(age);
    }
}

class Person{
    public Person(){
        System.out.println("person 构造方法调用了");
    }
}

class Too{
    public void too(){
        System.out.println("invoke.............");
    }

    public void too1(String str){
        System.out.println(str + ",invoke.............");
    }

    public Integer too2(String p) {
        return 1;
    }
}