8.JDK8新特性Stream流

一.什么是 Stream 流

Java8开始，得益于Lambda所带来的函数式编程，引入一个全新的Stream概念，用于解决已有集合类库的弊端。

1. Stream（流）是一个来自数据源的元素队列并支持聚合操作
   • 元素：特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
   • 数据源：流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
   • 聚合操作：类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。
2. 和以前的Collection操作不同， Stream操作还有两个基础的特征：
   • Pipelining： 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
   • 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

二.传统方式与Stream流对比

1.传统方式：

public class Demo01List {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        //传统方式：找出姓张，姓名长度大于2的人，左后打印出来
        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                listA.add(s);
            }
        }

        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if (s.length() > 2) {
                listB.add(s);
            }
        }

        for (String s : listB) {
            System.out.println(s);
        }

    }
}

结果：

张无忌
张三丰

2.使用Stream流的方式：

public class Demo01Stream {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        //Stream流的方式：找出姓张，姓名长度大于2的人，左后打印出来
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()>2)
                .forEach(name-> System.out.println(name));

    }
}

结果：

张无忌
张三丰

结论：大大简化了代码

三.获取Stream流的两种方式

• 将集合转换为Stream流（只对单列集合）：
  • default Stream<E> stream()
将数组转换为Stream流:
• static <T> Stream<T> of(T... values)

public class Demo01GetStream {

    public static void main(String[] args) {

        //1.将集合转换为Stream流
        //List
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

        //Map
        Map<String,String> map = new HashMap<>();
        //获取键转换为Stream流
        Set<String> keyset = map.keySet();
        Stream<String> stream3 = keyset.stream();
        //获取值转换为Stream流
        Collection<String> values = map.values();
        Stream<String> stream4 = values.stream();
        //获取键值对的映射关系entrySet转换为Stream流
        Set<Map.Entry<String,String>> entries = map.entrySet();
        Stream<Map.Entry<String,String>> stream5 = entries.stream();

        //2.将数组转换为Stream流
        //可变参数
        Stream<Integer> stream6 = Stream.of(1,2,3,4,5);
        //固定数组
        Integer[] arr = {1,2,3,4,5};
        Stream<Integer> stream7 = Stream.of(arr);

    }
}

四.Stream流中的常用方法

常用方法分为两种类型：

• 延迟方法：返回类型仍然是Stream接口自身类型的方法，支持链式调用（除了终结方法外，都是延迟方法）
• 终结方法：返回类型不再是Stream接口自身类型的方法，因此不能链式调用了，中介方法包括count和forEach方法。

1.终结方法：

逐一处理：forEach

• void forEach(consumer<? super T> action)：该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。（终结方法）

public class StreamTest {

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

        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream().forEach((name)-> System.out.println(name));

        /**
         * 输出：
         * 张无忌
         * 周芷若
         * 赵敏
         * 张强
         * 张三丰
         */
    }
}

统计个数方法：count

• long count()：统计流中元素的个数。（终结方法）

public class StreamTest {

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

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        System.out.println(list.stream().count());

        /**
         * 输出：
         * 5
         */
    }
}

2.延迟方法：

过滤：filter

• Stream<T> filter(Predicate<? super T> predicate)：可以通过filter方法将一个流转换成另一个子集流。

• 注意：不会修改原来集合，而是会新生成一个集合

public class StreamTest {

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

        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        list.stream().filter((name) -> name.startsWith("张")).forEach((name) -> System.out.println(name));

        System.out.println("---------------");
        for (String s : list) {
            System.out.println(s);
        }
        /**
         * 输出：
         * 张无忌
         * 张强
         * 张三丰
         * ---------------
         * 张无忌
         * 周芷若
         * 赵敏
         * 张强
         * 张三丰
         */
    }
}

注意：

Stream流特点：

• Stream流属于管道流，只能被消费一次。
• 前一个Stream流执行完毕，数据会传递给下一个流。这样前一个流就会关闭不能在对前一个流调用方法了。
• 报错：java.lang.IllegalStateException: stream has already been operated upon or closed

public class StreamTest {

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

        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");

        Stream<String> stream1 = list.stream();
        Stream<String> stream2 = stream1.filter((name) -> name.startsWith("张"));
        stream2.forEach((name) -> System.out.println(name));

        //报错：java.lang.IllegalStateException: stream has already been operated upon or closed
        //报错原因是stream1已经被使用过了
        Stream<String> stream3 = stream1.filter((name) -> name.length() > 2);
        stream3.forEach((name) -> System.out.println(name));

        //报错原因stream2已经被使用过了
        stream2.forEach((name) -> System.out.println("--" + name));
    }
}

映射：map

• <R> Stream<R> map(Function<? super T, ? extends R> mapper)：将一个流映射到另一个流中（将类型T转换为类型R）

public class StreamTest {

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

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        list.stream().map((s) -> Integer.parseInt(s)).forEach((i) -> System.out.println(i));

        /**
         * 输出：
         * 1
         * 2
         * 3
         * 4
         * 5
         */
    }
}

取用前几个元素：limit

• Stream<T> limit(long maxSize)：对流进行截取，只取用前几个元素。

public class StreamTest {

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

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        list.stream().limit(3).forEach((s) -> System.out.println(s));

        /**
         * 输出：
         * 1
         * 2
         * 3
         */
    }
}

跳过前几个元素：skip

• Stream<T> skip(long n)：跳过流的前几个元素，剩下的元素生成新流。

public class StreamTest {

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

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        list.stream().skip(3).forEach((s) -> System.out.println(s));

        /**
         * 输出：
         * 4
         * 5
         */
    }
}

组合：concat

• public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)：Stream类中的静态方法，将两个流合并为一个新的流使用。

public class StreamTest {

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

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");

        Stream<String> stream1 = list.stream().limit(2);
        Stream<String> stream2 = list.stream().skip(3);

        Stream.concat(stream1, stream2).forEach((s) -> System.out.println(s));

        /**
         * 输出：
         * 1
         * 2
         * 4
         * 5
         */
    }
}

补充：来自B站字母哥课堂

调试Stream流