1. Toy模板网首页
  2. > Toy博客

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法

7月前 作者：小扳 分类：Toy博客 阅读(26) 违法举报

这篇具有很好参考价值的文章主要介绍了进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

        1.0 Stream 流的说明

        2.0 Stream 流对象的创建

        2.1 对于 Collection 系列集合创建 Stream 流对象的方式

        2.2 对于 Map 系列集合创建 Stream 流对象的方式

        2.3 对于数组创建 Stream 流对象的方式

        3.0 Stream 流的中间方法

        3.1 Stream 流的 filter() 中间方法

        3.2 Stream 流的 sorted() 中间方法

        3.3 Stream 流的 limit(x) 中间方法

        3.4 Stream 流的 skip(x) 中间方法

        3.5 Stream 流的 map() 中间方法

        3.6 Stream 流的 distinct() 中间方法

        3.7 Stream 流的 concat() 中间方法

        4.0 Stream 流的终结方法

        4.1 Stream 流的 forEach 终结方法

        4.2 Stream 流的 count() 终结方法

        4.3 Stream 流的 max() 或者 min() 终结方法

        5.0 Stream 流的 collect() 收集方法

        1.0 Stream 流的说明

        Stream（流）是一种数据处理的概念，它可以用来处理集合、数组或输入/输出等数据源的元素序列。流可以看作是一个从源到目标的元素序列，可以通过一系列连续的操作对其进行处理。流的操作可以分为两种类型：中间操作和终端操作。中间操作是对流进行处理并返回一个新的流，而终端操作是对流进行最终的处理并返回一个结果或副作用。

        2.0 Stream 流对象的创建

        主要以数组、集合来创建 Stream 流对象。

        2.1 对于 Collection 系列集合创建 Stream 流对象的方式

        直接用集合对象.stream() 实例方法创建 Stream 流对象。

以代码的形式来具体介绍：

        // List 集合系列来创建 Stream 流对象
        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五","张麻子");
        Stream<String> stream = list.stream();

        // Set 集合系列来创建 Stream 流对象
        Set<String> set = new HashSet<>();
        Collections.addAll(set,"张三","李四","王五","张麻子");
        Stream<String> stream1 = set.stream();

       

        2.2 对于 Map 系列集合创建 Stream 流对象的方式

        具体来介绍两种方式：第一种方法；把键值对“封装”成一个整体。第二种方法；分别把集合中的键和值全部获取出来，单独放在各个集合中。

以代码的形式来具体介绍：

        // Map 集合系列来创建 Stream 流对象
        Map<String,Integer> m = new HashMap<>();
        m.put("张三",19);
        m.put("李四",28);
        m.put("王五",33);
        m.put("张麻子",22);
        //第一种方法:把键值对“封装”成一个整体
        Set<Map.Entry<String,Integer>> entries = m.entrySet();
        Stream<Map.Entry<String,Integer>> stream2 = entries.stream();
        //第二种方法:分别把集合中的键和值全部获取出来，单独放在系列集合中
        Set<String> k = m.keySet();
        Collection<Integer> v = m.values();
        Stream<String> stream3 = k.stream();
        Stream<Integer> stream4 = v.stream();

        2.3 对于数组创建 Stream 流对象的方式

        具体来介绍有两种方式来创建对象：第一种方法；用 Arrays.stream() 方法来创建。第二种方法；用 Stream.of() 方法来创建。

以代码的形式来具体介绍：

        // 用数组来创建 Stream 流对象
        String[] strings = new String[]{"张三","李四","王五","张麻子"};
        //第一种方法：用 Arrays.stream() 方法来创建
        Stream<String> stream5 = Arrays.stream(strings);

        //第二种方法：用 Stream.of() 方法来创建
        Stream<String> stream6 = Stream.of(strings);

        

        3.0 Stream 流的中间方法

        Stream 流的中间方法主要用于对流中的元素进行处理，返回一个新的流对象。这些中间方法可以组合使用，形成流水线式的处理流程，方便进行复杂的数据处理操作。

        3.1 Stream 流的 filter() 中间方法

        用于对流中的数据进行过滤。

通过具体代码实现：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

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

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五","张麻子");
        //对一下代码解读:首先用 stream() 得到了该集合的流，
        //然后用 filter() 用于对流中的数据进行过滤，也可以理解成筛选字符串中带有“张”的,返回新流，
        //该新流中都是含“张”的字符串，接着把流中的数据进行用 forEach() 方法进行遍历。
        
        /*list.stream().filter(s -> s.contains("张")).forEach(s-> System.out.println(s));*/
        //对以上代码稍微简化，如以下：
        list.stream().filter(s -> s.contains("张")).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        3.2 Stream 流的 sorted() 中间方法

        按照指定规则排序。

通过具体代码实现：

        

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        //解读以下代码：首先先利用 stream() 方法来获取该集合的流，然后用 sorted() 方法，由于是自定义类型的对象，
        //默认的 sorted() 方法是搞不定，所以需要重写方法，因此可以接入这个匿名内部类来重写内部的具体方法，
        //排完序之后会得到一个新的流，然后经过 forEach 方法来遍历该流中的数据。
        list.stream().sorted((o1, o2)-> o1.getAge() - o2.getAge()).forEach(s-> System.out.println(s));
        //以上代码话可以继续简化,效果是一样的
        System.out.println("--------------------------------------------------------------------");
        list.stream().sorted((o1, o2)-> o1.getAge() - o2.getAge()).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        3.3 Stream 流的 limit(x) 中间方法

        获取前面 x 个元素。

通过具体代码实现：

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        //对一下代码进行解读：先获取该集合的流，然后用 limit(2) 中间方法，获取前面2个元素，
        //返回新流，接着对新流进行遍历输出元素
        list.stream().limit(2).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        3.4 Stream 流的 skip(x) 中间方法

        跳过前面 x 个元素。

通过具体代码实现：

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        //对一下代码进行解读：先得到该集合的流，然后用 skip(2) 中间方法，跳过前面2个元素，
        //得到的新流中包含后面两个元素，然后就进行遍历了。
        list.stream().skip(2).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        3.5 Stream 流的 map() 中间方法

        对元素进行加工，并返回对应的新流。（映射）

通过代码具体实现：

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        //解读以下代码: 先得到该集合的流，然后调用 map() 中间方法，
        //将对应的元素进行加工，简单的来说就是，将原先的元素加工成自己想要的形式，
        //以下就是将学生类对象加工成字符串，["张三",19] -> "张三"，每一个元素都是一一对应、映射的。
        list.stream().map(s->s.getName()).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        3.6 Stream 流的 distinct() 中间方法

        去除流中重复的元素。但是对于自定义类型的元素，默认的 distinct() 方法是不能完成去除重复的元素。希望内容一样就认为重复，这就需要重写 hashCode() 与 equals() 方法。

通过代码具体实现：

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));
        list.add(new Student("张三",19));

        //解读以下代码: 先获取该集合中的流，然后调用 distinct() 方法，但是该流中的元素是自定义，
        //所以希望内容一样就认为重复，这就需要重写 hashCode() 与 equals() 方法。
        //去重后，返回一个新流。
        list.stream().distinct().forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

         如果对重写 hashCode() 与 equals() 方法不太熟悉，可以点击以下链接去了解以下：

        进阶JAVA篇-深入了解 Set 系列集合-CSDN博客

        3.7 Stream 流的 concat() 中间方法

        合并 a 和 b 两个流为一个流。

通过代码具体实现：

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

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        List<Student> list1 = new ArrayList<>();
        list1.add(new Student("李麻子",23));
        Stream<Student> stream = Stream.concat(list.stream(),list1.stream());
        stream.forEach(System.out::println);

    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节


 

        4.0 Stream 流的终结方法

        Stream 流的终结方法用于对流进行最终的处理并返回一个结果或副作用。对流进行最终的处理并获取结果。需要注意的是，终结方法只能对流进行一次操作，一旦流被消费，就不能再次使用。

        4.1 Stream 流的 forEach 终结方法

        对此流运算后的元素执行后遍历。

通过代码具体实现：

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

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        List<Student> list1 = new ArrayList<>();
        list1.add(new Student("李麻子",23));
        Stream.concat(list.stream(),list1.stream()).forEach(System.out::println);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        4.2 Stream 流的 count() 终结方法

        统计此流运算后的元素个数。需要注意的是：返回值是 long 类型。

通过代码具体实现：

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

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",19));
        list.add(new Student("李四",22));
        list.add(new Student("王五",17));
        list.add(new Student("张麻子",33));

        List<Student> list1 = new ArrayList<>();
        list1.add(new Student("李麻子",23));
        System.out.println(Stream.concat(list.stream(), list1.stream()).count());
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        4.3 Stream 流的 max() 或者 min() 终结方法

        获取此流运算后的最大值或者最小值元素。但是对于自定义的类型，默认的 max() 方法是不能获取此流的最大值元素，默认的 min() 方法是不能获取此流的最小值元素，会报异常，此时就需要用到比较器了。

通过代码具体实现：

import java.util.ArrayList;
import java.util.List;

public class StreamIntermediateMethod {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 19));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 17));
        list.add(new Student("张麻子", 33));

        Student s1 = list.stream().max((o1, o2) -> o1.getAge() - o2.getAge()).get();
        System.out.println("最大年龄为："+s1.getAge());

        Student s2 = list.stream().min((o1, o2) -> o1.getAge() - o2.getAge()).get();
        System.out.println("最小年龄为："+s2.getAge());
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

        5.0 Stream 流的 collect() 收集方法

        把流处理后的结果收集到一个指定的集合中去。

通过代码具体实现：

一. 收集到 list 系列集合中

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

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 19));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 17));
        list.add(new Student("张麻子", 33));

        //对以下代码进行解读：先得到该集合的流，再筛选开头为“张”的名字，得到一个新流，再收集到 List 系列集合中。
        List<Student> list1 =  list.stream().filter(s->s.getName().startsWith("张")).collect(Collectors.toList());
        System.out.println(list1);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

二.收集到 Set 系列集合中

import java.util.*;
import java.util.stream.Collectors;

public class StreamIntermediateMethod {

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 19));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 17));
        list.add(new Student("张麻子", 33));

        //对一下代码进行解读: 先得到该集合的流，再进行筛选出年龄大于18的元素，
        // 最后再将这些集合中的元素收集到 Set 系列集合中。
        Set <Student> set = list.stream().filter(s->s.getAge() > 18).collect(Collectors.toSet());
        System.out.println(set);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

三.收集到 Map 系列集合中

import java.util.*;
import java.util.stream.Collectors;

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 19));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 17));
        list.add(new Student("张麻子", 33));

        Map<String,Integer> map = list.stream().collect(Collectors.toMap(s-> s.getName(), s-> s.getAge()));
        System.out.println(map);
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

四.收集到数组中

import java.util.*;

public class StreamIntermediateMethod {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 19));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 17));
        list.add(new Student("张麻子", 33));

        Student[] students = list.stream().toArray(s->new Student[s]);
        //以上代码简化为如下:
        Student[] students1 = list.stream().toArray(Student[]::new);

        System.out.println(Arrays.toString(students));
        System.out.println(Arrays.toString(students1));
    }
}

运行结果如下：

进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法,1024程序员节

         本篇就先讲到这里！！！点击以下链接有更多篇目：小扳_-CSDN博客文章来源地址https://www.toymoban.com/news/detail-713176.html

到了这里，关于进阶JAVA篇-深入了解 Stream 流对象的创建与中间方法、终结方法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Java 进阶篇】深入了解 Bootstrap 全局 CSS 样式

    【Java 进阶篇】深入了解 Bootstrap 全局 CSS 样式

    Bootstrap 是一个流行的前端框架，以其强大的全局 CSS 样式而闻名。这些样式能够帮助开发者快速创建漂亮的、响应式的网页，而无需从头编写复杂的 CSS。在本文中，我们将深入探讨 Bootstrap 的全局 CSS 样式，适合初学者，帮助他们更好地理解和应用这些样式。 全局 CSS 样式是

    2024年02月07日
    浏览(30)

  • JAVA 使用stream流将List中的对象某一属性创建新的List

    Java Stream是Java 8引入的一种新机制，它可以让我们以声明式方式操作集合数据，提供了更加简洁、优雅的集合处理方式。Stream是一个来自数据源的元素队列，并支持聚合操作。它的特点有： Stream 不会修改原始数据源。 Stream 操作是延迟执行的。 Stream 操作可以是无限的（比如

    2024年02月03日
    浏览(40)

  • Java Stream对象并行处理方法parallel()

            Stream.parallel() 方法是 Java 8 中 Stream API 提供的一种并行处理方式。在处理大量数据或者耗时操作时，使用 Stream.parallel() 方法可以充分利用多核 CPU 的优势，提高程序的性能。本文将从以下几个方面对 Stream.parallel() 进行详解。 什么是 Stream.parallel() 方法         

    2024年02月16日
    浏览(51)

  • 深入理解JVM：Java使用new创建对象的流程

            ①new 对象         ②反射         ③对象的复制         ④反序列化 先看看常量池里面有没有，如果有，就用常量池的 看这个类有没有被加载过，如果没有，就执行类加载以及类的初始化。（对象的大小，在类加载的时候就确定了）。 对象在堆内存

    2024年02月15日
    浏览(55)

  • 深入了解 Java 方法和参数的使用方法

    方法是一块仅在调用时运行的代码。您可以将数据（称为参数）传递到方法中。方法用于执行特定的操作，它们也被称为函数。 重用代码：定义一次代码，多次使用。 提高代码的结构化和可读性。 将代码分解成更小的模块，易于维护和理解。 方法必须在类内声明。它的定义

    2024年02月19日
    浏览(29)
  • java8 列表通过 stream流 根据对象属性去重的三种实现方法

    java8 列表通过 stream流 根据对象属性去重的三种实现方法

    0、User对象 1、使用filter进行去重 测试 ①、疑惑 既然 filter 里面调用的是 distinctPredicate 方法，而该方法每次都 new 一个新的 map 对象，那么 map 就是新的，怎么能做到可以过滤呢 ②、解惑 先看一下 filter 的部分实现逻辑，他使用了函数式接口 Predicate ，每次调用filter时，会使用

    2024年01月20日
    浏览(49)

  • 深入了解：Java中BigDecimal比较大小的方法

    目录 Java中BigDecimal比较大小的方法 1. ​​compareTo()​​ 2. ​​equals()​​ 3. ​​compareTo()​​ 大家好，今天我想和大家讨论一下Java中BigDecimal类的比较大小的方法。在实际开发中，我们经常会遇到需要比较两个BigDecimal对象的大小的情况，比如排序、判断大小等。但是由于Bi

    2024年02月04日
    浏览(26)
  • 深入了解 RabbitMQ：高性能消息中间件

    深入了解 RabbitMQ：高性能消息中间件

    在现代分布式系统中，消息队列成为了实现系统间异步通信、削峰填谷以及解耦组件的重要工具。而RabbitMQ作为一个高效可靠的消息队列解决方案，已经成为许多企业广泛采用的选择。本文将介绍RabbitMQ的基本概念、主要特性以及常见应用场景。 RabbitMQ 是一个开源的高性能、

    2024年02月08日
    浏览(36)
  • Stream 流对象的创建与各方法

    Stream 流对象的创建与各方法

    1.0 Stream 流的说明 2.0 Stream 流对象的创建         2.1 对于 Collection 系列集合创建 Stream 流对象的方式        2.2 对于 Map 系列集合创建 Stream 流对象的方式       2.3 对于数组创建 Stream 流对象的方式 3.0 Stream 流的中间方法       3.1 Stream 流的 filter() 中间方法      3.2 Stream

    2024年02月06日
    浏览(18)
  • 【JavaSE专栏56】Java面向对象编程：深入理解类、对象、属性和方法的核心概念

    【JavaSE专栏56】Java面向对象编程：深入理解类、对象、属性和方法的核心概念

    博主 默语带您 Go to New World. ✍ 个人主页—— 默语 的博客👦🏻 《java 面试题大全》 🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭 《MYSQL从入门到精通》数据库是开发者必会基础之一~ 🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄

    2024年02月07日
    浏览(31)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包