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 combiner)

将第一个数组经过一系列操作复制到另一个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]