Stream流

1.Stream流的作用

结合了Lambda表达式，简化集合，数组的操作

2.Stream的使用步骤

获取Stream流对象
使用中间方法处理数据
使用终结方法处理数据

3.如何获取Stream流对象

单列集合：Collection中默认方法Stream
双列集合：不能直接获取（双列集合获取Stream流的方法）
通过 keySet() 方法：先获取键的集合，再获取流：

Map<String, Integer> map = new HashMap<>();
// 添加元素...
Stream keyStream = map.keySet().stream();

通过 values() 方法：先获取值的集合，再获取流

Map<String, Integer> map = new HashMap<>();
// 添加元素...

    Stream valueStream = map.values().stream();

通过 entrySet() 方法：先获取键值对（Map.Entry）的集合，再获取流

Map<String, Integer> map = new HashMap<>();
// 添加元素...
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();**

其中，entrySet().stream() 是最常用的方式，因为它可以同时操作键和值，例如：

**map.entrySet().stream()
.filter(entry -> entry.getValue() > 10)
.forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));**
数组：Arrays工具类中的静态方法Stream
一堆零散的数据：Stream接口中的静态方法of
4.常见方法

中间方法：filter，limit，skip，distinct，concat，map

filter

作用：过滤流中的元素，只保留满足 Predicate 条件的元素。
示例：筛选出值大于 10 的键值对
**map.entrySet().stream()
.filter(entry -> entry.getValue() > 10) // 保留值>10的元素
.forEach(System.out::println);**

limit

作用：截取流中的前 n 个元素，超出的元素会被丢弃。
示例：只保留前 3 个元素
**list.stream()
.limit(3) // 只取前3个元素
.forEach(System.out::println);**

skip

作用：跳过流中的前 n 个元素，保留剩余的元素。
示例：跳过前 2 个元素，保留后面的元素
**list.stream()
.skip(2) // 跳过前2个元素
.forEach(System.out::println);**

distinct

作用：去除流中的重复元素（依赖元素的 equals() 方法判断是否重复）。
示例：去除重复的整数
**Arrays.stream(new Integer[]{1, 2, 2, 3})
.distinct() // 去重后为 [1,2,3]
.forEach(System.out::println);**

concat

作用：这是 Stream 类的静态方法，用于将两个流合并为一个新的流。
示例：合并两个流
**Stream stream1 = Stream.of("a", "b");
Stream stream2 = Stream.of("c", "d");
Stream combined = Stream.concat(stream1, stream2); // 合并为 [a,b,c,d]**

map

作用：将流中的元素按照 Function 函数进行转换，生成一个新的流（类型可以改变）。
示例：将字符串转换为其长度
**Stream.of("apple", "banana")
.map(String::length) // 转换为 [5,6]
.forEach(System.out::println);**
终结方法：forEach，count，collect

forEach

作用：遍历流中的所有元素，并对每个元素执行 Consumer 接口定义的操作（如打印、修改属性等）。
特点：无返回值（void），主要用于 “消费” 流中的元素，适合简单的遍历操作。
**List list = Arrays.asList("a", "b", "c");
list.stream()

.forEach(s -> System.out.println(s)); // 遍历并打印每个元素**

count

作用：统计流中元素的数量，返回一个 long 类型的结果。
特点：返回流中剩余元素的总数，常用于获取过滤、转换等操作后的元素个数。
**List numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()

               .filter(n -> n > 2) // 筛选出大于2的元素
               .count(); // 统计数量，结果为3（元素3、4、5）

System.out.println(count);**

collect

作用：将流中的元素收集起来，转换为集合（如 List、Set、Map）或其他数据结构，是 Stream 中最灵活的终端操作。
特点：需要传入 Collector 接口的实现类来指定收集规则，Java 提供了 Collectors 工具类简化常见操作。
常用场景：
收集为 List 或 Set；
分组（groupingBy）、分区（partitioningBy）；
拼接字符串（joining）等。
**List list = Arrays.asList("apple", "banana", "cat");
// 1. 收集为 List
List filteredList = list.stream()

                          .filter(s -> s.length() > 3) // 筛选长度>3的元素
                          .collect(Collectors.toList()); // 结果：["apple", "banana"]

// 2. 收集为 Set（自动去重）
Set stringSet = list.stream()

                       .collect(Collectors.toSet());

// 3. 拼接字符串
String joined = list.stream()

               .collect(Collectors.joining(", ")); // 结果："apple, banana, cat"

// 4. 按长度分组（键为长度，值为对应字符串的List）
Map<Integer, List> groupByLength = list.stream()

                                          .collect(Collectors.groupingBy(String::length));**

方法引用

1.什么是方法引用？

把已经存在的方法拿过来用，当作函数是接口中的抽象方法的方法体

2.《：：》是什么符号？

方法引用符

3.方法引用时需要注意什么？

需要有函数式接口
被引用方法必须已经存在
被引用放啊的形参和返回值需要跟抽象方法一致
被引用方法的功能要满足当前需求

方法引用的格式

1.引用静态方法

类名：：静态方法（就是一个方法引用，简化代码的）

2.引用成员方法

对象：：成员方法
this：：成员方法
super：：成员方法

3.引用构造方法

类名：：new

4.使用类名引用成员方法 不能引用所有类中的成员方法，如果抽象方法的第一个参数是A类型的

类名：：成员方法 只能引用A类中的方法

5.引用数组的构造方法

数据类型[]：：new