【JAVA进阶】Stream流

喜欢ヅ旅行 2024-04-20 07:57 70阅读 0赞

> ?个人主页：[个人主页][Link 1]
> 
> ?系列专栏：[JAVASE基础][JAVASE]

**目录**

1.Stream流的概述

2.Stream流的获取

3.Stream流的常用方法

--------------------

#### 1.Stream流的概述 ####

**什么是Stream流？**

*  在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。
 *  目的：用于简化集合和数组操作的API。

![3ee6284434d64bccb661fea6d991ad03.png][]

**Stream流思想**

Stream流式思想的核心：

1.  先得到集合或者数组的Stream流（就是一根传送带）
2.  把元素放上去
3.  然后就用这个Stream流简化的API来方便的操作元素。

**体验Stream流的作用**

假设我们有一个Person类，其中包含属性name和age。我们有一个List<Person>对象，现在我们要使用Java Stream流来过滤出其中年龄大于18岁的人的名字。

public class Main {
    
        public static void main(String[] args) {
    
            List<Person> people = new ArrayList<>();
            people.add(new Person("Mike", 20));
            people.add(new Person("John", 17));
            people.add(new Person("Lucy", 25));
    
            people.stream().filter(p -> p.getAge() > 18).forEach((s-> System.out.println(s.getName())));
      
    
    
        }
    }

输出：

Mike
    Lucy

#### 2.Stream流的获取 ####

Stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。

**集合获取Stream流的方式**

可以使用Collection接口中的默认方法stream()生成流

<table> 
 <tbody> 
  <tr> 
   <td style="width:257px;"> <p>名称</p> </td> 
   <td style="width:587px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:257px;"> <p>default&nbsp;Stream&lt;E&gt;&nbsp;stream()</p> </td> 
   <td style="width:587px;"> <p>获取当前集合对象的Stream流</p> </td> 
  </tr> 
 </tbody> 
</table>

public class Main {
    
        public static void main(String[] args) {
    
    //----------------- Collection集合获取流------------------------
            Collection<String> list = new ArrayList<>();
            Stream<String> stream = list.stream();
    //----------------- Map集合获取流------------------------
            HashMap<String,Integer> map = new HashMap<>();
            //键流
            Stream<String> keyStream = map.keySet().stream();
            //值流
            Stream<Integer> valueStream = map.values().stream();
            //键值对流(拿整体)
            Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
    
    
        }
    }

**数组获取Stream流的方式**

<table> 
 <tbody> 
  <tr> 
   <td style="width:309px;"> <p>名称</p> </td> 
   <td style="width:539px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:309px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;Stream&lt;T&gt;&nbsp;stream(T[]&nbsp;array)</p> </td> 
   <td style="width:539px;"> <p>获取当前数组的Stream流</p> </td> 
  </tr> 
  <tr> 
   <td style="width:309px;"> <p>public&nbsp;static&lt;T&gt;&nbsp;Stream&lt;T&gt;&nbsp;of(T...&nbsp;values)&nbsp;</p> </td> 
   <td style="width:539px;"> <p>获取当前数组/可变数据的Stream流</p> </td> 
  </tr> 
 </tbody> 
</table>

public static void main(String[] args) {
            String[] names=["热爱","编程的","小白白"];
            Stream<String> stream = Arrays.stream(names);
            Stream<String> stringStream = Stream.of(names);
    
    
        }

**Stream流有三类方法：**

1.  Intermediate（中间操作）：对数据进行处理和转换，返回一个新的Stream对象，可以链式操作。包括常用的map、filter、distinct等方法。
2.  Terminal（终止操作）：对Stream流进行聚合或收集操作，触发执行计算并返回结果。包括常用的forEach、reduce、collect等方法。
3.  Short-circuiting（短路操作）：在满足一定条件时可以提前结束Stream流的操作。包括常用的anyMatch、allMatch、noneMatch等方法。

#### 3.Stream流的常用方法 ####

**collect()：将流中的元素收集到一个容器中。**

List<String> words = Arrays.asList("hello", "world", "java", "stream", "api");
    Set<String> wordSet = words.stream().collect(Collectors.toSet());
    System.out.println(wordSet);

上述代码中，我们定义了一个包含字符串的List，使用Stream的collect()方法对其进行收集操作，将其结果保存在Set集合中，去除重复元素，最终将结果保存在wordSet的Set集合中，并打印输出。

**Stream流的常用API中间操作方法包括：**

**1.filter()：根据指定的条件过滤元素。**

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
    List<Integer> result = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
    System.out.println(result);

上述代码中，我们定义了一个包含整数的List，并使用Stream的filter()方法对其进行过滤，只保留其中的偶数，最终将结果保存在result的List中，并打印输出。

**2.distinct()：根据元素的 hashCode() 和 equals() 方法去重。**

List<String> words = Arrays.asList("hello", "world", "hello", "java", "world");
    List<String> uniqueWords = words.stream().distinct().collect(Collectors.toList());
    System.out.println(uniqueWords);

上述代码中，我们定义了一个包含字符串的List，使用Stream的distinct()方法对其进行去重操作，最终将结果保存在uniqueWords的List中，并打印输出。

**3.limit()：限制元素数量。**

List<String> words = Arrays.asList("hello", "world", "java", "stream", "api");
    List<String> limitedWords = words.stream().limit(3).collect(Collectors.toList());
    System.out.println(limitedWords);

上述代码中，我们定义了一个包含字符串的List，使用Stream的limit()方法对其进行限制操作，只保留前3个元素，最终将结果保存在limitedWords的List中，并打印输出。

**4.skip()：跳过指定数量的元素。**

List<String> words = Arrays.asList("hello", "world", "java", "stream", "api");
    List<String> skippedWords = words.stream().skip(2).collect(Collectors.toList());
    System.out.println(skippedWords);

上述代码中，我们定义了一个包含字符串的List，使用Stream的skip()方法对其进行跳过操作，跳过前2个元素，只保留后面的元素，最终将结果保存在skippedWords的List中，并打印输出。

**5.concat():合并a和b两个流为一个流**

Stream<String> stream1 = Stream.of("Java", "is", "cool");
    Stream<String> stream2 = Stream.of(" and", "fun", "too!");
    
    Stream<String> resultStream = Stream.concat(stream1, stream2);
    resultStream.forEach(System.out::print); // Output: Java is cool and fun too!

在这个例子中，我们首先创建两个字符串流 stream1 和 stream2，并使用 concat() 方法将它们连接在一起，形成一个新的流 resultStream。最后，我们遍历新的流，并将结果输出到控制台。

总之，Stream.concat() 方法可以将两个流连接为一个流，以便进行进一步的操作。

注意：

*  中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。
 *  在Stream流中无法直接修改集合、数组中的数据。

**Stream流的常见终结操作方法:**

**1.forEach() 对此流的每个元素执行遍历操作**

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    numbers.stream().forEach(n -> System.out.println(n));

**2.count() 返回此流中的元素数**

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    long count = numbers.stream().count();
    System.out.println("Count: " + count);

**注意：终结操作方法，调用完成后流就无法继续使用了，原因是不会返回Stream了。**

**收集Stream流:**

收集Stream流的含义：就是把Stream流操作后的结果数据转回到集合或者数组中去。

*  Stream流：方便操作集合/数组的手段。
 *  集合/数组：才是开发中的目的。

**Stream流的收集方法:**

<table> 
 <tbody> 
  <tr> 
   <td style="width:283px;"> <p>名称</p> </td> 
   <td style="width:565px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:283px;"> <p>R&nbsp;collect(Collector&nbsp;collector)</p> </td> 
   <td style="width:565px;"> <p>开始收集Stream流，指定收集器</p> </td> 
  </tr> 
 </tbody> 
</table>

**Collectors工具类提供了具体的收集方式:**

<table> 
 <tbody> 
  <tr> 
   <td style="width:363px;"> <p>名称</p> </td> 
   <td style="width:485px;"> <p>说明</p> </td> 
  </tr> 
  <tr> 
   <td style="width:363px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;Collector&nbsp;toList()</p> </td> 
   <td style="width:485px;"> <p>把元素收集到List集合中</p> </td> 
  </tr> 
  <tr> 
   <td style="width:363px;"> <p>public&nbsp;static&nbsp;&lt;T&gt;&nbsp;Collector&nbsp;toSet()</p> </td> 
   <td style="width:485px;"> <p>把元素收集到Set集合中</p> </td> 
  </tr> 
  <tr> 
   <td style="width:363px;"> <p>public&nbsp;static&nbsp;&nbsp;Collector&nbsp;toMap(Function&nbsp;keyMapper&nbsp;,&nbsp;Function&nbsp;valueMapper)</p> </td> 
   <td style="width:485px;"> <p>把元素收集到Map集合中</p> </td> 
  </tr> 
 </tbody> 
</table>

上面案例有使用过，所以就不举例子了....

[Link 1]: https://blog.csdn.net/Javascript_tsj?type=blog
[JAVASE]: https://blog.csdn.net/javascript_tsj/category_11897642.html?spm=1001.2014.3001.5482
[3ee6284434d64bccb661fea6d991ad03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/16fded9d4bc94f15b7e603da06da08ae.png