Stream 是 Java 8 新增的重要特性,它提供函数式编程支持并允许以管道方式操作集合,流操作会遍历数据源,使用管道式操作处理数据后生成结果集合,这个过程通常不会对数据源造成影响。
同时 stream 不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组、Java 容器或 I/O channel 等。在 Stream 中的操作每一次都会产生新的流,内部不会像普通集合操作一样立刻获取值,而是惰性取值,只有等到用户真正需要结果的时候才会执行。
Stream 代表数据流,流中的数据元素的数量可能是有限的,也可能是无限的。
流和集合的区别
生成流的方式主要有五种
Stream<Integer> stream = Stream.of(1,2,3,4,5);
List<Integer> integerList = new ArrayList<>();
integerList.add(1);
integerList.add(2);
integerList.add(3);
integerList.add(4);
integerList.add(5);
Stream<Integer> listStream = integerList.stream();
int[] intArr = {1, 2, 3, 4, 5};
IntStream arrayStream = Arrays.stream(intArr);
通过 Array.stream 方法生成流,生成的是数值流 [IntStream] 而不是对象流 Stream
注:使用数值流可以避免计算过程中拆箱装箱,提高性能
Stream API 提供了 mapToInt、mapToDouble、mapToLong 三种方式将对象流 [Stream] 转换成对应的数值流,同时提供了 boxed 方法将数值流转换成对象流
try {
Stream<String> fileStream = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
} catch (IOException e) {
e.printStackTrace();
}
通过 Files.lines方法得到一个流,并且得到的每个流都是给定文件中的一行
iterator
Stream<Integer> iterateStream = Stream.iterate(0, n -> n + 2).limit(5);
iterator 方法接受两个参数,第一个为初始化值,第二个为进行的函数操作,因为 iterator 生成的流为无限流,通过 limit 方法对流进行了截断,只生成 5 个偶数
generator
Stream<Double> generateStream = Stream.generate(Math::random).limit(5);
generator 方法接受一个参数,方法参数类型为 Supplier,由它为流提供值。generator 生成的流也是无限流,因此通过 limit 方法对流进行截断
流的操作类型主要分为两种:中间操作、终止操作
distinct 保证数据源中的重复元素在结果中只出现一次,它使用 equals() 方法判断两个元素是否相等
/**filter去重方法实现类**/
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Set<Object> seen = ConcurrentHashMap.newKeySet();
return t -> seen.add(keyExtractor.apply(t));
}
// 1.String 集合去重
List<String> list_str = list.stream().distinct().collect(Collectors.toList());
// 2.实体对象集合去重,判断依据是整个实体对象
List<Student> list_student = list.stream(S).distinct().collect(Collectors.toList());
// 3.根据 list 中某个属性去重
List<Student> list_name1 = liststream().collect(collectingAndThen(
toCollection(() -> new
TreeSet<(Comparator.comparing(Student::getName))),
ArrayList::new));
List<Student> list_name2 = list.stream().filter(distinctByKey(Student::getName))
.collect(Collectors.toList());
在第3中情况中,我们首先创建了一个方法作为 Stream.filter() 的参数,其返回类型为 Predicate,原理就是判断一个元素能否加入到 Set 中去,用到了 Set 集合的属性
filter 对所有元素进行检查,只有断言函数为真的元素才会出现在结果中,不会对数据源进行修改
// 输出不为空的字符
List<String> list_notNull = list.stream().filter(ObjectUtil::isNotNull).toList();
// 输出ID大于 6的 user对象
List<User> filetr = userList.stream().filter(x-> x.getId() > 6).collect(Collectors.toList());
map 根据传入的mapper函数对元素一对一映射,即数据源中的每一个元素都会在结果中被替换(映射)为mapper函数的返回值,也可以根据处理返回不同数据类型
// 输出id
List<Long> list_ids = list.stream().map(ProblemList::getId).toList();
// 用指定字符连接流中的每个名称,并输出
String str_name = list.stream().map(ProblemList::getName).collect(Collectors.joining(", "));
// 输出新的IdName集合
List<IdName> list_IdName = list.stream().map(
x -> new IdName().setId(x.getId()).setName(x.getName())
).toList();
flatMap 将映射后的流的元素全部放入到一个新的流中
List<IdName> list = new ArrayList<>();
list.add(new IdName().setId(1L).setName("aa,bb,cc"));
list.add(new IdName().setId(2L).setName("11,22,33"));
list.add(new IdName().setId(3L).setName("ⅠⅠ,ⅡⅡ,ⅢⅢ"));
// 数据拆分一对多映射
list.stream().flatMap(x -> Arrays.stream(x.getName().split(","))).forEach(System.out::println);
sorted 将流中的元素进行排序
// 根据名字倒序
List<User> list = userList.stream().sorted(Comparator.comparing(User::getName).reversed()).toList();
limit 返回指定数量的前n个元素的流
// 获取前5条数据
List<User> list_limit = list.stream().limit(5).toList();
skip 返回丢弃了前n个元素的流,如果流中的元素小于或者等于n,则返回空的流
// 跳过第3条取后面的数据
List<User> list_skip = list.stream().skip(3).toList();
peek 主要作用是在流的每个元素上执行一个操作,比如打印值、记录日志、调试等。通常用于调试和观察流的中间状态,而不会对流的内容进行修改
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> doubledNumbers = numbers.stream()
.peek(n -> System.out.println("Processing number: " + n))
.map(n -> n * 2)
.collect(Collectors.toList());
创建一个整数列表 numbers,然后通过流的方式对每个元素进行处理。在流的 peek 操作中,打印元素的值,然后我们使用 map 操作将每个数字乘以2,并将结果收集到一个新的列表中。
运行上面代码时,会看到以下输出:
需要注意的是,peek 方法是一个中间操作,它不会触发流的终端操作。如果你希望对流的内容进行修改或获取最终的结果,你需要在 peek 方法之后添加一个终止操作,比如 collect、forEach 等。
//每个用户ID加1输出
userList.stream().peek(user -> user.setId(user.getId()+1)).forEach(System.out::println);
// allMatch:检查是否匹配所有元素
boolean matchAll = userList.stream().allMatch(user -> "北京".equals(user.getCity()));
// anyMatch:检查是否至少匹配一个元素
boolean matchAny = userList.stream().anyMatch(user -> "北京".equals(user.getCity()));
// noneMatch:检查是否没有匹配所有元素,返回boolean
boolean nonaMatch = userList.stream().allMatch(user -> "云南".equals(user.getCity()));
count 返回流中的元素的数量
long count = userList.stream().filter(user -> user.getAge() > 20).count();
collect 将流转换为其他形式。接收一个 Collector 接口的实现,用于给 stream 中元素做汇总的方法。下面是一些常见的搜集器:
把流中元素收集到 List 集合中
// 将用户ID存放到List集合中
List<Integer> idList = userList.stream().map(User::getId).collect(Collectors.toList());
把流中元素收集到 Map 集合中
// 将 ID和 user以 Key-Value形式存放到 Map集合中
Map<Long,User> userMap = list.stream().collect(Collectors.toMap(User::getId, x -> x, (a,b)->a));
注意,这里的 toMap方法中多了一个参数【(a,b) -> a】,表示如果遇到 Key相同的情况,Value保存新值(b)或旧值(a)
把流中元素收集到 Set 集合中
// 将用户所在城市存放到Set集合中
Set<String> citySet = userList.stream().map(User::getCity).collect(Collectors.toSet());
计算流中元素的个数
// 符合条件的用户总数
long count = userList.stream().filter(user -> user.getId()>1).collect(Collectors.counting());
对流中元素的整数属性求和
// 计算ID大于2的用户ID之和
Integer sumInt = userList.stream()
.filter(user -> user.getId()>2)
.collect(Collectors.summingInt(User::getId));
计算元素 Integer 属性的均值
// 计算用户的平均年龄
Double avg = userList.stream().collect(Collectors.averagingInt(Student::getAge));
连接流中的每个字符串
// 将用户所在城市,以指定分隔符链接成字符串
String joinCity = userList.stream().map(User::getCity).collect(Collectors.joining("||"));
根据比较器选择最大值、最小值
// 筛选元素中年龄最大的用户
User maxId = userList.stream().collect(Collectors.maxBy(Comparator.comparingLong(User::getAge))).get();
// 筛选元素中ID最小的用户
User maxId = userList.stream().collect(Collectors.minBy(Comparator.comparingLong(User::getId))).get();
根据某属性值对流分组,属性为K,结果为V
// 以城市对用户进行分组
Map<String,List<User>> groupCity = userList.stream().collect(Collectors.groupingBy(User::getCity));
forEach 遍历流的每一个元素,执行指定的 action。它是一个终点操作,但不保证按照流的 encounter order 顺序执行,对于有序流要按照顺序执行可使用 forEachOrdered 方法
list.stream().forEach(System.out::println);
findFirst 返回第一个元素,如果流为空,返回空的Optional
User user = list.stream().findFirst().orElse(null);
orElse( null ):表示如果一个都没找到 返回 null;orElse() 中可以塞默认值,如果找不到就会返回默认值
max、min 返回流中的最大值、最小值
Long max_id = list.stream().map(User::getId).max(Long::compare).orElse(0L);
Integer min_age = list.stream().map(User::getAge).min(Comparator.comparing(x -> x)).orElse(null);
sum 求流的某属性之和
// 求ID之和
int sum = userList.stream().mapToInt(User::getId).sum();
concat 用来连接类型一样的两个流
// 求ID之和
List<Integer> list1 = Arrays.asList(1,2,3);
List<Integer> list2 = Arrays.asList(4,3,2);
Stream.concat(list1.stream(),list2.stream()).forEach(System.out::println);
toXXX toArray 将一个流转换成数组,如果想转换成其他集合类型,也可调用 collect 方法,利用 Collectors.toXXX方法进行转换
List<User> toList = userList.stream().toList();
Integer[] integers = Stream.of(1, 2, 3, 4, 5).toArray(Integer[]::new);
reduce 把stream中的元素组合起来
它需要我们首先提供一个起始种子,然后依照某种运算规则使其与stream的第一个元素发生关系产生一个新的种子,这个新的种子再紧接着与stream的第二个元素发生关系产生又一个新的种子,就这样依次递归执行,最后产生的结果就是reduce的最终产出
// 没有起始值,返回为 Optional类型
Optional<Long> reduce = list.stream().map(ProblemList::getId).reduce(Long::sum); // 结果:15
// 给一个起始值 1
Long reduce_1 = list.stream().map(ProblemList::getId).reduce(1L, Long::sum); // 结果:16
好事定律:每件事最后都会是好事,如果不是好事,说明还没到最后。