天天看点
返回

Stream流简介

Stream流简介

说到Stream便容易想到I/O 流，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

集合的弊端:

​ 每一次筛选都需要定义一个新的集合来存储结果

​ 每一次操作集合中所有的元素都需要通过循环来遍历

Stream流简介

1.s流式思想概念

Stream流主要用于解决已有集合类库既有的弊端

整体来看，流式思想类似于工厂车间的“生产流水线”。

当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤方案，然后再按照方案去执行它。

Stream流简介

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

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

  • 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
  • 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。

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

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

  • Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

2.Stream特点

  1. Stream流一定得搭建好模型,才能执行(也就是说一定要有终结的方法,才会执行)。
  2. Stream流是单向的,不能重复使用。
  3. Stream流是有延迟性的,每一个操作延迟方法之后会得到一个新的流,除了终结的方法。
  4. Stream流不能存储数据。
  5. Stream流不会更改数据源。

3.使用stream流

Stream流的使用步骤: 获取流—>调用延迟方法—>调用终结方法

Stream流简介
3.1获取流

java.util.stream.Stream<T>

是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）

获取一个流非常简单，有以下几种常用的方式：

获取一个流非常简单，有以下几种常用的方式：

  1. 所有的

    Collection

     集合都可以通过

    stream

     默认方法获取流；

  2. Stream

     接口的静态方法

    of

     可以获取数组对应的流。

根据Collection获取流

首先，

java.util.Collection

接口中加入了default方法

stream

用来获取流，所以其所有实现类均可获取流。

代码演示:

import java.util.*;
import java.util.stream.Stream;

public class Demo04GetStream {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // ...
        Stream<String> stream1 = list.stream();

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

        Vector<String> vector = new Vector<>();
        // ...
        Stream<String> stream3 = vector.stream();
    }
}

根据Map获取流

java.util.Map

接口不是

Collection

的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：

代码演示:

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class Demo05GetStream {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        // 通过map集合的keyset()方法获取键的set集合进而获取流
        Stream<String> keyStream = map.keySet().stream();
        //通过map集合的values()方法获取值的set集合进而获取流
        Stream<String> valueStream = map.values().stream();
        //通过map集合的entrySet()方法获取的entry键值对对象的set集合进而获取流
        Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
    }
}

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以

Stream

接口中提供了静态方法

of

，使用很简单：

代码演示:

import java.util.stream.Stream;

public class Demo06GetStream {
    public static void main(String[] args) {
        String[] array = { "钢铁侠", "绿巨人", "美国队长", "雷神" };
        Stream<String> stream = Stream.of(array);
    }
}

备注:

of

方法的参数其实是一个可变参数，所以支持数组。

4.Stream流中常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

  • 终结方法：返回值类型不再是

    Stream

     接口自身类型的方法，因此不再支持类似

    StringBuilder

     那样的链式调用。本小节中，终结方法包括

    count

     和

    forEach

     方法。
  • 延迟方法：返回值类型仍然是

    Stream

     接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
    备注：本小节之外的更多方法，请自行参考API文档。
4.1.过滤：filter

可以通过

filter

方法将一个流转换成另一个子集流。方法签名：

该接口接收一个

Predicate

函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

Stream流简介
4.2.统计个数：count

正如旧集合

Collection

当中的

size

方法一样，流提供

count

方法来数一数其中的元素个数。

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。

4.3.取用前几个：limit

limit

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

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

Stream流简介
4.4.跳过前几个：skip

如果希望跳过前几个元素，可以使用

skip

方法获取一个截取之后的新流：

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

Stream流简介
4.5.映射：map

如果需要将流中的元素映射到另一个流中，可以使用

map

方法。方法签名：

该接口需要一个

Function

函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。

Stream流简介
4.6.组合：concat

如果有两个流，希望合并成为一个流，那么可以使用

Stream

接口的静态方法

concat

：

备注：这是一个静态方法，与

java.lang.String

 当中的

concat

 方法是不同的。
4.7.逐一处理：forEach

虽然方法名字叫

forEach

，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的。

该方法接收一个

Consumer

接口函数，会将每一个流元素交给该函数进行处理

5.集合元素处理对比

需求:

现在有两个

ArrayList

集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下若干操作步骤：

  1. 第一个队伍只要名字为3个字的成员姓名；
  2. 第一个队伍筛选之后只要前3个人；
  3. 第二个队伍只要姓张的成员姓名；
  4. 第二个队伍筛选之后不要前2个人；
  5. 将两个队伍合并为一个队伍；
  6. 根据姓名创建

    Person

     对象；
  7. 打印整个队伍的Person对象信息。

两个队伍（集合）的代码如下：

public class DemoArrayListNames {
    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("洪七公");

        //第二支队伍
        ArrayList<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
		// ....
    }
}

Person

类的代码为：

public class Person {
    
    private String name;

    public Person() {}

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
5.1传统方法处理

使用传统for循环,代码如下 :

public class DemoArrayListNames {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        // ...

        List<String> two = new ArrayList<>();
        // ...

        // 第一个队伍只要名字为3个字的成员姓名；
        List<String> oneA = new ArrayList<>();
        for (String name : one) {
            if (name.length() == 3) {
                oneA.add(name);
            }
        }

        // 第一个队伍筛选之后只要前3个人；
        List<String> oneB = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            oneB.add(oneA.get(i));
        }

        // 第二个队伍只要姓张的成员姓名；
        List<String> twoA = new ArrayList<>();
        for (String name : two) {
            if (name.startsWith("张")) {
                twoA.add(name);
            }
        }

        // 第二个队伍筛选之后不要前2个人；
        List<String> twoB = new ArrayList<>();
        for (int i = 2; i < twoA.size(); i++) {
            twoB.add(twoA.get(i));
        }

        // 将两个队伍合并为一个队伍；
        List<String> totalNames = new ArrayList<>();
        totalNames.addAll(oneB);
        totalNames.addAll(twoB);

        // 根据姓名创建Person对象；
        List<Person> totalPersonList = new ArrayList<>();
        for (String name : totalNames) {
            totalPersonList.add(new Person(name));
        }

        // 打印整个队伍的Person对象信息。
        for (Person person : totalPersonList) {
            System.out.println(person);
        }
    }
}

运行结果:

Person{name='宋远桥'}
Person{name='苏星河'}
Person{name='石破天'}
Person{name='张天爱'}
Person{name='张二狗'}
5.2使用stream流 处理

等效的Stream流式处理代码为：

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

public class DemoStreamNames {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        // ...

        List<String> two = new ArrayList<>();
        // ...

        // 第一个队伍只要名字为3个字的成员姓名；
        // 第一个队伍筛选之后只要前3个人；
        Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);

        // 第二个队伍只要姓张的成员姓名；
        // 第二个队伍筛选之后不要前2个人；
        Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);

        // 将两个队伍合并为一个队伍；
        // 根据姓名创建Person对象；
        // 打印整个队伍的Person对象信息。
        Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
    }
}

小结:

1. Stream流一定得搭建好模型,才能执行(也就是说一定要有终结的方法,才会执行)。
2. Stream流是单向的,不能重复使用。
3. Stream流是有延迟性的,每一个操作延迟方法之后会得到一个新的流,除了终结的方法。
4. Stream流不能存储数据。
5. Stream流不会更改数据源。
java基础 stream流
上一篇: Mac Monterey 12.3 brew install openresty
下一篇: java中stream流使用分享

继续阅读