Stream流

Stream流

从给定句子中返回单词长度大于5的单词列表，按长度倒序输出，最多返回3个

JAVA7及之前

package com.example.stream;

import com.sun.istack.internal.NotNull;

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

/**
 * @Author moon
 * @Date 2023/4/12 16:44
 * @Description TODO
 */
public class Main {
    //JAVA7及之前
    public List<String> sortGetTop3LongWords(@NotNull String sentence) {
        // 先切割句子，获取具体的单词信息
        String[] words = sentence.split(" ");
        List<String> wordList = new ArrayList<>();
        // 循环判断单词的长度，先过滤出符合长度要求的单词
        for (String word : words) {
            if (word.length() > 5) {
                wordList.add(word);
            }
        }
        //o2的长度大于o1的话，两个元素位置不变
        //o2的长度小于o1的话，两个元素位置交换
        // 对符合条件的列表按照长度进行排序
        wordList.sort((o1, o2) -> o2.length() - o1.length());
        // 判断list结果长度，如果大于3则截取前三个数据的子list返回
        if (wordList.size() > 3) {
            wordList =wordList.subList(0, 3);
        }
        return wordList;
    }

    //在JAVA8及之后的版本中，借助Stream流，我们可以更加优雅的写出如下代码：
    public List<String> sortGetTop3LongWordsByStream(@NotNull String sentence) {
        return Arrays.stream(sentence.split(" "))
                .filter(word -> word.length()>5)
                .sorted(((o1, o2) -> o2.length()-o1.length()))
                .limit(3)
           		 //将流转换为指定的类型，通过Collectors进行指定
                .collect(Collectors.toList());
    }
    public static void main(String[] args) {

    }
}

Stream初相识

Stream方法使用

map与flatMap

//一对一
public void  stringToIntMap() {
    //Arrays.asList 将数组转换为集合
    List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");
    List<User> results = ids.stream()
            //将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流
            .map(id -> {
                User user = new User();
                user.setId(id);
                return user;
            })
            //将流转换为指定的类型
            .collect(Collectors.toList());
    System.out.println(results);
}
//执行之后，会发现每一个元素都被转换为对应新的元素，但是前后总元素个数是一致的：
//[User(id=205), User(id=105), User(id=308), User(id=469), User(id=627), User(id=193), User(id=111)]

//一对多
public void stringToIntFlatMap() {
    List<String> sentences = Arrays.asList("hello world", "Jia Gou Wu Dao");
    List<String> results = sentences.stream()
            .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
            .collect(Collectors.toList());
    System.out.println(results);
}
//[hello, world, Jia, Gou, Wu, Dao] 为什么都加了逗号？

peek和foreach方法

//peek和foreach方法
public void testPeekAndForeach() {
    List<String> sentences = Arrays.asList("hello world", "Jia Gou Wu Dao");
    // 演示点1： 仅peek操作，最终不会执行
    System.out.println("----------peek前---------");
    sentences.stream().peek(sentence -> System.out.println(sentence));
    System.out.println("----------peek后---------");
    // 演示点2： 仅foreach操作，最终会执行
    System.out.println("----------foreach前---------");
    sentences.stream().forEach(s -> System.out.println(s));
    System.out.println("----------foreach后---------");
    // 演示点3： peek操作后面增加终止操作，peek会执行
    System.out.println("----------peek前---------");
    sentences.stream().peek(sentence -> System.out.println(sentence)).count();
    System.out.println("----------peek后---------");
}

filter、sorted、distinct、limit

//filter过滤、sorted排序、distinct去重、limit限制
public void testGetTargetUser() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    List<Dept> results = ids.stream()
            .filter(s -> s.length() > 2)
            .distinct()
            //将基本类型int转换为包装类型Integer,或者将String转换成Integer
            .map(Integer::valueOf)
            //借助sorted指定按照数字大小正序排列
            //Comparator？
            .sorted(Comparator.comparingInt(o -> o))
            .limit(3)
            .map(id -> new Dept(id))
            .collect(Collectors.toList());
    System.out.println(results);
}

简单结果终止方法

public void testSimpleStopOptions() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    // 统计stream操作后剩余的元素个数
    System.out.println(ids.stream().filter(s -> s.length() > 2).count());
    // 判断是否有元素值等于205
    System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
    //找到第一个符合条件的元素时则终止流处理
    ids.stream().filter(s -> s.length() > 2)
            .findFirst()
            .ifPresent(s -> System.out.println("findFirst:" + s));
}

一旦一个Stream被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错，看下面示例：

//一旦一个Stream被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错，看下面示例：
public void testHandleStreamAfterClosed() {
    
}
//先到这里吧，看腻了。。。

结果收集终止方法

生成集合

生成拼接字符串

数据批量数学运算

并行Stream

机制说明

约束与限制

回答最初的问题

总结