Java8 - Stream API 处理集合数据

Java 8的Stream API提供了一种功能强大的方式来处理集合数据，以函数式和声明式的方式进行操作。Stream API允许您对元素集合执行操作，如过滤、映射和归约，以简洁高效的方式进行处理。

下面是Java 8 Stream API的一些关键特性和概念：

① 创建流：您可以从各数据源创建流，如集合、数组或I/O通道。

② 中间操作：Stream提供了一组中间操作，可以链接在一起对数据进行转换或过滤。一些常见的中间操作包括filter、map、flatMap、distinct、sorted和limit。

③ 终端操作：终端操作用于生成结果或产生副作用。终端操作的示例包括forEach、collect、reduce、min、max和count。

④ 惰性求值：Stream支持惰性求值，这意味着中间操作只有在调用终端操作时才会执行。这样可以高效处理大型数据集。

⑤ 并行处理：Stream API还支持并行处理，允许您利用多核处理器加速对大型数据集的操作。您可以使用parallel或parallelStream方法将顺序流转换为并行流。

01. map 函数

通过使用map函数，我们可以对流中的每个元素进行转换操作，从而得到一个新的流。这种转换可以是类型转换、属性提取、计算等。

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Person {
    private String name;
    private Integer age;
}
1
2
3
4
5
6
7

@Test
public void test0() {
    List<Person> list = Arrays.asList(
        new Person("zhangsan", 10),
        new Person("zhangsan", 11),
        new Person("wangwu", 12)
    );

    //(1) map函数将list中的每个Person对象映射为其name属性，并使用collect()方法将新的流收集到一个新的列表nameList中
    List<String> nameList = list.stream().map(person -> {
        return person.getName();
    }).collect(Collectors.toList());
    System.out.println(nameList);  // [zhangsan, zhangsan, wangwu]

    //(2) map函数将list中的每个Person对象映射为其年龄，并将映射后的结果收集到一个新的整数列表ageList中
    List<Integer> ageList = list.stream().map(Person::getAge).collect(Collectors.toList());
    System.out.println(ageList);

    //(3) map函数将list中的每个Person对象映射为其年龄加1后的整数，并使用collect方法将映射后的结果收集到一个新的列表ageList1中
    List<Integer> ageList1 = list.stream().map(person -> {
        return person.getAge() + 1;
    }).collect(Collectors.toList());

    //(4) map函数将list中的每个Person对象的名称转换为大写形式，并将结果收集到一个新的字符串列表uppercaseNames中。
    List<String> uppercaseNames = list.stream().map(person -> {
        return person.getName().toUpperCase();
    }).collect(Collectors.toList());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

02. mapToInt函数

mapToInt是Stream接口提供的一个方法，用于将流中的元素映射为int类型的值。它接受一个ToIntFunction参数，用于指定如何将流中的元素映射为int类型的值。

@Test
public void test14() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    // map 函数
    Stream<Integer> stream = numbers.stream().map(n -> n * n);
    List<Integer> list1 = stream.collect(Collectors.toList());
    System.out.println(list1);

    // mapToInt 函数
    IntStream intStream = numbers.stream().mapToInt(n -> n * n);
    int sum = intStream.sum(); // 求和
    // OptionalDouble average = intStream.average(); // 平均值
    // OptionalInt max = intStream.max(); // 最大值
    // OptionalInt min = intStream.min(); // 最小值
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

map和mapToInt都是Stream接口提供的方法，用于对流中的元素进行映射转换。它们的区别在于返回值的类型和适用范围：

① map方法接受一个Function参数，用于指定如何将流中的元素映射为其他类型的值。它返回一个新的流，其中包含映射后的值。返回的流是一个泛型流，即Stream，其中R是映射后的值的类型。

② mapToInt方法也接受一个Function参数，用于指定如何将流中的元素映射为int类型的值。它返回一个新的IntStream，其中包含映射后的int值。返回的流是一个特殊的流，专门用于处理int类型的值，提供了更高效的操作和更少的内存消耗。

需要注意的是，IntStream提供了一些特殊的操作，例如sum、average、max、min等，这些操作只适用于IntStream，而不适用于泛型流Stream。如果需要对映射后的值进行这些特殊操作，应该使用mapToInt方法。

除了mapToInt方法，Stream接口还提供了其他一些类似的映射方法，如mapToLong和mapToDouble，用于将流中的元素映射为long类型和double类型的值。

03. filter 函数

通过使用filter函数，我们可以根据指定的条件过滤出流中满足条件的元素，从而得到一个新的流。这种过滤可以是基于元素的某个属性、某种关系或其他条件。

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Person {
    private String name;
    private Integer age;
}
1
2
3
4
5
6
7

@Test
public void test1() {
    List<Person> list = Arrays.asList(
        new Person("zhangsan", 10),
        new Person("zhangsan", 11),
        new Person("wangwu", 12)
    );

    // filter函数过滤出列表中Person对象的name为zhangsan的元素，最后使用collect方法将过滤后的结果收集到一个新的列表中。
    List<Person> list1 = list.stream().filter(person -> {
        return person.getName().equals("zhangsan");
    }).collect(Collectors.toList());
    System.out.println(list1); // [Person(name=zhangsan, age=10), Person(name=zhangsan, age=11)]

    // 简洁写法
    List<Person> list2 = list.stream().filter(person -> person.getName().equals("zhangsan")).collect(Collectors.toList());

    // filter函数过滤出列表中Person对象的age为偶数的元素，最后使用collect方法将过滤后的结果收集到一个新的列表中。
    List<Person> list3 = list.stream().filter(person -> person.getAge() % 2 == 0).collect(Collectors.toList());
    System.out.println(list3); // [Person(name=zhangsan, age=10), Person(name=wangwu, age=12)]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

04. flatMap 函数

flatMap函数是一种中间操作，用于对流中的每个元素进行映射操作，并将映射结果扁平化为一个新的流。

① flatMap函数将每个子列表映射为一个流，并将这些流扁平化为一个新的流：

@Test
public void test2() {
    // 首先创建一个嵌套的整数列表nestedList，其中包含了三个子列表。
    List<List<Integer>> nestedList = Arrays.asList(
        Arrays.asList(1, 2, 3),
        Arrays.asList(4, 5, 6),
        Arrays.asList(7, 8, 9)
    );

    // flatMap函数将每个子列表映射为一个流，并将这些流扁平化为一个新的流，最后使用collect方法将扁平化后的结果收集到一个新的整数列表flattenedList中。
    List<Integer> flattenedList = nestedList.stream().flatMap(list->{
        return list.stream();
    }).collect(Collectors.toList());

    // 简洁写法
    List<Integer> collect = nestedList.stream().flatMap(List::stream).collect(Collectors.toList());
    System.out.println(collect);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

② 使用flatMap函数将list中每个Person对象的ids列表扁平化为一个新的流：

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Person {
    List<Integer> ids;
    private String name;
    private Integer age;
    
    public Person(String name,Integer age){
        this.name = name;
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

@Test
public void test3() {
    Person qo1 = new Person("zhangsan",10);
    qo1.setIds(Arrays.asList(1,2,3));
    Person qo2 = new Person("zhangsan",11);
    qo2.setIds(Arrays.asList(4,5,6));
    Person qo3 = new Person("wangwu",12);
    qo3.setIds(Arrays.asList(7,8,9));

    List<Person> list = new ArrayList<>();
    list.add(qo1);
    list.add(qo2);
    list.add(qo3);

    List<Integer> list1 = list.stream().flatMap(Person -> {
        return Person.getIds().stream();
    }).collect(Collectors.toList());
    System.out.println(list1); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

    List<List<Integer>> list2 = list.stream().map(Person -> {
        return Person.getIds();
    }).collect(Collectors.toList());
    System.out.println(list2); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    List<Integer> list3 = list.stream().flatMap(Person -> {
        return Optional.ofNullable(Person.getIds()).orElse(new ArrayList<>()).stream();
    }).collect(Collectors.toList());
    System.out.println(list3); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

05. distinct 函数

distinct函数是一种中间操作，用于去除流中的重复元素，保留唯一的元素。它会根据元素的equals方法进行比较来判断元素是否重复。

@Test
public void test4() {
    List<Integer> list = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5);
    List<Integer> list1 = list.stream().distinct().collect(Collectors.toList());
    System.out.println(list1);
}
1
2
3
4
5
6

如果想要根据对象的属性进行去重，您可以使用Java 8的Stream API结合distinct函数和自定义的equals和hashCode方法来实现。

@NoArgsConstructor
@AllArgsConstructor
@Data
public
class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Test
public void test5() {
    List<Person> list = Arrays.asList(
        new Person("zhangsan", 10),
        new Person("zhangsan", 10),
        new Person("wangwu", 12)
    );

    List<Person> collect = list.stream().distinct().collect(Collectors.toList());
    System.out.println(collect); // [Person(name=zhangsan, age=10), Person(name=wangwu, age=12)]
}
1
2
3
4
5
6
7
8
9
10
11

06. sorted 函数

sorted函数是一种中间操作，用于对流中的元素进行排序。它可以按照自然顺序或者通过自定义的比较器进行排序。

① sorted()：按照自然顺序对流中的元素进行排序。

@Test
public void test6() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    List<Integer> sortedNumbers = numbers.stream()
        .sorted()
        .collect(Collectors.toList());
    System.out.println(sortedNumbers); // [1, 2, 3, 5, 8]
}
1
2
3
4
5
6
7
8

② sorted(Comparator<? super T> comparator)：根据自定义的比较器对流中的元素进行排序。

@Test
public void test7() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    List<Integer> sortedNumbers = numbers.stream()
        .sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer obj1, Integer obj2) {
                // 倒序排序
                return obj2-obj1;
            }
        })
        .collect(Collectors.toList());
    System.out.println(sortedNumbers); // [8, 5, 3, 2, 1]

    // 降序排序
    List<Integer> collect = numbers.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

07. limit 函数

limit 函数是一种中间操作，用于截取流中的前n个元素。它会返回一个新的流，其中包含原始流中的前n个元素。

@Test
public void test8() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    // 截取列表中的前3个元素
    List<Integer> list1 = numbers.stream().limit(3).collect(Collectors.toList());
    System.out.println(list1); // [5, 2, 8]

    // 对列表中的元素排序，再截取列表中的前3个元素
    List<Integer> list2 = numbers.stream().sorted().limit(3).collect(Collectors.toList());
    System.out.println(list2); // [1, 2, 3]
}
1
2
3
4
5
6
7
8
9
10
11

08. min 函数

min函数是一种终端操作，用于找到流中的最小元素。它接受一个Comparator函数作为参数，用于确定元素的顺序。通过使用min函数，我们可以方便地找到流中的最小元素。这对于需要找到最小值或根据某个属性进行排序的场景非常有用。

@Test
public void test9() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    // min函数并传入比较器，找到流中的最小值
    Optional<Integer> optional = numbers.stream().min(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 正序排序
            return o1 - o2;
        }
    });

    // 简洁写法
    Optional<Integer> optional1 = numbers.stream().min(Integer::compareTo);

    // 使用Optional类来处理可能为空的结果，并打印输出最小值
    if(optional.isPresent()){
        System.out.println(optional.get()); // 1
    }else {
        System.out.println("Stream is empty");
    }
}

@Test
public void test10() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    // min函数并传入比较器
    Optional<Integer> optional = numbers.stream().min(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 倒叙排序
            return o2-o1;
        }
    });

    // 使用Optional类来处理可能为空的结果
    if(optional.isPresent()){
        System.out.println(optional.get()); // 8
    }else {
        System.out.println("Stream is empty");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

09. max 函数

max函数是一种终端操作，用于找到流中的最大元素。它接受一个Comparator函数作为参数，用于确定元素的顺序。

@Test
public void test11() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    // max函数并传入比较器
    Optional<Integer> optional = numbers.stream().max(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 正序排序
            return o1-o2;
        }
    });

    // 简洁写法
    Optional<Integer> optional1 = numbers.stream().max(Integer::compareTo);

    // 使用Optional类来处理可能为空的结果
    if(optional.isPresent()){
        System.out.println(optional.get()); // 8
    }else {
        System.out.println("Stream is empty");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

10. count 函数

count函数是一种终端操作，用于计算流中的元素数量。它返回一个long类型的值，表示流中的元素个数。

@Test
public void test12() {
    List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
    System.out.println(numbers.stream().count()); // 5
}
1
2
3
4
5

11. groupby 函数

groupBy函数，用于对流中的元素进行分组。groupBy函数接受一个Function参数，用于指定分组的依据。它将流中的元素按照该函数的返回值进行分组，并返回一个Map对象，其中键是分组的依据，值是属于该分组的元素列表。

@Test
public void test12() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    // 使用 n -> n % 2 == 0 ? "偶数" : "奇数"作为分组的依据，将整数列表按照奇偶数进行分组。
    // 最终得到的groups对象是一个Map，其中键是"奇数"和"偶数"，值是属于该分组的整数列表。
    Map<String, List<Integer>> groups = numbers.stream().collect(Collectors.groupingBy(n -> n % 2 == 0 ? "偶数" : "奇数"));
    System.out.println(groups); // {偶数=[2, 4, 6, 8, 10], 奇数=[1, 3, 5, 7, 9]}
}
1
2
3
4
5
6
7
8

还可以使用groupBy函数按照对象的属性进行分组。

@Test
public void test13() {
    List<Person> list = Arrays.asList(
            new Person("zhangsan", 10),
            new Person("lisi", 10),
            new Person("wangwu", 12)
    );
    Map<Integer, List<Person>> map = list.stream().collect(Collectors.groupingBy(person -> person.getAge()));
    // Map<Integer, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getAge));
    System.out.println(map); // {10=[Person(name=zhangsan, age=10), Person(name=lisi, age=10)], 12=[Person(name=wangwu, age=12)]}
}
1
2
3
4
5
6
7
8
9
10
11