Stream流的常用方法

前言

介绍

Stream 将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

特点

• stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
• stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
• stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

 常用方法

1、forEach

forEach接收消费类型的函数式接口，为Stream流的最终方法，调用后不能再调用Stream流的其它方法了

若只有一个参数则可以省略()

参数的类型也可省略，java编译器会自动推断参数类型

若方法体只有一行代码则可以省略{}

@Test
public void test1() {
    Stream<String> st = Stream.of("张三","李四","王五","赵六","田七");
    st.forEach((String name) -> {
        System.out.println(name);
    });
}

@Test
public void test2() {
    Stream<String> st = Stream.of("张三","李四","王五","赵六","田七");
    st.forEach(name -> System.out.println(name));
}

2、filter

过滤，延迟方法，接收判断类型的函数式接口，产生新的子集流，调用后还可以继续调用其它的Stream流方法

若写了{}则必须用return返回结果

若省略了{}则不需要return返回结果

@Test
public void test1() {
    // 原始Stream流
    Stream<String> st1 = Stream.of("张三","张无忌","赵敏","张三丰","周芷若");
    // 过滤后会产生一个新的子集流
    Stream<String> st2 = st1.filter((String name) -> {
        return name.startsWith("张") && name.length() == 3;
    });
    st2.forEach(name -> System.out.println(name));
}

@Test
public void test2() {
    // 原始Stream流
    Stream<String> st1 = Stream.of("张三","张无忌","赵敏","张三丰","周芷若");
    // 过滤后会产生一个新的子集流
    Stream<String> st2 = st1.filter(name -> name.startsWith("张") && name.length() == 3);
    st2.forEach(name -> System.out.println(name));
}

3、map

延迟方法，操作Stream流数据中的每个元素，将Stream流映射到一个新的Stream流上

操作数据中的每个元素，改变该元素的值或者类型等等

@Test
public void test1() {
    Stream<String> st1 = Stream.of("a","b","c","d","e");
    // 操作数据中的每个元素，返回新的元素
    // 方法体只有一行时，可省略{}和return
    st1.map(str -> str += str.toUpperCase())
            .forEach(str -> System.out.println(str));
}

@Test
public void test2() {
    Stream<String> st1 = Stream.of("a","b","c","d","e");
    // 操作数据中的每个元素，返回新的元素
    // 方法体有{}时必须加上return
    st1.map(str -> {
        return str += str.toUpperCase();
    }).forEach(str -> System.out.println(str));
}

@Test
public void test3() {
    Stream<String> st1 = Stream.of("1","2","3","4","5");
    // 操作数据中的每个元素，将每个元素转为Integer类型
    Stream<Integer> st2 = st1.map(str -> Integer.parseInt(str));
    st2.forEach(num -> System.out.println(num.getClass()));
}

4、count

最终方法，没有参数，没有方法体，属于Stream流的最终方法，用于统计Stream流中的数据长度，返回long类型

@Test
public void test4() {
    // count方法属于Stream流的最终方法，统计数据的长度，返回long类型
    Stream<String> st1 = Stream.of("1","2","3","4","5");
    long ct = st1.map(str -> Integer.parseInt(str))
            .filter(num -> num > 3)
            .count();
    System.out.println(ct);
}

5、limit

延迟方法，截取Stream流中的前几个元素返回新的Stream流，入参为long类型，没有方法体

若入参的值大于Stream流中的数据的长度则返回由原数据组成的新Stream流

@Test
public void test1() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    st1.limit(3).forEach(str -> System.out.println(str));
}

6、skip

延迟方法，入参为long类型，没有方法体，跳过前一个Stream流的前几个元素，得到由后面的元素组成的新Stream流

@Test
public void test2() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    st1.skip(2).forEach(str -> System.out.println(str));
}

若跳过的元素个数>=Stream流数据的长度则会得到一个元素个数为0的空流

@Test
public void test2() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    long ct = st1.skip(6).count();
    System.out.println(ct);
}

7、concat

Stream的静态方法，将多个Stream流的数据按入参顺序合并为一个新的Stream流

@Test
public void test3() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    Stream<String> st2 = Stream.of("AA","BB","CC","DD","EE");
    Stream<String> st3 = Stream.concat(st1,st2);
    st3.forEach(s -> System.out.println(s));
}