java stream 简单函数
写在前面
本文为笔者学习的一些心得，如有问题，评论请轻喷
本文分为以下部分：
中间操作
终止操作
归纳
中间操作
对 list 进行操作，返回一个新的 list
| 主要函数 | 作用 |
|---|---|
| filter | 过滤操作 |
| limit | 截取限制个数的 list |
| skip | 对 list 进行跳过操作 |
| distinct | 去重操作 |
| map | 提取 list 中的每个元素进行操作，改变原元素 |
| flatMap | 将多个流放在一个流上，然后再组合 |
| sorted | 对 list 进行排序操作，可以定制排序 |
| concat | 拼接，将两个list拼接到一个list上 |
筛选
filter
filter 对 list 中的数据进行过滤操作
List<Integer> list = Arrays.asList(1, 2, 2, 3);
List<Integer> integers = list.stream().filter(i -> i > 1).collect(Collectors.toList());
System.out.println(integers);
[2, 2, 3]
limit
limit 对 list 进行限制个数操作
List<Integer> list = Arrays.asList(1, 2, 2, 3);
list.stream().limit(2).forEach(System.out::println);
List<Integer> integers = list.stream().limit(2).map(i -> i * 3).collect(Collectors.toList());
System.out.println(integers);
1
2
[3, 6]
skip
skip 对 list 进行跳过操作
List<Integer> list = Arrays.asList(1, 2, 2, 3);
List<Integer> integers = list.stream().skip(2).collect(Collectors.toList());
System.out.println(integers);
[2, 3]
distinct
distinct 去重
List<Integer> list = Arrays.asList(1, 2, 2, 3);
List<Integer> integers = list.stream().distinct().collect(Collectors.toList());
System.out.println(integers);
[1, 2, 3]
映射
map
map 对 list 中的每个数进行操作
List<Integer> list = Arrays.asList(1, 2, 2, 3);
List<Integer> integers = list.stream().map(i -> i * i).collect(Collectors.toList());
System.out.println(integers);
[1, 4, 4, 9]
flatMap
flatMap 将多个流（一般为多维）放在一个流上，然后再组合（可以看成 降维）
Integer[][] ary = {{1,2,3,4,5},{6,7,8,9,10}};
List<Integer> integers = Arrays.stream(ary).flatMap(i -> Arrays.stream(i)).collect(Collectors.toList());
System.out.println(integers);
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
排序
sorted
sort 对 list 进行排序操作，可以定制排序
//正序排序
List<Integer> list = Arrays.asList(5,4,3,2,1);
List<Integer> integers = list.stream().sorted().collect(Collectors.toList());
System.out.println(integers);
[1, 2, 3, 4, 5]
//倒序排序
List<Integer> integers1 = integers.stream().sorted(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
}).collect(Collectors.toList());
System.out.println(integers1);
[5, 4, 3, 2, 1]
拼接
concat
concat，拼接，将两个list拼接到一个list上
List<String> list1 = Arrays.asList("1", "2");
List<String> list2 = Arrays.asList("3", "4");
List<String> list3 = Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());
System.out.println(list3);
[1, 2, 3, 4]
终止操作
无法返回新 list
| 主要函数 | 作用 |
|---|---|
| allMatch | 检查是否所有值都匹配 |
| anyMatch | 检查是否至少匹配一个元素 |
| noneMatch | 检查是否没有一项匹配 |
| findFirst | 查找第一个元素 |
| count | 计算总数 |
| max、min | 取出最大、最小值（可自定义） |
| forEach | 迭代 list 中的每个数，和map不同，无法对原元素进行操作 |
allMatch
allMatch 检查是否所有值都匹配，返回boolean类型
List<Integer> list = Arrays.asList(1, 2, 2, 3);
System.out.println(list.stream().allMatch(x -> x < 2));
false
anyMatch
anyMatch 检查是否至少匹配一个元素，返回boolean类型
List<Integer> list = Arrays.asList(1, 2, 2, 3);
System.out.println(list.stream().anyMatch(x -> x < 2));
true
noneMatch
noneMatch 检查是否没有一项匹配，返回boolean类型
List<Integer> list = Arrays.asList(1, 2, 2, 3);
System.out.println(list.stream().noneMatch(x -> x < 2));
false
findFirst
findFirst 查找第一个
List<Integer> list = Arrays.asList(1, 2, 2, 3);
Optional<Integer> first = list.stream().findFirst();
System.out.println(first.get());
1
count
count 计算总共有多少个元素，配合其他操作（多为中间操作）使用
List<Integer> list = Arrays.asList(1, 2, 2, 3);
System.out.println(list.stream().count());
4
max、min
max 查找 list 中的最大值，可以自定义何为最大值；
min 查找 list 中的最小值，可以自定义何为最小值；
List<Integer> list = Arrays.asList(1, 2, 2, 3);
Optional<Integer> max = list.stream().max(Integer::compareTo);
System.out.println(max.get());
3
Optional<Integer> min = list.stream().min(Integer::compareTo);
System.out.println(min.get());
1
forEach
forEach 迭代 list 中的每个数
List<Integer> list = Arrays.asList(1, 2, 2, 3);
list.stream().forEach(System.out::println);
1
2
2
3
归纳
reduce
reduce(BinaryOperator<P_OUT> accumulator) 类似赫夫曼树的生成规则
首先取出前俩元素进行操作，删除前俩元素，再把得出的值压回 list 头部，上面步骤重复
List<Integer> list = Arrays.asList(1, 2, 2, 3);
Optional<Integer> reduce = list.stream().reduce((o1, o2) -> o1 + o2);
// ==>
Optional<Integer> reduce1 = list.stream().reduce((o1, o2) -> {
System.out.print("o1:" + o1);
System.out.print(" o2:" + o2);
int i = o1 + o2;
System.out.print(" sum:" + i);
System.out.println();
return i;
});
System.out.println(reduce.get());
System.out.println(reduce1.get());
o1:1 o2:2 sum:3
o1:3 o2:2 sum:5
o1:5 o2:3 sum:8
8
8
reduce(final P_OUT identity, final BinaryOperator<P_OUT> accumulator) 带有初始值，与上方逻辑一致
List<Integer> list = Arrays.asList(1, 2, 2, 3);
Integer reduce = list.stream().reduce(100, (o1, o2) -> o1 + o2);
// ==>
Integer reduce1 = list.stream().reduce(100, (o1, o2) -> {
System.out.print("o1:" + o1);
System.out.print(" o2:" + o2);
int i = o1 + o2;
System.out.print(" sum:" + i);
System.out.println();
return i;
});
System.out.println(reduce);
System.out.println(reduce1);
o1:100 o2:1 sum:101
o1:101 o2:2 sum:103
o1:103 o2:2 sum:105
o1:105 o2:3 sum:108
108
108
reduce(R identity, BiFunction<R, ? super P_OUT, R> accumulator, BinaryOperator
将第一个数组经过一系列操作复制到另一个list
List<Integer> list = Arrays.asList(1, 2, 2, 3);
ArrayList<Integer> newList = new ArrayList<>();
ArrayList<Integer> integers = Stream.of(list.toArray()).reduce(newList, (o1, o2) -> {
System.out.print("o1:"+o1);
System.out.print(" o2:"+o2);
System.out.println();
o1.add((Integer)o2);
return o1;
}, (o1, o2) -> null);
System.out.println(integers);
System.out.println(newList);
o1:[] o2:1
o1:[1] o2:2
o1:[1, 2] o2:2
o1:[1, 2, 2] o2:3
[1, 2, 2, 3]
[1, 2, 2, 3]
