Java Stream 知识脑图 - 流式处理

一、流概念

1. 结构

  • 流获取
  • 转换操作 : 可以有多个
  • 终止操作 : 只能有一个

Java Stream 知识脑图 - 流式处理_第1张图片

2. 类型

  • stream() : 单管道

  • parallelStream()

    • 多管道,并行流式处理,底层使用 ForkJoinPool 实现
    • 强制要求有序 : forEachOrdered()
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

//结果:1234567
list.stream().forEach(System.out::print);

//结果:5726134
list.parallelStream().forEach(System.out::print);

//结果:1234567
list.parallelStream().forEachOrdered(System.out::print);

3. 函数式接口

  • 接口中有且仅有一个抽象方法

  • 常见接口

Java Stream 知识脑图 - 流式处理_第2张图片

4. Lambda 表达式

  • 结构 : (参数) ‐> { 代码语句 }
  • 用于简化 函数式接口 的编写
  • 可以延迟运行,提升性能

 

二、流获取

1. Collection 子接口

  • 直接调用 stream() 方法

  • List

  • Set

  • Vector

List list = new ArrayList<>();
Stream stream1 = list.stream();

Set set = new HashSet<>();
Stream stream2 = set.stream();

Vector vector = new Vector<>();
Stream stream3 = vector.stream();

 

2. Map

  • 不是 Collection 子接口,其 K-V 数据结构不符合流元素特征,所以需根据 Key、Value、Entry 分别获取

Map map = new HashMap<>();
// ...
Stream keyStream = map.keySet().stream();
Stream valueStream = map.values().stream();
Stream> entryStream = map.entrySet().stream();

3. Array

  • 数组无法添加默认方法,故使用 Stream.of() 方法获取

String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
Stream stream = Stream.of(array);

三、转换操作

1. filter( T -> boolean )

  • 过滤数据,保留条件为 true 的元素

List list = Arrays.asList(20, 23, 25, 28, 30, 33, 37, 40);
//从指定数据集合中过滤出大于等于30的数据集合
List collect = list.stream().filter(x -> x >= 30).collect(Collectors.toList());
//结果:[30, 33, 37, 40]
System.out.println(collect);

2. map( T -> R )

  • 转换数据,将转换后的数据存回流中

List list = Arrays.asList("1", "2", "3", "4", "5", "6");

List collect1 = list.stream().map(x -> Long.parseLong(x)).collect(Collectors.toList());
//结果:[1, 2, 3, 4, 5, 6]
System.out.println(collect1);

//结果:111111
list.stream().mapToInt(x -> x.length()).forEach(System.out::print);
System.out.println("");

//结果:111111
list.stream().mapToLong(x -> x.length()).forEach(System.out::print);
System.out.println("");

//结果:1.01.01.01.01.01.0
list.stream().mapToDouble(x -> x.length()).forEach(System.out::print);

3. flatMap( T -> Stream )

  • 将流中的 元素 映射为一个 流,再把每个流连接为一个流

List>  list = new ArrayList>(){
    {
            add(Lists.newArrayList("a","b","c"));
            add(Lists.newArrayList("d","e","f"));
            add(Lists.newArrayList("j","k","y"));
        }};
//结果:[[a, b, c], [d, e, f], [j, k, y]]
System.out.println(list);
List collect = list.stream().flatMap(List::stream).collect(Collectors.toList());
//结果:[a, b, c, d, e, f, j, k, y]
System.out.println(collect);

4. distinct()

  • 元素去重,底层使用 equals() 方法做比较

List list = Arrays.asList("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
List collect = list.stream().distinct().collect(Collectors.toList());
//结果:[a, b, ab, abc, abcd, bd]
System.out.println(collect);

 

5. sorted( T -> boolean )

  • 元素排序,需事前 实现 Comparable 接口 或 自定义比较器

List list = Arrays.asList(5, 3, 7, 1, 4, 6);
List collect = list.stream().sorted((a, b) -> a.compareTo(b)).collect(Collectors.toList());
//结果:[1, 3, 4, 5, 6, 7]
System.out.println(collect);

6. limit( num )

  • 限制返回的元素个数

List list = Arrays.asList("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
List collect = list.stream().limit(3).collect(Collectors.toList());
//结果:[a, b, ab]
System.out.println(collect);

7. skip( num )

  • 跳过元素

List list = Arrays.asList("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
List collect = list.stream().skip(5).collect(Collectors.toList());
//结果:[ab, a, abcd, bd, abc]
System.out.println(collect);

 

8. peek( T -> void )

  • 挑出元素进行操作,但操作后的元素不返回到流中

List list = Arrays.asList("a", "b", "ab", "abc", "a", "ab", "a", "abcd", "bd", "abc");
//结果:abababcaabaabcdbdabc
list.stream().peek(x -> x.toUpperCase()).forEach(System.out::print);

//结果:ABABABCAABAABCDBDABC
list.stream().map(x -> x.toUpperCase()).forEach(System.out::print);

 

三、终止操作

1. forEach

  • forEach : 支持并行处理

forEachOrdered : 强制要求有序处理,速度较慢

List list = Arrays.asList("a", "b", "ab");

//结果:a b ab
list.stream().forEach(x -> System.out.print(x+' '));
System.out.println("");

//可以简化
//结果:a b ab
list.forEach(x -> System.out.print(x+' '));
System.out.println("");

//结果:a b ab
list.stream().forEachOrdered(x -> System.out.print(x+' '));

 

2. collect

  • toMap : 将 数据流 转换成 Map,里面包含的元素是 key / value 形式

  • toSet : 将 数据流 转换成 Set,里面包含的 元素不可重复

  • toList : 将 数据流 转换成 List,里面包含的 元素有序

  • joining : 元素间 拼接 分割符,并返回 字符串

  • groupingBy : 分组,可以将 List 转换成 Map

  • couting : 统计 元素数量

  • maxBy : 获取 最大的元素

  • minBy : 获取 最小的元素

  • summarizingInt : 汇总 Integer 类型的元素,返回 IntSummaryStatistics,可再调用具体方法进行统计

    • getCount : 统计数量
    • getSum : 求和
    • getMin : 获取最小值
    • getMax : 获取最大值
    • getAverage : 获取平均值
  • summarizingLong : 汇总 Long 类型元素,用法同 summarizingInt

  • summarizingDouble : 汇总 Double 类型元素,用法同 summarizingInt

  • averagingInt : 获取 Integer 元素平均值,返回一个 Double 类型数据

  • averagingLong : 获取 Long 元素平均值,返回一个 Double 类型数据

  • averagingDouble : 获取 Double 元素平均值,返回一个 Double 类型数据

  • mapping : 获取映射,可以将原始元素的一部分内容作为一个新元素返回

List list0 = Arrays.asList("a", "b", "ab");
Map collect0 = list0.stream().collect(Collectors.toMap(String::new, Function.identity()));
//结果:{ab=ab, a=a, b=b}
System.out.println(collect0);

List list = Arrays.asList("a", "b", "ab", "a", "b", "ab");
List collect1 = list.stream().collect(Collectors.toList());
//结果:[a, b, ab, a, b, ab]
System.out.println(collect1);

//结果:[a, ab, b]
Set collect2 = list.stream().collect(Collectors.toSet());
System.out.println(collect2);

String collect3 = list.stream().collect(Collectors.joining(","));
//结果:a,b,ab,a,b,ab
System.out.println(collect3);

Map collect4 = list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
//结果:{ab=2, a=2, b=2}
System.out.println(collect4);

Long collect = list.stream().collect(Collectors.counting());
//结果:6
System.out.println(collect);

List list1 = Arrays.asList(1, 3, 5, 7, 9, 11);

Integer collect5 = list1.stream().collect(Collectors.maxBy((a, b) -> a.compareTo(b))).orElse(null);
System.out.println(collect5);
//结果:11
System.out.println(collect5);

String collect6 = list1.stream().collect(Collectors.minBy((a, b) -> a.compareTo(b))).orElse(null);
//结果:1
System.out.println(collect6);

List list2 = Arrays.asList("2", "3", "5");
IntSummaryStatistics summaryStatistics = list2.stream().collect(Collectors.summarizingInt(x -> Integer.parseInt(x)));
long sum = summaryStatistics.getSum();
//结果:10
System.out.println(sum);

Double collect7 = list2.stream().collect(Collectors.averagingInt(x -> Integer.parseInt(x)));
//结果:3.3333333333333335
System.out.println(collect7);

List userList = new ArrayList() {
    {
  add(new User("jack",23));
  add(new User("james",30));
  add(new User("curry",28));
}};
List collect8 = userList.stream().collect(Collectors.mapping(User::getName, Collectors.toList()));
//[jack, james, curry]
System.out.println(collect8);

3. find

  • findFirst : 查找第一个元素,返回的类型为 Optional

  • findAny : 一般返回第一个元素,返回的类型为 Optional,但如果是并行情况,则不保证是第一个
List lst1 = Arrays.asList("Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");
List lst2 = Arrays.asList("Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");
 
Optional findFirst = lst1.parallelStream().filter(s -> s.startsWith("D")).findFirst();
Optional fidnAny = lst2.parallelStream().filter(s -> s.startsWith("J")).findAny();
 
System.out.println(findFirst.get()); // 总是打印出 David
System.out.println(fidnAny.get()); // 会随机打印出 Jack/Jill/Julia

4. match

  • allMatch : 所有元素都满足条件,返回 boolean 类型

  • anyMatch : 任意一个元素满足条件,返回 boolean 类型

  • noneMatch : 所有元素都不满足条件,返回 boolean 类型

List list = Arrays.asList(2, 3, 5, 7);

boolean allMatch = list.stream().allMatch(x -> x > 1);
//结果:true
System.out.println(allMatch);

boolean allMatch2 = list.stream().allMatch(x -> x > 2);
//结果:false
System.out.println(allMatch2);

boolean anyMatch = list.stream().anyMatch(x -> x > 2);
//结果:true
System.out.println(anyMatch);

boolean noneMatch1 = list.stream().noneMatch(x -> x > 5);
//结果:false
System.out.println(noneMatch1);

boolean noneMatch2 = list.stream().noneMatch(x -> x > 7);
//结果:true
System.out.println(noneMatch2);

 

5. count

统计数量,返回 long 类型,与集合的 size() 方法类似

List list = Arrays.asList("a", "b", "ab");
long count = list.stream().count();
//结果:3
System.out.println(count);

6. max、min

  • max : 获取最大值,返回 Optional 类型

  • min : 获取最小值,返回 Optional 类型
List list = Arrays.asList(2, 3, 5, 7);

Optional max = list.stream().max((a, b) -> a.compareTo(b));
//结果:7
System.out.println(max.get());

Optional min = list.stream().min((a, b) -> a.compareTo(b));
//结果:2
System.out.println(min.get());

 

7. reduce

  • 规约操作,将整个数据流规约成一个值

  • 两个参数 : 循环计算的初始值、计算累加器

  • count、max、min 底层就是使用 reduce 实现
List list = Arrays.asList(2, 3, 5, 7);

Integer sum1 = list.stream().reduce(0, Integer::sum);
//结果:17
System.out.println(sum1);

Optional reduce = list.stream().reduce((a, b) -> a + b);
//结果:17
System.out.println(reduce.get());

Integer max = list.stream().reduce(0, Integer::max);
//结果:7
System.out.println(max);

Integer min = list.stream().reduce(0, Integer::min);
//结果:0
System.out.println(min);


Optional reduce1 = list.stream().reduce((a, b) -> a > b ? b : a);
//2
System.out.println(reduce1.get());

 

8. toArray

  • 数组操作,将 数据流 转换成 数组
List list = Arrays.asList("a", "b", "ab");
String[] strings = list.stream().toArray(String[]::new);
//结果:a b ab
for (int i = 0; i < strings.length; i++) {
  System.out.print(strings[i]+" ");
}

9. concat

  • 将 两个流 合并为 一个流

Stream streamA = Stream.of("张无忌");
Stream streamB = Stream.of("张翠山");
Stream result = Stream.concat(streamA, streamB);

 

你可能感兴趣的:(个人自学,Java,java)