java8新特性

函数式接口

1、概念：
使用功能性接口作为函数的参数，Lambda表达式协助实现函数功能。
2、功能性接口分类：
消费式接口，提供式接口，函数式接口，断言式接口
3、消费式接口

import java.util.function.Consumer;

public class Demo4_消费式接口 {

    public static void main(String[] args) {
        method(x -> System.out.println("每月消费" + x + "元在生活上"), 5000);
    }

    public static void method(Consumer<Integer> cons, Integer money) {
        //消费式接口，提供了accept抽象方法，接受一个参数
        cons.accept(money);
    }
}

4、提供式接口

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

public class Demo5_提供式接口 {

    public static void main(String[] args) {
        //需求：生成n个随机值(1~10)到集合中
        List<Integer> method = method(() -> new Random().nextInt(10) + 1, 5);
        System.out.println(method);//[3, 1, 9, 1, 2]
    }

    public static List<Integer> method(Supplier<Integer> sup, int num) {
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= num; i++) {
            Integer integer = sup.get();
            list.add(integer);
        }
        return list;
    }
}

5、函数式接口

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public class Demo6_函数式接口 {

    public static void main(String[] args) {
        //需求：对字符串去除左右空格
        List<String> list = new ArrayList();
        list.add("abc");
        list.add(" bbc");
        list.add("ccd  ");

        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            String method = method(x -> x.trim(), s);
            list.set(i, method);
        }

        System.out.println(list);

    }

    public static String method(Function<String, String> fun, String s) {
        String apply = fun.apply(s);
        return apply;
    }
}

6、断言式接口

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;

public class Demo7_断言式接口 {

    public static void main(String[] args) {
        //使用集合存储字符串长度大于3的元素
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"cba","wahaha","ujiuye","offcn");
        List<String> method = method(x -> x.length() > 3, list);
        System.out.println(method);//[wahaha, ujiuye, offcn]
    }

    public static List<String> method(Predicate<String> pred, List<String> list) {
        List<String> arr = new ArrayList<>();
        for (String s : list) {
            if (pred.test(s)) {
                arr.add(s);
            }
        }
        return arr;
    }
}

Stream类API

1、API介绍

2、获取该接口实现类的方式
(1)通过Collection集合获取
(2)通过Map集合获取
(3)通过数组/Stream类获取

import com.sun.javafx.collections.MappingChange;

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

public class Demo8_Stream {

    public static void main(String[] args) {
        //Collection获取Stream对象
        Collection<Integer> col = new ArrayList();
        col.add(10);
        col.add(20);
        col.add(30);

        //.stream()方法
        Stream<Integer> stream = col.stream();
        System.out.println(stream);//java.util.stream.ReferencePipeline$Head@511d50c0

        //Map
        Map<String, String> map = new HashMap<>();
        map.put("cn", "china");
        map.put("us", "america");
        //1、通过keySet获取键一系列元素，再通过stream()获取Stream对象
        Set<String> keys = map.keySet();
        Stream<String> s = keys.stream();
        System.out.println(s);
        //2、通过values获取值一系列元素，再通过stream()获取Stream对象
        Collection<String> values = map.values();
        Stream<String> ss = values.stream();
        System.out.println(ss);
        //3、通过valentrySet获取Entry一系列元素，再通过stream()获取Stream对象
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Stream<Map.Entry<String, String>> sss = entries.stream();
        System.out.println(sss);

        //数组，多个元素获取
        Integer[] arr = {1, 2, 3, 4, 5};
        //Arrays.stream(数组) 获取Stream类对象
        Stream<Integer> stream1 = Arrays.stream(arr);
        System.out.println(stream1);

        //Stream.of(T... t) 获取Stream类对象
        Stream<Integer> stream2 = Stream.of(arr);
        System.out.println(stream2);

        Stream<String> stream3 = Stream.of("abc", "bbb", "ccb");
        System.out.println(stream3);
    }
}

(4)常用终结功能方法

import com.sun.javafx.collections.MappingChange;

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

public class Demo8_Stream {

    public static void main(String[] args) {
        //Stream终结方法：调用终结方法后，流被关闭，无法继续使用。
        Collection<Integer> col = new ArrayList();
        col.add(10);
        col.add(20);
        col.add(30);

        Stream<Integer> stream = col.stream();

        //.forEach(x-> System.out.println(x)) 遍历Stream中的每个元素，将元素输出到控制台。
        //stream.forEach(x-> System.out.println(x));

        //.count() 获取Stream中的元素个数
        System.out.println(stream.count());//java.lang.IllegalStateException: stream has already been operated upon or closed
    }
}

(5)常用延迟功能方法

import com.sun.javafx.collections.MappingChange;

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

public class Demo8_Stream {

    public static void main(String[] args) {
        //Stream中的延迟方法：Stream调用该方法后，流不会被关闭，还可以继续使用。
        Collection<Integer> col = new ArrayList();
        col.add(10);
        col.add(20);
        col.add(30);

        Stream<Integer> stream = col.stream();
        //limit(long) 获取Stream前n位元素
        //stream.limit(2).forEach(x -> System.out.println(x));

        //skip(long) 跳过Stream前n位元素
        //Stream<Integer> skip = stream.skip(2);
        //skip.forEach(x-> System.out.println(x));

        //filter(Predicate) 根据条件过滤Stream的元素
        stream.filter(x -> x >= 20).forEach(x -> System.out.println(x));

        Collection<String> col2 = new ArrayList();
        col2.add("abc");
        col2.add(" bbc");
        col2.add("ccd ");

        Stream<String> stream2 = col2.stream();

        //map() 对Stream类中元素执行相同方法
        stream2.map(x->x.trim()).forEach(x-> System.out.println(x));
    }
}