java中jdk8新特性之一stream流的使用方式，常用方法，终结方法

最新推荐文章于 2024-07-07 20:33:00 发布
最新推荐文章于 2024-07-07 20:33:00 发布
阅读量142 收藏
点赞数 1
分类专栏： java技术成才之路 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64502989/article/details/134430753
版权

什么是stream？

也叫Stream流，是JDK8开始新增的一套API（java.util.stream.*）可以用于操作集合或者数组的数据。

优势：

Stream流大量结合了Lamdba表达式的语法风格来编程，提供了一套更加强大的，更加简单的方式操作集合或数组中的数据， 代码更加简洁，可读性更好。

 初体验Stream流：

需求：在一组list集合中把所有以张开头，且是3个字的元素存储到一个新的集合中

我们先不使用Stream流演示一下：

public static void main(String[] args) {

 List<String> names = new ArrayList<>();
        Collections.addAll(names,"无极","单独","范德萨","VS是否","孙子","孙尚香","孙纷纷");
        System.out.println(names);
        // 找出姓张，存入到一个信息的集合中
        ArrayList<String> list = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("孙") && name.length() == 3){
                list.add(name);
            }
        }
        System.out.println(list);

}

/** [无极, 单独, 范德萨, VS是否, 孙子, 孙尚香, 孙纷纷]
   * [孙尚香, 孙纷纷]
  *
  */

下面我们使用Stream流来完成这个需求：

public class StreamDemo1 {
public static void main(String[] args) {

 List <String> nameList = names.stream().filter(s -> s.startsWith("孙"))
            .filter(a -> a.length() == 3).collect(Collectors.toList());
        System.out.println(nameList);

}

// [孙尚香, 孙纷纷]

}

Stream流的使用步骤：

获取Stream流：
获取集合的Stream流：

获取list集合的stream流：


  public static void main(String[] args) {

         // 1 如何获取list集合的stream流
        ArrayList<String> names = new ArrayList<>();
        Collections.addAll(names,"无极","单独","范德萨","VS是否","孙子","孙尚香","孙方法");
        Stream<String> stream = names.stream();

}
如何获取set集合的stream流:

Set<String> set = new HashSet<>();
        Collections.addAll(set,"张德华","张信息","组织者","马德","德玛西亚");
        Stream<String> stream1 = set.stream();
        stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));

    /**
     * 张德华
     * 马德
     * 德玛西亚
     */
获取map集合的Stream流:

  Map<String,Double> map = new HashMap<>();
        map.put("迪丽热巴",171.4);
        map.put("古力娜扎",168.9);
        map.put("马尔科是",177.8);
        map.put("卡尔",173.4);
        Set<String> keys = map.keySet();
        Stream<String> kStream = keys.stream();
        Collection<Double> values = map.values();
        Stream<Double> allValues = values.stream();

//第二种方式：  示例：获取map集合中键值包含巴的人的信息
Set<Map.Entry<String, Double>> entries = map.entrySet();
        Stream<Map.Entry<String, Double>> kvs = entries.stream();
        kvs.filter(s -> s.getKey().contains("巴")).
                forEach(e -> System.out.println(e.getKey() + "--->" + e.getValue()));

//迪丽热巴--->171.4
获取数组的Stream流：



   String[] names2 = {"孙尚香","孙凤的","大山","多少"};
        Stream<String> streamName1 = Arrays.stream(names2);
        Stream<String> streamName2 = Stream.of(names2);
        streamName1.forEach(s -> System.out.print(s+" "));

// 孙尚香 孙凤的 大山 多少
Stream流常见的中间方法：

中间方法指的是调用完成后会返回新的Stream流，可以继续使用（支持链式编程）

filter的使用：

需求：过滤姓名以张开头，并且名字长度等于3的名字

 List<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若","赵敏","张强","张三丰");
        // 1、过滤方法   //过滤姓名以张开头，并且名字长度等于3的名字
       list.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(e -> System.out.println(e));


//张无忌
//张三丰

 socred 排序

先准备一个 Movie类和Actor类：

Movies类：

public class Movie implements Comparable<Movie>{
    private String name;
    private Double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, Double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Movie movie = (Movie) o;
        return Objects.equals(name, movie.name) && Objects.equals(score, movie.score) && Objects.equals(actor, movie.actor);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, score, actor);
    }

    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", actor='" + actor + '\'' +
                '}';
    }

    @Override
    public int compareTo(Movie o) {
        return Double.compare(this.score,o.score);
    }
}

Actor类：

public class Actor {
    private String name;
    private Double actor;

    public Actor() {
    }

    public Actor(String name, Double actor) {
        this.name = name;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public Double getActor() {
        return actor;
    }

    public void setActor(Double actor) {
        this.actor = actor;
    }

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

准备一个集合，排序。
 List<Movie> movies = new ArrayList<>();
        movies.add(new Movie("摔跤吧，爸爸", 9.5, "阿米尔汗"));
        movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
        movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
        movies.add(new Movie("阿甘正传", 7.5, "汤姆汉克斯"));
        // 集合中如果存储对象，
        // 方式一：对象类可以实现Comparable接口，指定比较规则  // sorted方法就可以按照规则进行排序，否则报错！
        movies.stream().sorted().forEach(e -> System.out.println(e));

        // 方式二：自带比较器
        movies.stream().sorted((o1,o2)  ->  Double.compare(o2.getScore(),o1.getScore()));


    /**
     * Movie{name='阿甘正传', score=7.5, actor='汤姆汉克斯'}
     * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
     * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
     * Movie{name='摔跤吧，爸爸', score=9.5, actor='阿米尔汗'}
     */

limit 截取：

需求：截取前两个


 movies.stream().sorted().limit(3).forEach(System.out::println);


/**
 * Movie{name='阿甘正传', score=7.5, actor='汤姆汉克斯'}
 * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
 * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
 */

skip 跳过：

需求：跳过前两个
 movies.stream().skip(2).forEach(e -> System.out.println(e));

/**
 * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
 * Movie{name='阿甘正传', score=7.5, actor='汤姆汉克斯'}
 */

distinct 去重：


 movies.stream().distinct().forEach(e -> System.out.println(e));


/**
 * Movie{name='摔跤吧，爸爸', score=9.5, actor='阿米尔汗'}
 * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
 * Movie{name='阿甘正传', score=7.5, actor='汤姆汉克斯'}
 */
map加工方法(映射)：

需求：把流上的数据加工成新数据。


 movies.stream().sorted((Movie o1, Movie o2) -> Double.compare(o2.getScore(),o1.getScore()))
                .map(m -> new Actor(m.getName(),m.getScore())).forEach(e -> System.out.println(e));


    /**
     * Actor{name='摔跤吧，爸爸', actor=9.5}
     * Actor{name='三傻宝莱坞', actor=8.5}
     * Actor{name='三傻宝莱坞', actor=8.5}
     * Actor{name='阿甘正传', actor=7.5}
     */

合并流：

需求：把两个流连接起来


  Stream<String> s1 = Stream.of("张三", "楚留香", "西门吹牛");
        Stream<String> s2 = Stream.of("李四", "石观音");
        // public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
        Stream<String> concat = Stream.concat(s1, s2);
        concat.forEach(e -> System.out.println(e));


/**
 * 张三
 * 楚留香
 * 西门吹牛
 * 李四
 * 石观音
 */
Stream流常见的终结方法：

终结方法指的是调用完成后，不会返回新的Stream了，没法继续使用流了。

forEach：方法

需求：打印出来集合中的数据


  List<Movie> movies = new ArrayList<>();
        movies.add(new Movie("摔跤吧，爸爸", 9.5, "阿米尔汗"));
        movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
        movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
        movies.add(new Movie("阿甘正传", 7.5, "汤姆汉克斯"));
        // 1、forEach
       movies.forEach(e -> System.out.println(e));



        /**
         * {name='摔跤吧，爸爸', score=9.5, actor='阿米尔汗'}
         * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
         * Movie{name='三傻宝莱坞', score=8.5, actor='阿米尔汗2'}
         * Movie{name='阿甘正传', score=7.5, actor='汤姆汉克斯'}
         */

count 取数量：

需求：求出集合中的数据的数量


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



// 4

max 求最大值：

需求：根据评分升序排序


  Movie max = movies.stream().max((o1,o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
        System.out.println(max);


//{name='摔跤吧，爸爸', score=9.5, actor='阿米尔汗'}

min 求最小值:

需求：按照评分排序，找到最小值



        Movie min = movies.stream().min((o1, o2) -> Double.compare(o1.getScore(), o2.getScore())).get();
        System.out.println(min);


// {name='阿甘正传', score=7.5, actor='汤姆汉克斯'}

collect 收集流：

需求：收集Stream流：把流中的数据恢复到集合或者数组中去

  List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        // 收集到List集合   //把姓张的学生收集到一个新的集合中
        List<String> list2 = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());
        System.out.println(list2);

        // 收集到Set集合(流只能用一次)
        Set<String> set1 = list.stream().filter(s -> s.startsWith("张") && s.length() == 3).collect(Collectors.toSet());
        System.out.println(set1);

//[张无忌, 张强, 张三丰, 张三丰]
[张三丰, 张无忌]
//

收集到数组中：


   Stream<String> arr = list.stream().filter(s -> s.startsWith("张"));
        Object[] array = arr.toArray();
        System.out.println(Arrays.toString(array));

// [张无忌, 张强, 张三丰, 张三丰]
// 拓展 收集到Map集合。Movice需要重写 equals 和 hashCode 方法
List<Movie> movies1 = new ArrayList<>();
movies1.add(new Movie("摔跤吧，爸爸", 9.5, "阿米尔汗"));
movies1.add(new Movie("三傻宝莱坞", 18.5, "阿米尔汗2"));
movies1.add(new Movie("三傻宝莱坞", 18.5, "阿米尔汗2"));
movies1.add(new Movie("阿甘正传", 7.5, "汤姆汉克斯"));

Map<String, Double> collect = movies1.stream()
        .distinct().collect(Collectors.toMap(movie -> movie.getName(), movie -> movie.getScore()));
System.out.println(collect);



// {摔跤吧，爸爸=9.5, 阿甘正传=7.5, 三傻宝莱坞=18.5}

烛照103
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java jdk 8 帮助文档 中文 文档 chm 谷歌翻译
04-02
JDK1.8 API 中文谷歌翻译版 java帮助文档 JDK API java 帮助文档 谷歌翻译 JDK1.8 API 中文 谷歌翻译版 java帮助文档 Java最新帮助文档 本帮助文档是使用谷歌翻译，非人工翻译。准确性不能保证，请与英文版配合使用 ...
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。在网上也有很多关于这些新特性的介绍，但个人觉得网上的很多文字对新特性的介绍是不够全面的，...
Java8新特性stream
qq_42964601的博客
05-02 628
Java8新特性stream 概念 Stream是Java8 API的新成员，它允许以声明性方式处理数据集合 特点 （1）代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。 （2）多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下方法。 流程 1）第一步：把集合转换为流stream 2）第二步：操作stream流stream流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal o
JDK8新特性--Stream流详解
最新发布
2401_85014515的博客
07-07 1172
覆盖了Java 8中Stream流的基本概念、操作方法及其在并行处理中的应用. Stream流不同于传统的IO流，它是一种用于对数据进行加工处理的抽象概念，类似于工厂的生产流水线。通过介绍了获取Stream流的几种方式，包括从集合和数组获取流的方法。同时详细描述了Stream流的常用操作方法，如filter、map、sorted、distinct等，以及如何使用终结方法和非终结方法对流进行处理。此外，文中还涉及了如何收集Stream流中的结果到集合或数组中，以及并行Stream流的使用和效率对比
Java-Stream详解
yueerba126的博客
06-30 6874
Stream是Java 8新增的接口，Stream可以认为是一个高级版本的 Iterator。
Java--Stream流详解
热门推荐
MinggeQingchun的博客
08-30 7万+
Stream是Java 8 API添加的一个新的抽象，称为流Stream，可以一种声明的方式处理数据 stream().filter()一般适用于list集合过滤list中的数据，主要作用就是模拟sql查询，从集合中查询想要的数据，不用像之前一样遍历list再筛选 orElse(null)表示如果一个都没找到返回null（orElse()中可以塞默认值。如果找不到就会返回orElse中设置的默认值） orElseGet(null)表示如果一个都没找到返回null（orElseGet()中可以塞默认值。
Java中的Stream
isGentleman的博客
07-04 375
Java中的Stream是一种用于处理集合（数组、列表等）和其他数据源的元素序列的抽象。Stream API提供了一种声明性的编程风格，可以方便地对数据进行过滤、映射、聚合等操作。Stream是Java8API添加的一个新的抽象，称为流Stream，以一种声明性方式处理数据集合（侧重对于源数据计算能力的封装，并且支持序列与并行两种操作方式)Stream流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。
Java中Stream流式编程从入门到精通
qq_42757706的博客
10-20 232
1.Java8开始引入，支持链式书写； 2.存在惰性计算，短路操作，可消费性，所以性能上要优于传统编程； (1).惰性计算:流的元素只在需要时才进行计算，不会提前计算整个流; (2).短路操作:类似于 && ，|| 前面满足条件，后面的计算直接略过； (3).可消费性:流只能被消费一次，即每个元素只能被处理一次;
java中常用list方法，jdk8中的一些方法整理
12-06
jdk7中list的一些功能用起来比较繁琐，比如去重，得通过好几层for循环遍历判断得到，而jdk8 中lambda表达式提供了一些方便list操作的方法，主要涵盖分组、过滤、求和、最值、排序、去重。跟之前的传统写法对比，能少...
JAVA JDK8 List分组获取第一个元素的方法
08-26
JAVA JDK8 List分组获取第一个元素的方法 在Java 8中，List分组获取第一个元素的方法是通过使用Stream API和Collectors来实现的。下面是对该方法的详细介绍： 首先，需要了解Java 8中的Stream API，它允许开发者...
JDK8新特性——Stream.pdf
08-06
借鉴前人经验，在经过不断实践之后，将Strean流部分方法整理成适合于自身需要的文档，供大家借鉴分享。
java Stream详解看我这一篇就够了
m0_64332518的博客
04-01 3760
java Stream详解看一篇就够了。
jdk1.8新特性——Stream（流）的终止操作（归约的示例演示）
小志的博客
08-29 463
目录一、Stream（流）的理解二、Stream（流）是什么三、Stream（流）的注意事项四、Stream API 的操作步骤1、创建 Stream2、中间操作 Stream3、终止Stream五、Stream（流）的终止操作语法1、归约六、Stream（流）的终止操作（归约的示例演示） 一、Stream（流）的理解 Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API对集合数据进行操作，类似于使用S
Java Stream流操作
还是要稳扎稳打
10-26 244
Java Stream 是 Java 8 中引入的一个新特性，它的出现主要是为了解决传统操作方式的一些问题，并提供更为简洁、灵活和高效的操作方式，可以大大提高代码的开发效率和质量。因此，在使用 Java 编程时，推荐使用 Stream 流来进行数据处理和操作。Java Stream 是一种处理集合数据的新方法，它提供了一种简单、高效、并行化的方式来处理集合数据。Java Stream 可以用于任何类型的集合数据，包括 List、Set、Map 等。
一文带你入门Java Stream流，太强了
沉默王二
04-01 2万+
两个星期以前，就有读者强烈要求我写一篇 Java Stream 流的文章，我说市面上不是已经有很多了吗，结果你猜他怎么说：“就想看你写的啊！”你看你看，多么苍白的喜欢啊。那就“勉为其难”写一篇吧，嘻嘻。 单从“Stream”这个单词上来看，它似乎和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢，没毛关系。Java 8 新增的 Stream 是为...
Java Stream 常用方法【详尽篇】
Java Pro
07-25 4608
Java8 版本引入的重要特性之一, 对于集合（例如 List、Map、Set 等）进行处理和操作的高级抽象.Stream API 提供了一种更为简洁高效的的方式来处理集合数据, 可读性较高, 特别在数据的过滤、转换、聚合时的操作很简单方便快捷.
JDK8新特性之Stream流
cch970812的博客
06-14 914
Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作。
Java基础--Stream流
左灯右行的爱情
03-20 1224
加油
深入解析 Java Stream 编程：高效处理数据的新范式
Java领域优秀创作者
06-21 767
Java 8 引入了一个强大而灵活的 API——Stream API，为我们提供了一种声明性处理数据集的方法。Stream API 大大简化了集合操作，让开发者可以以更高效、更可读的方式编写代码。这篇文章将深入探讨 Java Stream 编程的方方面面，通过多个详细的代码示例，帮助你全面理解和掌握这一强大的工具。
jdk8新特性stream流
09-21
JDK8引入了新的特性Stream流。Stream流允许以声明性方式处理数据集合，可以将其看作是遍历数据集合的一个高级迭代器。通过Stream流，我们可以以简洁的方式完成复杂的数据处理操作，代码也更加清晰可读。 在JDK8中，我们可以通过多种方式获取Stream流： 1. 通过List集合对象调用stream()方法来获取Stream流。 2. 通过数组类的stream()方法来获取Stream流。 3. 通过Stream类的of()方法来获取Stream流。 4. 通过List集合对象调用parallelStream()方法来获取并行流。 使用Stream流有以下好处： 1. 代码以声明性方式书写，更加清晰易懂，能够说明想要完成什么，而不是说明如何完成一个操作。 2. 可以将多个基础操作连接起来，形成复杂的数据处理流水线，从而实现更加高效的数据处理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值