Stream流

最新推荐文章于 2023-01-28 16:14:25 发布

heromps

最新推荐文章于 2023-01-28 16:14:25 发布

阅读量268

点赞数

分类专栏： java 文章标签： stream java

本文链接：https://blog.csdn.net/heromps/article/details/107674429

版权

java 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

Stream流

在java8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端

流式思想

整体来看，流式思想类似于工厂车间的“生产流水线”。当需要对多个元素进行操作的时候，考虑到性能及其便利性，先拼好一个“模型”步骤方案，然后再按照方案执行它

注意：Stream流其实就是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）

Stream流是一个来自于数据源的元素队列

元素是特定类型的对象，形成一个队列。java中的stream并不会存储元素，而是按需计算
数据流的来源，可以是集合，数组等

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

Pipelining：中间操作都会返回流对象本身。多个操作可以串联成一个管道，如同流风格。这样做可以对操作进行优化，比如延迟执行和短路
内部迭代：以前对集合遍历是经过Iterator或者增强for的方式，显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方法，流可以直接调用遍历方法

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源

–>数据转换–>执行操作获取想要的结果–>每次转换原有Stream对象不改变，返回一个新的Stream对象，这就允许对其操作可以向链条一样排列，变成一个管道

获取流

java.util.stream.Stream<T>是java8新加入的最长用的流接口。获取一个流，有一下几种方法：

所有的Collection集合都可以通过stream默认方法获取流
stream接口的静态方法of可以获取数组相对应的流

根据Collection获取流

java.util.Collection接口中加入了default方法stream来获取流，其所有实现类均可获取流

根据Map获取流

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

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream接口中提供了静态方法 of ，使用很简单

常用方法

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

延迟方法：返回值方法仍然是Stream接口自身类型的方法，支持链式调用。（除了终结方法，其余方法均为延迟方法）
终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。
逐一处理：ForEach
- 该方法接收一个Consumer接口函数，会将每一个流元素交给函数进行处理

过滤：filter

可以通过filter方法把一个流转换成另一个子集流
该接口接收一个Predicate函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件，该方法会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的filter方法将会保留元素，为false，将会舍弃元素

基本使用

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
        Stream<String> stream = original.filter(s -> s.startsWith("张"));
        System.out.println(stream.count());
    }
}

映射：map

如果把流中的元素映射到另一个流中，可以使用map方法。该方法需要一个Function函数接口参数，可以将当前流中的T类型数据转换为另一种R类型的流

基本使用

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "20");
        //map方法通过方法引用，把string类型转化为int类型
        Stream<Integer> stream = original.map(s ->Integer.parseInt(s));
        System.out.println(stream.count());
    }
}

统计个数：count

该方法返回一个long值代表元素个数

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "20");
        //map方法通过方法引用，把string类型转化为int类型
        Stream<Integer> stream = original.map(s ->Integer.parseInt(s));
        System.out.println(stream.count());
    }
}

取用前几个：limit

limit方法可以对流进行截取，只取用前n个，参数是一个long行，如果集合当前长度大于参数则进行截取；否则不进行操作

基本使用

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "20");
        //map方法通过方法引用，把string类型转化为int类型
        Stream<Integer> stream = original.map(s ->Integer.parseInt(s)).limit(2);
        System.out.println(stream.count());
    }
}

跳过前几个：skip

如果希望跳过几个元素，可以使用skip方法获取一个截取之后的新流，如果当前流的长度大于n，则跳过前n个；否则会得到一个长度为0的空流

基本使用：

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> original = Stream.of("10", "12", "20");
        //map方法通过方法引用，把string类型转化为int类型
        Stream<Integer> stream = original.map(s ->Integer.parseInt(s)).skip(2);
        System.out.println(stream.count());
    }
}

组合：concat

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

基本使用

package demo.function;

import sun.lwawt.macosx.CThreading;

import java.util.stream.Stream;

public class DemoPredicate {
    public static void main(String[] args) {
        Stream<String> streamA = Stream.of("张无忌");
        Stream<String> streamB = Stream.of("张翠山");
        Stream<String> stream = Stream.concat(streamA, streamB); 
        System.out.println(stream.count());
    }
}

练习：集合元素处理（传统方式）

题目

现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以下若干操作步骤：
- 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
- 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
- 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
- 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
- 将两个队伍合并为一个队伍；存储到一个新集合中。
- 根据姓名创建 Person 对象；存储到一个新集合中。
- 打印整个队伍的Person对象信息。

两支队伍集合代码如下：

package demo.function;

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<String>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //第二支队伍
        ArrayList<String> two = new ArrayList<String>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
    }
}

Person类代码：

package demo.function;


public class Person {
    String name;

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

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

解答

使用传统for循环

package demo.function;

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<String>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //第二支队伍
        ArrayList<String> two = new ArrayList<String>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        /*
        1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
        2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
        3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
        5. 将两个队伍合并为一个队伍；存储到一个新集合中。
        6. 根据姓名创建 Person 对象；存储到一个新集合中。
        7. 打印整个队伍的Person对象信息。
         */
        ArrayList<String> oneA = new ArrayList<>();
        for (String s : one) {
            if(s.length()==3){
                oneA.add(s);
            }
        }
        ArrayList<String> oneB = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            oneB.add(oneA.get(i));
        }
        ArrayList<String> twoA = new ArrayList<>();
        for (String s : two) {
            if(s.startsWith("张")){
                twoA.add(s);
            }
        }
        ArrayList<String> twoB = new ArrayList<>();
        for (int i = 2; i < twoA.size(); i++) {
            twoB.add(twoA.get(i));
        }

        ArrayList<String> strings = new ArrayList<>();
        strings.addAll(oneB);
        strings.addAll(twoB);
        ArrayList<Person> people = new ArrayList<>();
        for (String string : strings) {
            people.add(new Person(string));
        }
        for (Person person : people) {
            System.out.println(person.toString());
        }
    }
}

练习：集合元素处理（Stream方式）

题目
- 将上一题中的传统for循环写法更换为Stream流处理方式。两个集合的初始内容不变，Person类的定义也不变

解答

等效的stream流处理

package demo.function;

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

public class ArrayListDemo {
    public static void main(String[] args) {
        //第一支队伍
        ArrayList<String> one = new ArrayList<String>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("石破天");
        one.add("石中玉");
        one.add("老子");
        one.add("庄子");
        one.add("洪七公");
        //第二支队伍
        ArrayList<String> two = new ArrayList<String>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖");
        two.add("张三丰");
        two.add("尼古拉斯赵四");
        two.add("张天爱");
        two.add("张二狗");
        /*
        1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
        2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
        3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
        4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
        5. 将两个队伍合并为一个队伍；存储到一个新集合中。
        6. 根据姓名创建 Person 对象；存储到一个新集合中。
        7. 打印整个队伍的Person对象信息。
         */
        Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
        Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
        Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
    }
}

heromps

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Stream流

Stream流在java8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端流式思想整体来看，流式思想类似于工厂车间的“生产流水线”。当需要对多个元素进行操作的时候，考虑到性能及其便利性，先拼好一个“模型”步骤方案，然后再按照方案执行它注意：Stream流其实就是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）Stream流是一个来自于数据源的元素队列元素是特定类型的对象，形成一个队列。jav
复制链接

扫一扫