JAVA基础---Stream流

Stream流出现背景

背景

在Java8之前，通常用 fori、for each 或者 Iterator 迭代来重排序合并数据，或者通过重新定义 Collections.sorts的 Comparator 方法来实现，这两种方式对 大数量系统来说，效率不理想。

Java8 中添加了一个新的接口类 Stream，相当于高级版的 Iterator，通过Lambda 表达式对集合进行各种非常便利、高效的聚合操作（Aggregate Operation），或者大批量数据操作 (Bulk Data Operation）。Stream不仅可以通过串行的方式实现数据操作，还可以通过并行的方式处理大批量数据，提高数据的处理效率。

解释

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

1. Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

   select * from user where age >30

   流水线：

   空瓶子--》灌水---》盖盖子--》贴标签 --->一瓶农夫三拳

2. Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

3. 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

4. 元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

什么是Stream流

Stream（流）是一个来自数据源的元素队列并支持聚合操作

1. <strong元素队列< strong="">元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。</strong元素队列<>

2. 数据源 流的来源。 可以是集合，数组，I/O channel（nio new IO非阻塞式IO）， 产生器generator 等。

3. 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

   和以前的Collection操作不同， Stream操作还有两个基础的特征：

4. Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。

5. 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

如何生成流

在 Java 8 中, 集合接口有两个方法来生成流：

stream() − 为集合创建串行流。

parallelStream() − 为集合创建并行流。

常用方法

for each(循环遍历)

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,-2,3,4,5,6,7,8);
        //for each
        list.stream().forEach(System.out::println);
        }
}

运行结果

map

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,-2,3,4,5,6,7,8);
        //for each
        list.stream().forEach(System.out::println);
        //list中的每个元素都乘以3然后再打印
        list.stream()
                .map(integer -> integer*3)//map表示对什么进行操作，箭头前面为数据，箭头后面为对数据进行的操作
                .forEach(System.out::println);
        }
}

运行结果

fliter

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,-2,3,4,5,6,7,8);
        //for each
        list.stream().forEach(System.out::println);
        //list中的每个元素都乘以3然后再打印
        list.stream()
                .map(integer -> integer*3)//map表示对什么进行操作，箭头前面为数据，箭头后面为对数据进行的操作
                .forEach(System.out::println);
        System.out.println("======================使用过滤器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>7)
                .forEach(System.out::println);
    }
}

运行结果

limit

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,-2,3,4,5,6,7,8);
        //for each
        list.stream().forEach(System.out::println);
        //list中的每个元素都乘以3然后再打印
        list.stream()
                .map(integer -> integer*3)//map表示对什么进行操作，箭头前面为数据，箭头后面为对数据进行的操作
                .forEach(System.out::println);
        System.out.println("======================使用过滤器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>7)
                .forEach(System.out::println);
        System.out.println("======================使用限制器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>7)
                .limit(3)//限制只输出3个元素(前三个)
                .forEach(System.out::println);
    }
}

运行结果

sorted

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> list= Arrays.asList(1,2,-2,3,4,5,6,7,8);
        //for each        list.stream().forEach(System.out::println);
        //list中的每个元素都乘以3然后再打印
        list.stream()
                .map(integer -> integer*3)//map表示对什么进行操作，箭头前面为数据，箭头后面为对数据进行的操作
                .forEach(System.out::println);
        System.out.println("======================使用过滤器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>7)
                .forEach(System.out::println);
        System.out.println("======================使用限制器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>7)
                .limit(3)//限制只输出3个元素(前三个)
                .forEach(System.out::println);
        System.out.println("======================使用排序器=============================");
        list.stream()
                .map(integer -> integer*2)
                .filter(integer -> integer>-100)
                .sorted()//默认从小到大排序
                .limit(6)//限制只输出3个元素(前三个)
                .forEach(System.out::println);
    }
}

运行结果

并行流与串行流

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：

Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

写在最后：流式编程是JAVA中一种很重要的编程思想，希望大家能够重视，这对提高代码效率十分有帮助。