项目上用到了stream流，找篇blog，转载一下，介绍下Stream流的用法。
1 流概述
流是 JDK8 新增的成员,允许以声明性方式处理数据集合,可以把 Stream 流看作是遍历数据集合的一个高级迭代器
使用流的好处: 代码以声明性方式书写:说明想要完成什么,而不是说明如何完 成一个操作 可以把几个基础操作连接起来,来表达复杂的数据处理的流水 线,同时保持代码清晰可读
流是什么?
从支持数据处理操作的源生成元素序列.数据源可以是集合,数组 或 IO 资源
从操作角度来看,流与集合是不同的. 流不存储数据值; 流的目的 是处理数据,它是关于算法与计算的. 如果把集合作为流的数据源,创建流时不会导致数据流动; 如果流 的终止操作需要值时,流会从集合中获取值; 流只使用一次 流中心思想是延迟计算,流直到需要时才计算值
流使用时一般包括三件事:
1) 一个数据源(如集合)来执行一个查询;
2) 一个中间操作链,形成一条流的流水线
3) 一个终端操作,执行流水线,生成结果
2 Stream流的几种获得方式
public class Test01 {
public static void main(String[] args) {
//1 如何获得流,可以通过 Collection 集合,数据, 根据字面量获得流
// 1.1 通过 Collection 获得流
List<String> list = new ArrayList<>();
Collections.addAll(list, "aa", "hello", "jj", "dd", "mm", "test");
Stream<String> stream1 = list.stream();
System.out.println(stream1);
stream1.forEach(System.out::println);
// 1.2 根据数组获得流
String[]data = {"zhangsan","lisi","wangwu"};
Stream<String> stream2 = Arrays.stream(data);
stream2.forEach(s -> System.out.print(s + " "));
System.out.println();
// 1.3 直接通过值获得流
Stream<String> stream3 = Stream.of("1", "2", "3", "4");
stream3.forEach(s -> System.out.print(s + " "));
System.out.println();
// 1.4 无限流
Stream.iterate(100, x -> x + 3).limit(10).forEach(s -> System.out.print(s + " "));
System.out.println();
}
}
3 Stream流的筛选操作
public class Test01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "aa", "aa", "cc", "d","bb");
Stream<String> stream = list.stream();
//流的筛选与切片
//去重:distinct()
stream.distinct().forEach(System.out::println);
System.out.println("-------------1-----------");
//过滤filter(Predicate<? super T> predicate); 传递一个Predicate接口
// stream.filter(x -> x.length()>2).forEach(System.out::println);
//java.lang.IllegalStateException: 流只能使用一次
list.stream().filter(x -> x.length() > 2).forEach(System.out::println);
System.out.println("-------------2-----------");
//sorted()排序操作 Comparator<? super T> comparator 传递一个Comparator接口
list.stream().sorted(String::compareTo).forEach(System.out::println);
System.out.println("-------------3-----------");
//limt()截断操作
list.stream().limit(5).forEach(System.out::println);
System.out.println("--------------4----------");
//skip()跳过
list.stream().skip(3).forEach(System.out::println);
System.out.println("---------------5---------");
}
}
4 Stream流的map映射
public class Test02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee");
//map(Function<? super T, ? extends R> mapper); 传递一个Function接口
//为每个元素应用toUpperCase()把小写转换为大写
list.stream().map(String::toUpperCase).forEach(System.out::println);
//list每个每个元素的长度，然后拼接空格 2 2 2 2 1 6
list.stream().map(String::length).map(len->len + " ").forEach(System.out::println);
System.out.println("----------2-------");
//转换为数值流
List<Integer> integerList= Arrays.asList(54,1,78,90,345);
IntStream intStream = integerList.stream().mapToInt(x->x);
intStream.forEach(x->System.out.print(x+" "));
}
}
5 Stream流的查找与匹配
public class Test03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");
//allMatch()判断流中所有的元素是否都匹配给定的谓词
System.out.println(list.stream().allMatch(s -> s.length() > 3)); //false
//anyMatch()判断流中是否有某个元素可以匹配指定的谓词
System.out.println(list.stream().anyMatch(s -> s.equals("wkcto"))); //true
//noneMathc()判断流中的元素是否都没有匹配指定谓词的
System.out.println(list.stream().noneMatch(s -> s.equals("jj"))); //false
//findAny()和findFirst()的返回值类型均为Optional<T>
//查找任意一个
System.out.println(list.stream().filter(s -> s.length() > 5).findAny().get());
//查找第一个
try {
System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().get());
}catch (Exception e) {
e.printStackTrace();
}
//查找第一个，如果不加orElse 会输出Optional.empty
System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().orElse("不存在"));
}
}
6 Stream流的reduce规约
public class Test04 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");
//1 forEach 遍历
list.stream().forEach(System.out::println);
//2 cout 统计
System.out.println(list.stream().filter(x -> x.length() > 2).count());
//3 reduce 归纳合并
//传递的是BinaryOperator<T> accumulator 接口
Optional<String> reduce = list.stream().reduce((s1, s2) -> s1 + "--" + s2);
System.out.println(reduce.get());
//传递Consumer<? super T> consumer 接口
reduce.ifPresent(System.out::println);
//4数值操作
List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);
//5求和,指定初始值
//reduce(T identity, BinaryOperator<T> accumulator);
System.out.println(list2.stream().reduce(0, Integer::sum));
//求和,没有初始值
//Optional<T> reduce(BinaryOperator<T> accumulator);
System.out.println(list2.stream().reduce((x, y) -> x + y).orElse(0));
//6最值
//Optional<T> reduce(BinaryOperator<T> accumulator);
System.out.println(list2.stream().reduce(Math::max).get());
System.out.println(list2.stream().reduce(Math::min).get());
}
7 Stream流映射到数值流
public class Test05 {
public static void main(String[] args) {
List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);
//求和 IntStream mapToInt(ToIntFunction<? super T> mapper);
System.out.println(list2.stream().mapToInt(x->x).sum() );
//最大值 OptionalInt max();
//public int getAsInt() {
// if (!isPresent) {
// throw new NoSuchElementException("No value present");
// }
// return value;
// }
System.out.println(list2.stream().mapToInt(x->x).max().getAsInt() );
//最小值 OptionalInt min();
//public int orElse(int other) {
// return isPresent ? value : other;
//}
System.out.println(list2.stream().mapToInt(x->x).min().orElse(0) );
//平均值
//DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
//OptionalDouble average();
System.out.println(list2.stream().mapToDouble(x->x).average().getAsDouble());
//求最大值
System.out.println(list2.stream().max(Integer::compareTo).get());
//求最小值
list2.stream().min(Integer::compareTo).ifPresent(System.out::println);
}
}
8 Stream流的collect规约
public class Test06 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "ss", "aa", "hello", "jj","hello","xx", "good");
//把 stream 流转换为集合
Set<String> stringSet = list.stream().collect(Collectors.toSet());
System.out.println( stringSet );
//把 Stream 流转换为数组
Object[] objects = list.stream().toArray();
System.out.println( Arrays.toString(objects));
String[] toArray = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(toArray));
//Stream 流转换为字符串
String collect = list.stream().collect(Collectors.joining(","));
System.out.println(collect);
}
}
————————————————
版权声明：本文为CSDN博主「ChengZi~」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38339124/article/details/93423360