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;
}

@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());
}

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(); // 最小值
}

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;
}

@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)]
}

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);
}

② 使用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;}
}

@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]
}

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);
}

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

@NoArgsConstructor
@AllArgsConstructor
@Data
public
class Person {private String name;private int age;@Overridepublic 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);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}

@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)]
}

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]
}

② 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>() {@Overridepublic 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());
}

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]
}

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>() {@Overridepublic 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>() {@Overridepublic 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");}
}

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>() {@Overridepublic 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");}
}

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
}

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]}
}

还可以使用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)]}
}