Stream流的常用方法

Stream流属于管道流，只能被消费（使用）一次

第一个Stream流调用完毕方法，数据就会流转到下一个Stream上

而这时第一个Stream流已经使用完毕，就会关闭了。

所以第一个Stream流就不能再调用方法了。

IllegalStateException:Stream has already been operated upon or closed

映射：map

如果需要将流中的元素映射到另一个流中，可以使用map方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

复习Function接口

此前已经学习过java.util.stream.Function函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成为R类型，而这种转换的动作，就成为“映射”。

package day16;

import java.util.stream.Stream;

public class Demo01 {
    public static void main(String[] args) {
        //获取一个String类型的Stream流
        Stream<String> stream = Stream.of("1","2","3","4");
        //使用map方法，把字符串类型的证书，转换（映射）为Integer类型的整数
        Stream<Integer> stream2 = stream.map((String s)->{
            return Integer.parseInt(s);
        });
        //遍历Stream2流
        stream2.forEach(i -> System.out.println(i));
    }
}

统计个数：count

Stream流中的常用方法_count:用于统计Stream流中元素的个数。

long count();

count方法是一个终结方法，返回值是一个Long类型的整数。

所以不能再继续调用Stream流中的其他方法了。

package day16;

import java.util.ArrayList;
import java.util.stream.Stream;

public class Stream_Count {
    public static void main(String[] args) {
        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<Integer> stream = list.stream();
        long count = stream.count();
        System.out.println(count);
    }
}

取用前几个：limit

limit方法可以对流进行截取，只取用前几个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。

limit方法用于截取流中的元素

limit方法是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法。

package day16;

import java.util.stream.Stream;

public class Stream_limit {
    public static void main(String[] args) {
        //获取一个stream流
        Integer[] arr = {1,2,3,4,5,6,7};
        Stream<Integer> stream = Stream.of(arr);
        //使用Limit截取三个元素
        Stream<Integer> stream2 = stream.limit(3);
        //遍历结果
        stream2.forEach(name -> System.out.println(name));
    }
}

跳过前几个：skip

如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果当前流的长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

package day16;

import java.util.stream.Stream;

public class Stream_skip {
    public static void main(String[] args) {
        //获取一个stream流
        Integer[] arr = {1,2,3,4,5,6,7};
        Stream<Integer> stream = Stream.of(arr);
        //使用skip创建一个新流
        Stream<Integer> stream2 = stream.skip(3);
        //遍历stream2
        stream2.forEach(name -> System.out.println(name));
    }
}

组合：concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat:

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与java.lang.String 当中的concat 方法是不同。

package day16;

import java.util.stream.Stream;

public class Stream_concat {
    public static void main(String[] args) {
        //创建两个stream流
        Integer[] arr = {1,2,3,4,5};
        Integer[] arr2 = {6,7,8,9,0};
        Stream<Integer> stream = Stream.of(arr);
        Stream<Integer> stream2 = Stream.of(arr2);
        //使用concat方法组合两个流
        Stream<Integer> concat = Stream.concat(stream,stream2);
        //遍历concat
        concat.forEach(name -> System.out.println(name));
    }
}

练习：集合元素处理

题目：

现有两个ArrayList集合存储队伍当中的多个成员名字，要求使用stream流的方法一次完成下面的操作。

1. 第一个队伍只要名字为三个字的成员姓名：存储到一个新集合中。
2. 第一个队伍筛选之后只要前三个人；存储到一个新集合中
3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前两个人；存储到一个新集合中。
5. 将两个队伍合并成为一个队伍，存储到一个新集合中。
6. 根据姓名创建Person对象，存储到一个新集合中。
7. 打印整个队伍的Person对象信息。

package day16;

import java.util.ArrayList;
import java.util.stream.Stream;

public class 练习 {
    public static void main(String[] args) {
        //第一个队伍
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋冬野");
        one.add("苏星河");
        one.add("龙傲天");
        one.add("李星云");
        one.add("李煜");
        one.add("庄周");
        one.add("李白");
        one.add("项羽");
        one.add("李清照");
        //1. 第一个队伍只要名字为三个字的成员姓名：存储到一个新集合中。
        //2. 第一个队伍筛选之后只要前三个人；存储到一个新集合中
        Stream<String> oneStream = one.stream().filter(name -> name.length()==3).limit(3);

        //第二个队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张三丰");
        two.add("张无忌");
        two.add("上官纤云");
        two.add("弗拉基米尔");
        two.add("章鱼哥");
        two.add("海绵宝宝");
        two.add("李天然");
        //1. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        //2. 第二个队伍筛选之后不要前两个人；存储到一个新集合中。
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张00")).skip(2);
        //1. 将两个队伍合并成为一个队伍，存储到一个新集合中。
        //2. 根据姓名创建Person对象，存储到一个新集合中。
        //3. 打印整个队伍的Person对象信息。
        Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));
    }
}