Stream 流对象的创建与各方法

Dear 丶 2024-02-20 11:40 28阅读 0赞

## 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);
        }
    }

**运行结果如下：**

![f79269d63cec491da2ef340c5fe51098.png][]

####  **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);
        }
    }

**运行结果如下：**

![d7b9a9f2749b4abfaa62d1f51ac89ef8.png][]

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

**获取前面 x 个元素。**

**通过具体代码实现：**

**运行结果如下：**

![e48c2de6093442f289e73745a5ee794f.png][]

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

**跳过前面 x 个元素。**

**通过具体代码实现：**

**运行结果如下：**

![479e83840b744a498324a61beee5f03f.png][]

####  **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);
        }
    }

**运行结果如下：**

![b511a1a7dc54448db6c49b4949eff9c3.png][]

#### 3.6 Stream 流的 distinct() 中间方法 ####

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

**通过代码具体实现：**

**运行结果如下：**

![9b8988db1c394d519c739eaa939764b9.png][]

#### 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);
     
        }
    }

**运行结果如下：**

![2b02cc315f5b434dbbbd1b56d1b94654.png][]

## 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);
        }
    }

**运行结果如下：**

![7d155b8a52e540cb886bed6fecde456d.png][]

#### 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());
        }
    }

**运行结果如下：**

![3bd4007095284d3993d807559d35e0f9.png][]

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

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

**通过代码具体实现：**

**运行结果如下：**

## 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);
>         }
>     }
> 
> 实现List数组用逗号分隔开，转成字符串
> 
>     List list = new ArrayList();
>     list.add("a");
>     list.add("b");
>     list.add("c");
>     list.add("d");
>     
>     String str = list.stream().collect(Collectors.joining(","));
>     
>     System.out.println(str); //输出结果为 a,b,c,d

**运行结果如下：**

![1073aaa37523471a8f25d9d4224313e1.png][]

**二.收集到 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);
        }
    }

**运行结果如下：**

![b0a945a727174ec5945c46e4e63a41df.png][]

**三.收集到 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);
        }
    }

**运行结果如下：**

![338fbd897330493a8436d38068de7c13.png][]

**四.收集到数组中**

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));
        }
    }

**运行结果如下：**

![dce05f7379af4ec6a9fb2d71b4e5f40b.png][]

[f79269d63cec491da2ef340c5fe51098.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/6357688643c54172b26dfed5de7902a2.png
[d7b9a9f2749b4abfaa62d1f51ac89ef8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/c7d37cd7d5fa423c9c1df74cf2dc14d5.png
[e48c2de6093442f289e73745a5ee794f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/20746c4fe25643eeba24f7101e18ec5f.png
[479e83840b744a498324a61beee5f03f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/c757649ac0f44f30a2d50fac4b9bb9c1.png
[b511a1a7dc54448db6c49b4949eff9c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/cac343656cbe47bd9576dd43ed81716e.png
[9b8988db1c394d519c739eaa939764b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/827e933b3f344588af3b46d21d1df479.png
[2b02cc315f5b434dbbbd1b56d1b94654.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/80a1c6f7872e4983b766dc6044ae0abb.png
[7d155b8a52e540cb886bed6fecde456d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/9dad4ec77fbc4db2a79e88c4caf8e600.png
[3bd4007095284d3993d807559d35e0f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/ba6fdacca0fd4c218f80d8be554bc873.png
[1073aaa37523471a8f25d9d4224313e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/a27ac07e2de64753b9adfea5a13b2b5f.png
[b0a945a727174ec5945c46e4e63a41df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/58fedf5331ad4fb7a24ffae0176da528.png
[338fbd897330493a8436d38068de7c13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/53556e3d6d1b4973925664f5fa64c7df.png
[dce05f7379af4ec6a9fb2d71b4e5f40b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/20/f69fd39ffe45419f86d06ce2b9a52be2.png