一、Stream流生成方式

1、生成流

通过数据源（集合、数组）生成流

常见生成方式：

（1）Collection体系的集合可以使用默认方法stream()生成流

（2）Map体系的集合间接的生成流

（3）数组可以通过Stream接口的静态方法of(T…valus)生成流

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map体系间接生成流
        Map<String, Integer> map = new HashMap<>();
        Stream<String> mapkeyStream = map.keySet().stream();
        Stream<Integer> mapValueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组通过Stream接口的静态方法生成流
        String[] array = {"hello","world"};
        Stream<String> strStream = Stream.of(array);
        Stream<String> strStream2 = Stream.of("hello","world");
    }
}

2、中间操作

一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流

（1）Stream <T> filter(Predicate predicate)

对流中的数据进行过滤

public class StreamDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("甄嬛");
        list.add("华妃");
        list.add("沈眉庄");
        list.add("安陵容");
        list.add("甄玉娆");

        list.stream().filter(s -> s.startsWith("甄")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

（2）Stream <T>  limit(long maxSize)

返回此流中的元素组成的流，截取前指定参数个数的数据

（3）Stream <T>  skip(long n)

跳过指定参数个数的数据，返回由该流的剩余元素组成的流

        //把前三个元素输出
       list.stream().limit(3).forEach(System.out::println);
       System.out.println("-----------");

       //跳过3个元素，把剩下的输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("-----------");
        
        //跳过2个元素，把剩下的前2个输出
        list.stream().skip(2).limit(2).forEach(System.out::println);

（4）static Stream <T>  concat(Stream a, Stream b)

合并a和b两个流为一个流

（5）Stream <T> distinct()

返回由该流的不同元素组成的流，根据Object.equals(Object)方法判断

        //取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //跳过前2个元素组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //合并刚才得到的两个流，元素不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

（6）Stream <T> sorted()

         Stream <T> sorted(Comparator comparator)

返回由该流的元素组成的流，根据提供的comparator进行排序

//        list.stream().sorted().forEach(System.out::println);

//        list.stream().sorted((s1,s2)-> s1.length()-s2.length()).forEach(System.out::println);
        list.stream().sorted((s1,s2)->{
            int num1 = s1.length()-s2.length();
            int num2 = num1==0?s1.compareTo(s2):num1;
            return num2;
        }).forEach(System.out::println);

（7） Stream <T> map (Function mapper)

返回由给定函数应用于此流的元素的结果组成的流

（8） Stream <T> mapToInt (ToIntFunction mapper)

返回一个intStream其中包含将给定函数应用于此流的元素的结果

intStream：表示原始int流

ToIntFunciton：接口中的方法 int appltAsInt(T value)

        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //intStream特有方法 求和
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);

3、终结操作

一个流只能有一个终结操作，当这个操作执行后，流就被用完了，无法再被操作，所以这一定是流的最后一个操作。

（1）void forEach(Consumer action)

对此流的每个元素执行操作

（2）long count()

返回此流中的元素数

4、Stream的收集操作

（1）R collection(Collector collector)

收集方法的参数是一个collector接口

工具类collectors提供了具体的收集方式：

public static <T> Collector toList()：把元素收集到List集合中

public static <T> Collector toSet()：把元素收集到Set集合中

public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到Map中

        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
        List<String> names = listStream.collect(Collectors.toList());
        for(String name:names){
            System.out.println(name);
        }

        Stream<Integer> ageStream = set.stream().filter(i -> i > 25);
        Set<Integer> ages = ageStream.collect(Collectors.toSet());
        for(int age:ages){
            System.out.println(age);
        }

        String[] strArray = {"甄嬛,17","华妃,20","安陵容,17","眉庄,18","皇后,30"};
        //收集年龄小于等于18的
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) <= 18);
        //收集到Map中，姓名作为键，年龄作为值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
        //遍历
        Set<String> ketset = map.keySet();
        for(String key:ketset){
            Integer value = map.get(key);
            System.out.println(key+"："+value);
        }