Java8新特性（未完待续，不断更新）

java8四大核心内置函数

函数式接口名	函数名	函数描述式	方法
Consumer	消费性	T -> void	void accept(T t)
Supplier	供给型	void -> T	T get()
Function<T , R>	函数型	T -> R	R apply(T t)
Predicate	断言型	T ->boolean	boolean test(T t)

例子：

     @Test
    public void test1(){
        //消费型
        happy(1000.0 , (money) -> System.out.println("每次消费了"+money+"元"));
       //消费型
        happy(1000.0 , (money) -> System.out.println("每次消费了"+money+"元"));
        //供给型
        String supplyStr = sadnessSupplier( () -> "so so so much sadness!");
        System.out.println("has supplied："+supplyStr);
        //函数型
        String funStrResult = funStr("123hellowpzhang" , (str) -> str.substring(3));
        System.out.println("has functioned:"+funStrResult);
        //断言型
        List<String> strList = Arrays.asList("hello" , "today" , "nice" , "!" , "ok");
        List<String> filterResult = new ArrayList<>();
        strList.forEach(str1 -> {
            if (filterStr(str1 , (perStr)-> perStr.length() > 3)){
                filterResult.add(str1);
            }
        });
        System.out.println(filterResult);
	}
	public void happy(Double money , Consumer<Double> consume){
        consume.accept(money);
    };
    public String sadnessSupplier(Supplier<String> supply){
        return supply.get();
    }
    public String funStr(String str , Function<String , String> myFun){
        return myFun.apply(str);
    }
    public boolean filterStr(String str , Predicate<String> myPre){
        return myPre.test(str);
    }

方法引用：是Lambda的另一种表现形式

三种方法引用	使用规则
对象::实例方法	Lambda体中 调用方法的参数列表、返回值类型 要与 该函数式接口中抽象方法的参数列表、返回值类型保持一致
类::实例方法	参数列表中的第一个参数是实例方法的调用者，第二个参数是实例方法的参数
类::静态方法	静态类名::方法名 ClassName :: method

例子：
对象::实例方法

//对象::实例方法 运用在Consumer对象::实例方法 运用在Consumer
 @Test
    public void test1(){
        PrintStream ps = System.out;
        Consumer<String> con = (str) -> ps.println(str);
        //使用方法引用简化后：
        Consumer<String> con2 = ps::print;
        con2.accept("12324");
    }
//对象::实例方法 运用在Supplier
    @Test
    public void supplierTest(){
        Emp emp = new Emp();
        Supplier<String> supplier = () -> emp.getName();
        //进一步简化
        Supplier<String> supplier2 = emp::getName;
        String supplierResult = supplier2.get();
        System.out.println(supplierResult);
    }
//对象::实例方法 运用在BiFunction(传入两个参数时)
	@Test
    public void functionTest() {
        BiFunction<String , Integer  , String> biFunTest = (fistStr , secondIndex) -> fistStr.substring(secondIndex);
        String result3 = biFunTest.apply("1997's wpzhang" ,7);
        System.out.println("result3:"+result3);
		//等同于
        BiFunction<String , Integer, String> biFunctionTest2 = String::substring;
        String biFunctionResult = biFunctionTest2.apply("1997's wpzhang" , 7);
        System.out.println("biFunctionResult:" + biFunctionResult);
	}

类::静态方法

 //类::静态方法 运用在Comparator
    @Test
    public void test3(){
        Comparator<Integer> com = (x, y) -> Integer.compare(x,y);
        //等同于
        Comparator<Integer> com2 = Integer::compare;
    }

类::实例方法

//类::实例方法 运用在BiPredicate
    @Test
    public void test4(){
        BiPredicate<String , String> biPredicate = (x,y) -> x.equals(y);
        boolean biPredicateResult = biPredicate.test("123" ,"123");
        System.out.println("biPredicateResult:"+biPredicateResult);
        //简化
        BiPredicate<String , String> biPredicate1 = String::equals;
        boolean biPredicateResult1 = biPredicate1.test("123" , "456");
        System.out.println("biPredicateResult1:"+biPredicateResult1);
    }

构造器引用

 	@Test
    public void test5(){
        //构造器引用默认调用的是无参构造器
        Supplier<Emp> emp = () -> new Emp();
        Emp result = emp.get();
        System.out.println("result"+result);
        //简化
        Supplier<Emp> emp2 = Emp::new;
        Emp result2 = emp2.get();
        System.out.println("result2"+result2);
        //调用一个参数的构造器
        Function<Integer , Emp> emp3 = Emp::new;
        Emp result3 = emp3.apply(23);
        System.out.println("result3:"+result3);
    }

数组引用

@Test
    public void test6(){
        Function<Integer , String[]> arrFun = (length) -> new String[length];
        String[] arr = arrFun.apply(10);
        System.out.println("result4："+arr.length);
        //等同于
        Function<Integer , String[]> arrFun2 =String[]::new;
        String[] arr2 = arrFun2.apply(20);
        System.out.println("result5:"+arr2.length);
    }

Stream

step:

• 创建流
• 中间操作
• 终止操作

创建流：

@Test
    public void test1(){
        //通过Collection系列集合创建流
        List<String> list = new ArrayList<>();
        Stream<String> stringStream = list.stream();
        //通过Arrays数组创建流
        String[] strArr = new String[10];
        Stream<String> streams = Arrays.stream(strArr);
        //通过stream中的静态方法of创建流
        Stream<String> strStream = Stream.of("11" , "22" , "33");
        //创建无限流
        Stream<Integer> noLimitStream = Stream.iterate(0,(x) -> x + 2);
        //终端流
        //noLimitStream.forEach(System.out::println);
        //终止流操作使得产生10个流
        noLimitStream.limit(10).forEach(System.out::println);
    }
    //生成的方式创建流
    @Test
    public void test2(){
        Stream<Double> streams = Stream.generate(() -> Math.random());
        streams.limit(5).forEach(System.out::println);
    }

中间操作

• filter
• limit
• skip
• distinct
• map
• flatMap
• sorted排序
  -自然排序sorted()
  -定制排序sorted(comparator com）
  filter

	List<Emp> empList = Arrays.asList(
            new Emp("wpzhang" , 23 , "w" , 6666),
            new Emp("zl" , 24 , "w" , 8888),
            new Emp("zw" , 23 , "m" , 9999),
            new Emp("hch" , 27 , "m" , 10000),
            new Emp("wyy" , 28 , "m" , 15000),
            new Emp("wyy" , 28 , "m" , 15000)
    );
    //中间操作
    //filter
    @Test
    public void operate(){
        //中间操作  根本不会执行
        Stream<Emp> s = empList.stream()
                .filter((e) ->{
                    return  e.getAge() < 30;
                });
        //终止操作 有终止操作才会执行
        s.forEach(System.out::println);
    }

limit

   //中间操作limit
    @Test
    public void limitTest(){
        Stream<Emp> s = empList.stream()
                .filter((e) -> e.getSalary() > 8888)
                .limit(1);//一旦发现满足条件的一条数据以后，不再进行后续的操作，叫做短路
        s.forEach(System.out::println);
    }

skip

 	//中间操作skip :跳过结果的前三个，取第四个及以后的
    @Test
    public void skipTest(){
        empList.stream()
                .filter((e) -> e.getSalary() > 6666)
                .skip(3)
                .forEach(System.out::println);
    }

distinct

    //中间操作distinct:通过hashCode 和 equals方法实现的去重
    @Test
    public void distinctTest(){
        empList.stream()
                .distinct()
                .forEach(System.out::println);
    }

map

    //中间操作map映射
    @Test
    public void mapTest(){
        empList.stream()
                .map(Emp::getName)
                .forEach(System.out::println);
    }

flatMap

    @Test
    public void mapTest2(){
       List<String> strList = Arrays.asList("aa" , "bb" , "cc" ,"dd");
       //flatMap接受一个函数作为参数，将函数中每一个值作为一个流， 最后将流连接在一起返回
        //flatMap将每一个元素添加到流中
         strList.stream()
                .flatMap(BetweenOperation::filterCharacter)
                .forEach(System.out::println);//{a,a,a,b,b,b}
    }
    public static Stream<Character> filterCharacter(String str){
        List<Character> charList = new ArrayList<>();
        for (Character c : str.toCharArray()){
            charList.add(c);
        }
        return charList.stream();
    }

sort

    @Test
    public void sortTest(){
        //自然排序
        List<String> strList = Arrays.asList("a" , "b" , "z" ,"e");
        strList.stream()
                .sorted()
                .forEach(System.out::println);
        //定制排序
        empList.stream()
                .sorted((e1 , e2) ->{
                    if (e1.getAge() == e2.getAge()){
                        return e1.getName().compareTo(e2.getName());
                    }else{
                        return e1.getAge()-e2.getAge();
                    }
                }).forEach(System.out::println);
    }

终端操作

• allMatch 是否匹配所有元素
• anyMatch 是否至少匹配一个元素
• noneMatch 检查是否没有匹配所有元素
• findFirst 返回第一个元素
• findAny 返回当前流中任意一个元素
• count 返回当前流中元素的个数
• max 返回当前流中的最大值
• min 返回当前流中最小值
• reduce() 可以将流中元素反复结合起来，返回一个Optional
• collect 收集

public class TerminalOperation {
    List<Emp> empList = Arrays.asList(
            new Emp("wpzhang", 23, "w", 6666),
            new Emp("zl", 24, "w", 8888),
            new Emp("zw", 23, "m", 9999),
            new Emp("hch", 27, "m", 10000),
            new Emp("wyy", 28, "m", 15000),
            new Emp("wyy", 28, "m", 15000)
    );
    List<String> strList = Arrays.asList("aa", "bb", "cc", "bb", "ee", "bb", "dd");

    @Test
    public void test1() {
        //allMatch
        if (strList.stream().allMatch((str) -> !str.startsWith("!"))) {
            System.out.println("不以！”开头");
        }
        //anyMatch
        if (strList.stream().anyMatch((str) -> str.startsWith("a"))) {
            System.out.println("有一个以a开头的");
        }
        //noneMatch
        if (strList.stream().noneMatch((str) -> str.startsWith("g"))) {
            System.out.println("全部都不匹配！");
        }
        //findFirst返回第一个元素
        Optional<String> op = strList.stream().findFirst();
        String result = op.get();
        System.out.println("result:" + result);
        //findAny返回当前流中的任意一个元素
        //使用并行流查找任意元素
        Optional<String> result2 = strList.parallelStream().findAny();
        System.out.println("result2:"+result2.get());
        //count
        Long count = strList.stream().count();
        System.out.println("count:" + count);
        //max/min
        Optional<String> op2 = strList.stream().max((e1, e2) -> e1.compareTo(e2));
        System.out.println("result3：" + op2.get());
        //reduce 归约
        List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer intResult = numList.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println("intList:" + intResult);
        Optional<Double> empOptional = empList.stream()
                .map(Emp::getSalary)//提取出工资
                .reduce(Double::sum);//类::静态方法
        System.out.println("empOptional:" + empOptional.get());
        //collect
        //收集所有名字
        List<String> nameList = empList.stream()
                .map(Emp::getName)
                .collect(Collectors.toList());
        System.out.println("nameList:" + nameList);
        //收集名字到Set中
        Set<String> set = empList.stream()
                                .map(Emp::getName)
                                .collect(Collectors.toSet());
        System.out.println("set:"+set);
        //收集名字到hashset中
        HashSet<String> nameSet = empList.stream()
                                        .map(Emp::getName)
                                        .collect(Collectors.toCollection(HashSet::new));
        System.out.println("nameSet:"+nameSet);
        //收集名字到LinkedHashSet中 存储有序且不重复
        LinkedHashSet<String> nameSortedSet = empList.stream()
                                                    .map(Emp::getName)
                                                    .collect(Collectors.toCollection(LinkedHashSet::new));
        System.out.println("LinkedHashSet:"+nameSortedSet);
    }
}