Stream学习的特点

Stream流的创建

可以通过集合创建流，也可以通过Stream.of()方法直接创建流。例如：List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); Stream<String> stream = names.stream();

中间操作

中间操作允许对流进行各种转换和处理，例如过滤、映射、排序等。常见的中间操作包括filter、map、sorted等。

终端操作

终端操作是对流进行最终操作，触发流(中间操作)的处理。

常见的终端操作包括forEach、collect、reduce等。

Stream特点

惰性求值

Stream的操作通常是惰性求值的，只有在遇到终端操作时才会触发中间操作的执行。

并行处理

Stream API支持并行处理，可以通过parallel()方法将流转换为并行流，以提高处理大量数据时的效率。

函数式编程

Stream API借鉴了函数式编程的思想，可以通过Lambda表达式来传递操作

IDEA编辑器：记得光标浮在Stream代码附近：按一下Alt + Enter IDEA会自动帮我们做转换为循环，方便我们理解代码，也可以在For循环附件，帮我们转为Stream的代码

Java8提供了常用函数式接口

函数式接口就是我们常用的lambda表达式的内容。

  • Function<T,R> 转换型：接受一个输入参数，返回一个结果
  • Consumer<T> 消费型：接受一个输入参数，无返回
  • Predicate<T> 判断型：接受一个输入参数，返回Boolean结果
  • Supplier<T> 供给型：无参数，返回结果

函数式接口的应用

Lambda 4种函数式接口的应用

Stream流使用案例

我们先添加一个Pojo作为我们操作的对象 UserInfo

添加一个实体，方便我们模拟真实集合去测试方法。

@Data
public class UserInfo {
    private Integer id;
    private String name;
    private Integer isDelete;

    public UserInfo(Integer id, String name, Integer isDelete) {
        this.id = id;
        this.name = name;
        this.isDelete = isDelete;
    }
}

List -> Map

注意，如果List集合元素有重复，Map是不允许重复的，就需要考虑去重问题。

    public static void main(String[] args) {
        ArrayList<UserInfo> list = new ArrayList();
        list.add(new UserInfo(1, "张三", 1));
        list.add(new UserInfo(2, "李四", 2));
        list.add(new UserInfo(3, "王五", 3));
        list.add(new UserInfo(3, "赵六", 4));
        Map<Integer, UserInfo> userInfoMap = list.stream().collect(
                // Collectors.toMap参数是3个lambda表达式：生成键的映射函数、生成值的映射函数、合并函数（因为Map存储可能会重复，导致元素丢失，我们需要指定规则保留哪个）
                Collectors.toMap(
                        (UserInfo::getId), (userInfo -> userInfo), (k1, k2) -> {
                            // 合并函数，如果ID相同，保留isDelete的元素
                            if (k1.getIsDelete() > k2.getIsDelete()) {
                                return k1;
                            } else {
                                return k2;
                            }
                        })
        );
        userInfoMap.values().forEach(k -> {
            System.out.println(String.format("name=%s,isDelete=%s",k.getName(),k.getIsDelete()));
        });

Filter 过滤元素

.filter方法 对集合或Stream中的元素进行过滤，只保留满足特定条件的元素。

接受一个Predicate作为参数，该Predicate定义了过滤的条件。

public static void main(String[] args) {
    ArrayList<UserInfo> list = new ArrayList();
    list.add(new UserInfo(1, "张三", 1));
    list.add(new UserInfo(2, "李四", 2));
    list.add(new UserInfo(3, "王五", 3));
    list.add(new UserInfo(3, "赵六", 4));
    List<UserInfo> collect = list.stream()
            // 保留isDelete > 2 的元素
            .filter(userInfo -> userInfo.getIsDelete() > 2)
            .collect(Collectors.toList());
    collect.forEach(k -> {
        System.out.println(String.format("name=%s,isDelete=%s", k.getName(), k.getIsDelete()));
    });
    // 只获取保留元素ID列表
    LinkedList<Integer> collect1 = collect.stream()
            .map(UserInfo::getId)
            .collect(Collectors.toCollection(LinkedList::new));
    System.out.println("获取到的ID列表是" + collect1);
}

GroupingBy分组

我们日常SQL使用的时候，都是Group By实现分组。Stream也有类似功能，比如一个集合有3个组的员工，我们想获取每个组的员工，就可以通过.collect(Collectors.groupingBy(Obj::getXXX));实现。返回的集合是Map集合！

public static void main(String[] args) {
    ArrayList<UserInfo> list = new ArrayList();
    list.add(new UserInfo(1, "张三", 1));
    list.add(new UserInfo(2, "李四", 2));
    list.add(new UserInfo(3, "王五", 3));
    list.add(new UserInfo(3, "赵六", 4));
    Map<Integer, List<UserInfo>> collect = list.stream()
            .collect(Collectors.groupingBy(UserInfo::getId));
    collect.forEach((k,v) -> {
        

System.out.println(String.format("GroupID=%s,Element=%s",k.toString(),Arrays.toString(v.toArray())));
    });
}

统计数量

collect(Collectors.groupingBy(UserInfo::getId, Collectors.counting()));

排序 sorted + Comparator

原对象不会发生变更，新对象才会排序。

    public static void main(String[] args) {
        ArrayList<UserInfo> list = new ArrayList();
        list.add(new UserInfo(1, "张三", 1));
        list.add(new UserInfo(2, "李四", 2));
        list.add(new UserInfo(3, "王五", 3));
        list.add(new UserInfo(3, "赵六", 4));
        List<UserInfo> collect = list.stream()
                .sorted(Comparator
                        .comparing(UserInfo::getId)
                        .thenComparing(UserInfo::getIsDelete, Comparator.reverseOrder())  // 默认升序,多一个参数实现此字段倒序
                        // .reversed() // 实现所有条件排序后，再反转排序
                )
                .collect(Collectors.toList());
        collect.forEach(k -> {
            System.out.println(String.format("id=%s,name=%s,isDelete=%s", k.getId(), k.getName(), k.getIsDelete()));
        });
    }

Distinct 对集合元素去重

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList();
    list.add("A");
    list.add("A");
    list.add("B");
    list.add("A");
    List<String> collect = list.stream().distinct().collect(Collectors.toList());
    collect.forEach(k -> {
        System.out.println(String.format("Element=%s",k));
    });
}

FindFirst 返回第一个元素

    public static void main(String[] args) {
        ArrayList<UserInfo> list = new ArrayList();
        list.add(new UserInfo(1, "张三", 1));
        list.add(new UserInfo(2, "李四", 2));
        list.add(new UserInfo(3, "王五", 3));
        list.add(new UserInfo(3, "赵六", 4));
        list.stream().findFirst().ifPresent(System.out::println);

        UserInfo userInfo = list.stream().findFirst().get();
        System.out.println(userInfo);
    }

AnyMatch 与 AllMatch

AnyMatch匹配整个集合是否包含某元素

AllMatch匹配整个集合是否都是某元素

public static void main(String[] args) {
    ArrayList<UserInfo> list = new ArrayList();
    UserInfo user = new UserInfo(1, "张三", 1);
    list.add(user);
    list.add(new UserInfo(2, "李四", 2));
    list.add(new UserInfo(3, "王五", 3));
    list.add(new UserInfo(3, "赵六", 4));
    // 注意比较的是 地址值
    boolean anyMatch = list.stream().anyMatch(userInfo -> user == userInfo);
    System.out.println("AnyMatch结果：" + anyMatch);
    boolean allMatch = list.stream().allMatch(userInfo -> user == userInfo);
    System.out.println("AllMatch结果：" + allMatch);
}

Map用法，得到新数据

.map方法的作用：

  • 将一个对象转换为另一个对象。
  • 或者对对象进行某种处理，生成一个新的对象。
public static void main(String[] args) {
    ArrayList<UserInfo> list = new ArrayList();
    list.add(new UserInfo(1, "张三", 1));
    list.add(new UserInfo(2, "李四", 2));
    list.add(new UserInfo(3, "王五", 3));
    list.add(new UserInfo(3, "赵六", 4));
    List<String> collect = list.stream()
            .distinct()
            .map(UserInfo::getName)
            .collect(Collectors.toList());
    System.out.println(collect);
}

Peek - Stream打印日志

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList();
    list.add("A");
    list.add("A");
    list.add("B");
    list.add("A");
    List<String> collect = list.stream().distinct()
            .peek(e -> {
                System.out.println(e);
            })
            .collect(Collectors.toList());
}

max、min取值

max min用法一致！

    public static void main(String[] args) {
        ArrayList<UserInfo> list = new ArrayList();
        list.add(new UserInfo(1, "张三", 1));
        list.add(new UserInfo(2, "李四", 2));
        list.add(new UserInfo(3, "王五", 3));
        list.add(new UserInfo(3, "赵六", 4));
        Integer integer = list.stream()
                .distinct()
                .map(UserInfo::getId)
                // 如果List集合直接是int可直接用 .max(Integer::compare)
                .max(Integer::compare)
                .get();
        System.out.println(integer);
    }

Count统计元素个数

获取集合流元素的个数

public static void main(String[] args) {
    ArrayList<UserInfo> list = new ArrayList();
    list.add(new UserInfo(1, "张三", 1));
    list.add(new UserInfo(2, "李四", 2));
    list.add(new UserInfo(3, "王五", 3));
    list.add(new UserInfo(3, "赵六", 4));
    long count = list.stream().count();
    System.out.println(count);
}

flatMap 扁平化嵌套结构

flatMap 可以将嵌套的集合（如 List<List<T>>）扁平化为一个单一的集合（如 List<T>）。这意味着它将每个内部集合的元素提取出来，并将它们放入一个新的集合中。

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

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
            Arrays.asList("a", "b"),
            Arrays.asList("c", "d"),
            Arrays.asList("e", "f")
        );

        List<String> flatList = nestedList.stream()
            .flatMap(List::stream) // 将每个 List 转换为流并扁平化
            .collect(Collectors.toList()); // 收集到一个 List 中

        System.out.println(flatList); // 输出: [a, b, c, d, e, f]
    }
}
特殊说明：
上述文章均是作者实际操作后产出。烦请各位，请勿直接盗用！转载记得标注原文链接：www.zanglikun.com
第三方平台不会及时更新本文最新内容。如果发现本文资料不全，可访问本人的Java博客搜索：标题关键字。以获取最新全部资料 ❤