Stream流

forEach方法,用来遍历流中的数据
是一个终结方法,遍历之后就不能继续调用Stream流中的其他方法

		//获取一个Stream流
        Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "田七");
        //使用Stream流中的方法forEach对Stream流中的数据进行遍历
        stream.forEach(name -> System.out.println(name));

Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤
Stream filter(Predicate predicate);
filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤
Predicate中的抽象方法:
boolean test(T t);

		//创建一个Stream流
        Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //对Stream流中的元素进行过滤,只要姓张的人
        Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
        //遍历stream2流
        stream2.forEach(name -> System.out.println(name));

        /*
            Stream流属于管道流,只能被消费(使用)一次
            第一个Stream流调用完毕方法,数据就会流转到下一个Stream上
            而这时第一个Stream流已经使用完毕,就会关闭了
            所以第一个Stream流就不能再调用方法了
            IllegalStateException: stream has already been operated upon or closed
         */
        //遍历stream流
        stream.forEach(name -> System.out.println(name));

Stream流中的常用方法_map:用于类型转换
如果需要将流中的元素映射到另一个流中，可以使用map方法.
Stream map(Function mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
Function中的抽象方法:
R apply(T t);

//获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1", "2", "3", "4");
        //使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
        stream.map(s -> Integer.parseInt(s)).forEach(i -> System.out.println(i));

Stream流中的常用方法_count:用于统计Stream流中元素的个数
long count();
count方法是一个终结方法,返回值是一个long类型的整数
所以不能再继续调用Stream流中的其他方法了

		ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        //获取一个Stream流，统计元素个数
        long count = list.stream().count(); // count野心很大
        System.out.println(count);

Stream流的收集方法
R collect(Collector collector)

它是通过工具类Collectors提供了具体的收集方式
    public static  Collector toList()：把元素收集到List集合中
    public static  Collector toSet()：把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中

//创建List集合对象
     List<String> list = new ArrayList<String>();
     list.add("林青霞");
     list.add("张曼玉");
     list.add("王祖贤");
     list.add("柳岩");

     //需求1：得到名字为3个字的流
     Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

     //需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
     List<String> names = listStream.collect(Collectors.toList());
     for (String name : names) {
         System.out.println(name);
     }

     //创建Set集合对象
     Set<Integer> set = new HashSet<Integer>();
     set.add(10);
     set.add(20);
     set.add(30);
     set.add(33);
     set.add(35);

     //需求3：得到年龄大于25的流
     Stream<Integer> setStream = set.stream().filter(age -> age > 25);

     //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
     Set<Integer> ages = setStream.collect(Collectors.toSet());
     for (Integer age : ages) {
         System.out.println(age);
     }

     //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
     String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

     //需求5：得到字符串中年龄数据大于28的流
     Stream<String> arrayStream = Stream.of(strArray).filter(
             s -> Integer.parseInt(s.split(",")[1]) > 28);

     //需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
     Map<String, Integer> map = arrayStream.collect(Collectors.toMap(
             s -> s.split(",")[0],
             s -> Integer.parseInt(s.split(",")[1])
     ));
     Set<String> keySet = map.keySet();
     for (String key : keySet) {
         System.out.println(key + ",," + map.get(key));
     }

Stream流中的常用方法_skip:用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
Stream skip(long n);
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

//获取一个Stream流
        String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
        Stream<String> stream = Stream.of(arr);
        //使用skip方法跳过前3个元素
        stream.skip(3).forEach(name -> System.out.println(name));

Stream流中的常用方法_concat:用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
static Stream concat(Stream a, Stream b)

		//创建一个Stream流
        Stream<String> stream1 = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
        //获取一个Stream流
        String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
        Stream<String> stream2 = Stream.of(arr);
        //把以上两个流组合为一个流
        Stream.concat(stream1, stream2).forEach(name -> System.out.println(name));