JAVA学习4 stream流

现在的我很迷茫，就像当初那个电视机前剥葡萄把皮扔进碗里把葡萄扔进垃圾桶里的小孩一样

stream流

stream流是jdgk8开始新增的一套AIP，针对集合或者数组数据的操作。其大量集合了Lamba的语法来编程，功能强大，性能高效，简洁美观。

//对于字符串数组，筛选出所有字符a开头且长度为3的字符串
public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("acc");
        list.add("BBBB");
        list.add("AAAAAA");
        list.add("ace");
        list.add("ecd");
        list.add("aaaaaaa");

        //1.暴力筛选
        List<String> newList = new ArrayList<>();
        for (String name : list) {
            if(name.startsWith("a") && name.length() == 3) {
                newList.add(name);
            }
        }
        System.out.println(newList);

        //2.stream流筛选
        System.out.println(list.stream().collect(Collectors.toList())); //stream流输出集合 
        System.out.println(list.stream().filter(s->s.startsWith("a")).collect(Collectors.toList())); //stream流筛选出a开头的字符串集合
        System.out.println(list.stream().filter(s->s.startsWith("a")).filter(s->s.length()==3).collect(Collectors.toList())); //stream流筛选出a开头且长度为3的字符串集合
    }
}

输出如下：

[aaa, acc, ace]
[aaa, bbb, acc, BBBB, AAAAAA, ace, ecd, aaaaaaa]
[aaa, acc, ace, aaaaaaa]
[aaa, acc, ace]

stream流使用步骤

stream流的使用步骤分三步走：①与数据源建立连接，获取stream流 ②调用中间方法对数据进行处理 ③获取处理结果收集到新集合中

获取stream流

使用代码详细介绍

//1.从单列集合获取 Stream 流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();

//2.从数组获取stream流
Set<Integer> set = new HashSet<>();
Stream<Integer> stream2 = set.stream();

//3.使用 Stream.of() 方法
Stream<String> stream = Stream.of("apple", "banana", "cherry");
Stream<Integer> intStream = Stream.of(1, 2, 3, 4, 5);

//4.从双列集合（Map）获取 Stream 流，由于Map本身不直接继承自Collection，所以需要分别提取键值集合
Map<String, Integer> map = new HashMap<>();

// 获取键的 Stream
Stream<String> keyStream = map.keySet().stream();

// 获取值的 Stream
Stream<Integer> valueStream = map.values().stream();

// 获取键值对 Entry 的 Stream
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

stream流中间方法

常用中间方法如下：

filter

filter是对流中数据元素过滤的方法

//其中filter括号内的是(Predicate <? super T> predicate)，接受输入参数返回布尔值，实际声明声明为条件判断用于过滤
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

map

map方法将流中的每个元素通过给定的映射函数进行加工转换

List<String> names = Arrays.asList("alice", "bob", "charlie");
//将字符串转换为其长度然后存储
List<Integer> nameLengths = names.stream()
    .map(String::length)
    .collect(Collectors.toList());

sorted

sorted方法对流内数据进行排序，不指定规则则按照默认规则升序排序

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
//默认规则升序排序
List<Integer> sortedNumbers1 = numbers.stream()
        .sorted()
        .toList();
//自定义降序排序
List<Integer> sortedNumbers2 = numbers.stream()
        .sorted((a,b)->Integer.compare(b,a))
        .toList();

distinct

distinct方法对元素去重

List<String> names = Arrays.asList("John", "Jane", "John", "Mike");
List<String> distinctNames = names.stream()
    .distinct()
    .collect(Collectors.toList());

concat

concat方法将多个流结合到一起

Stream<String> stream1 = Stream.of("A", "B", "C");
Stream<String> stream2 = Stream.of("D", "E", "F");
Stream<String> result = Stream.concat(stream1, stream2);
// 结果流包含: A, B, C, D, E, F

//多个流结合采取嵌套处理
Stream<String> stream1 = Stream.of("A", "B");
Stream<String> stream2 = Stream.of("C", "D");
Stream<String> stream3 = Stream.of("E", "F");
Stream<String> result = Stream.concat(Stream.concat(stream1, stream2), stream3);

终结方法

终结方法是指stream调用之后不会再返回stream对象，所以终结了 听上去有些中二不过学计算机学多了就会发现疯狂的命名海了去了

简易终结方法

//1.forEach方法 对于stream元素遍历操作，返回void类型
List<String> list = Arrays.asList("a", "b", "c");
list.stream().forEach(System.out::println);

//2.count方法，计数操作，返回long类型
long count = list.stream().count();

//3.min和max方法，获取最值，返回Optional类型，可自定义规则
Optional<String> min = list.stream().min(String::compareTo);
Optional<String> max = list.stream().max(String::compareTo);

收集stream流方法

把stream流操作后的结果收集到数据或者集合中去，常见方法为collect和toArray，前者返回集合，后者返回数组

collect方法

collect方法格式如下：

<R> R collect(Collector<? super T, A, R> collector)
//T是流中元素类型
//A是累加器类型
//R是收集元素类型

看上去有些过于抽象了，没事直接上实例

//1.收集到list中去
List<String> list = stream.collect(Collectors.toList());

//2.收集到set中去
Set<String> set = stream.collect(Collectors.toSet());

//3.收集到map中去
Map<String, Integer> map = stream.collect(Collectors.toMap(
    keyMapper,    // 键的映射函数
    valueMapper   // 值的映射函数
));

toArray方法

// 示例1：基本使用
List<String> list = Arrays.asList("A", "B", "C", "D");
String[] strArray = list.stream().toArray(String[]::new);

// 示例2：使用 IntFunction 生成器
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer[] intArray = numbers.stream().toArray(Integer[]::new);

// 示例3：处理基本数据类型
int[] primitiveArray = numbers.stream().mapToInt(Integer::intValue).toArray();

---

好了，总结完成，感觉有些抽象，不过没关系，AI会帮我们想办法的~~