Java8集合常用API_java8 api

常用api

排序

stream().sorted(Comparator.comparing(StudentInfo::getAge))
1

排序，null值放在集合最后面，默认null值会放在集合最前面

stream().sorted(Comparator.comparing(SchedulingPlanDetailsResponse.GateDTO::getRank, Comparator.nullsLast(Integer::compareTo)))

1
2

filter 筛选

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
List<Integer> stream = integerList.stream().filter(i -> i > 3).collect(Collectors.toList());;
1
2

distinct 去除重复元素

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().distinct();
1
2

分类

stream().collect(groupingBy(Dish::getType))
1

limit 返回指定流个数

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().limit(3);
1
2

skip 跳过流中的元素

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().skip(2);
1
2

map 流映射
所谓流映射就是将接受的元素映射成另外一个元素

List<String> stringList = Arrays.asList("Java 8", "Lambdas", "In", "Action");
Stream<Integer> stream = stringList.stream().map(String::length);

List<ModelingStationVO> data = resultModel.getData();
List<String> stationList = data.stream().map(ModelingStationVO::getId).collect(Collectors.toList());
1
2
3
4
5

mapToInt 、mapToDouble
转换成intStream后可以用一些计算的API

int count = splitResult.stream ().mapToInt (res -> modelingStationExtendMapper.addBatch (res)).sum ();
double sum = value.stream().mapToDouble(rows -> Double.parseDouble(rows.get(2))).sum();
1
2

flatMap 流转换
将一个流中的每个值都转换为另一个流

List<List<Long>> senids = newFetchParams.stream().map(FetchParam::getIdarrayLongs).collect(Collectors.toList());
List<Long> collect = senids.stream().flatMap(list -> list.stream()).collect(Collectors.toList());
1
2

Map 循环

map.forEach((key, value) -> {
     System.out.println(key + "：" + value);
});
1
2
3

List转Map

Map<String, ModelingStation> listMap = modelingStationList.stream()
                .collect(Collectors.toMap(ModelingStation::getId, account -> account));
1
2

元素匹配(一般用于判断)

1.allMatch 匹配所有

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().allMatch(i -> i > 3)) {
    System.out.println("值都大于3");
}
1
2
3
4

2.anyMatch 匹配其中一个

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().anyMatch(i -> i > 3)) {
  System.out.println("存在大于3的值");
}
1
2
3
4

等同于

for (Integer i : integerList) {
    if (i > 3) {
        System.out.println("存在大于3的值");
        break;
    }
}
1
2
3
4
5
6

3.noneMatch 全部不匹配

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().noneMatch(i -> i > 3)) {
    System.out.println("值都小于3");
}
1
2
3
4

终端操作

统计流中元素个数

通过 count统计出流中元素个数

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Long result = integerList.stream().count();
1
2

查找

提供了两种查找方式

1、findFirst 查找第一个

//查找到第一个大于 3 的元素并打印
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findFirst();
1
2
3

2、findAny 随机查找一个

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findAny();
1
2

通过 findAny 方法查找到其中一个大于三的元素并打印，因为内部进行优化的原因，当找到第一个满足大于三的元素时就结束，该方法结果和 findFirst 方法结果一样。提供 findAny 方法是为了更好的利用并行流，findFirst 方法在并行上限制更多

reduce 将流中的元素组合起来

假设我们对一个集合中的值进行求和

JDK8 之前:

int sum = 0;
for (int i : integerList) {
sum += i;
}
1
2
3
4

JDK8 之后通过 reduce 进行处理

int sum = integerList.stream().reduce(0, (a, b) -> (a + b));
1

一行就可以完成，还可以使用方法引用简写成：

int sum = integerList.stream().reduce(0, Integer::sum);
1

reduce 接受两个参数，一个初始值这里是 0，一个 BinaryOperator accumulator 来将两个元素结合起来产生一个新值，

另外, reduce 方法还有一个没有初始化值的重载方法

获取流中最小最大值

通过 min/max 获取最小最大值

OptionalInt min = menu.stream().mapToInt(Dish::getCalories).min();
OptionalInt max = menu.stream().mapToInt(Dish::getCalories).max();
1
2