常用方法
Stream方法组合使用
第一种介绍字符串集合可进行的操作
import java.util.Arrays;
import java.util.List;
public class StreamExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "cat", "dog", "egg");
long count = list.stream() // 创建Stream
.filter(s -> s.length() == 3) // 过滤长度为3的元素
.map(String::toUpperCase) // 转换为大写
.sorted() // 排序
.count(); // 统计元素个数
System.out.println(count); // 输出：3
}
}
上述代码中，首先创建了一个包含5个字符串的List，然后通过stream()方法将其转换为一个Stream。接着对Stream进行操作，包括过滤、转换为大写、排序和统计元素个数。最后将统计结果打印出来。
具体步骤和注释如下：
- list.stream(): 将List转换为一个Stream对象。
- filter(s -> s.length() == 3): 对Stream中的元素进行过滤，只保留长度为3的元素。
- map(String::toUpperCase): 将Stream中的元素转换为大写。
- sorted(): 对Stream中的元素进行排序。
- count(): 统计Stream中元素的个数。
- System.out.println(count): 将统计结果打印出来。
第二种介绍int类型集合可进行的操作
下面的代码演示了如何使用Stream的方法组合来完成以下三个操作：
找出所有大于5的偶数，并将结果存储到一个列表中；
计算列表中所有元素的平方和；
找出列表中的最大值和最小值。
import java.util.Arrays;
import java.util.List;
public class StreamDemo {
public static void main(String[] args) {
// 创建一个包含整数的列表
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 找出所有大于5的偶数，并将结果存储到一个列表中
List<Integer> result = numbers.stream()
.filter(n -> n > 5) // 过滤出大于5的数
.filter(n -> n % 2 == 0) // 过滤出偶数
.collect(Collectors.toList()); // 将结果存储到一个列表中
System.out.println(result);
// 计算列表中所有元素的平方和
int sum = numbers.stream()
.mapToInt(n -> n * n) // 将元素映射为它的平方
.sum(); // 计算和
System.out.println(sum);
// 找出列表中的最大值和最小值
IntSummaryStatistics stats = numbers.stream()
.mapToInt((x) -> x) // 将Stream<Integer>转换为IntStream
.summaryStatistics(); // 计算统计信息
System.out.println("最大值: " + stats.getMax());
System.out.println("最小值: " + stats.getMin());
}
}
下面分别对这三个操作进行详细的解释：
操作1：找出所有大于5的偶数，并将结果存储到一个列表中
首先，使用filter()方法过滤出大于5的数，然后使用另一个filter()方法过滤出偶数，最后使用collect()方法将结果存储到一个列表中。
操作2：计算列表中所有元素的平方和
首先，使用mapToInt()方法将每个元素映射为它的平方，然后使用sum()方法计算和。
操作3：找出列表中的最大值和最小值
首先，使用mapToInt()方法将Stream转换为IntStream，然后使用summaryStatistics()方法计算统计信息，包括最大值和最小值。
第三种介绍collect()和filter()组合的使用方式
在下面的代码中，首先创建了一个包含数字1到10的List。然后，调用stream()方法将List转换为一个Stream。接着，调用filter()方法对Stream中的元素进行过滤操作，只保留偶数元素。最后，调用collect()方法将结果收集到一个新的List中。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> result = numbers.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toList());
System.out.println(result);
}
}
将一个包含学生信息的List转换为一个以学生名字为键，学生对象为值的Map。
在下面的代码中，首先创建了一个包含三个学生信息的List。然后，调用stream()方法将List转换为一个Stream。接着，调用collect()方法，并传递一个Collectors.toMap()方法作为参数。在toMap()方法中，使用Student::getName将学生名字作为Map的键，使用student -> student将学生对象作为Map的值。最终，将结果存储到一个Map对象中。
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("Tom", 18),
new Student("Jack", 20),
new Student("Lucy", 19)
);
Map<String, Student> result = students.stream()
.collect(Collectors.toMap(Student::getName, student -> student));
System.out.println(result);
}
}
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
方法对比flatMap()和filter()
这两个方法都可以用来筛选流中的数据，但它们的实现方式和作用是不同的。
flatMap()方法的作用是将一个Stream中的每个元素都转换为一个新的流，然后将这些流合并成一个新的流。换句话说，flatMap()方法用来处理嵌套的流结构，并将它们扁平化为一个单一的流。因此，flatMap()方法常用于将嵌套的集合或数组展开为一个单独的流，以方便进一步的处理。
下面是一个使用flatMap()方法的示例代码：
List<List<Integer>> numbers = Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5, 6));
List<Integer> flattenedNumbers = numbers.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList());
System.out.println(flattenedNumbers);
// Output: [1, 2, 3, 4, 5, 6]
在上面的代码中，首先创建了一个包含多个集合的列表numbers。然后，调用stream()方法将这个列表转换为一个Stream。接着，使用flatMap()方法将每个集合都转换为一个新的流，并将这些流合并为一个新的流。最后，使用collect()方法将所有的元素收集到一个新的List中。
filter()方法的作用是根据指定的条件筛选出符合条件的元素，并将它们收集到一个新的Stream中。换句话说，filter()方法用于对Stream中的元素进行条件过滤。因此，filter()方法常用于从一个大的数据集合中，选择符合条件的元素，以用于进一步的处理。
下面是一个使用filter()方法的示例代码：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers);
// Output: [2, 4, 6]
在上面的代码中，首先创建了一个包含多个整数的列表numbers。然后，调用stream()方法将这个列表转换为一个Stream。接着，使用filter()方法过滤出所有偶数，并将它们收集到一个新的Stream中。最后，使用collect()方法将所有偶数收集到一个新的List中。
需要注意的是，flatMap()和filter()方法都是用于处理Stream中的数据，并返回一个新的Stream，它们常常被用于组合使用，以达到对数据进行更复杂处理的目的。
Stream的创建
可以通过以下方式创建Stream：
1. 从集合或数组创建
可以通过Collection.stream()或Arrays.stream()方法来创建Stream。
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();
2. 使用Stream.of()创建
使用Stream.of()方法创建一个Stream。
Stream<String> stream = Stream.of("a", "b", "c");
3. 使用Stream.iterate()创建
使用Stream.iterate()方法创建一个无限流。
Stream<Integer> stream = Stream.iterate(0, n -> n + 2);
4. 使用Stream.generate()创建
使用Stream.generate()方法创建一个无限流。
Stream<Double> stream = Stream.generate(Math::random);
Stream的中间操作
中间操作是指对数据源进行处理并返回一个Stream对象的操作，可以对数据源进行筛选、映射、去重、排序等操作。
以下是常用的Stream中间操作：
1. filter
该方法用于通过设置的条件过滤出元素，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.filter(s -> s.length() > 5).forEach(System.out::println);
2. map
该方法用于将元素按照某种规则进行转换，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.map(String::toUpperCase).forEach(System.out::println);
3. flatMap
该方法用于将一个Stream中的每个元素转换为另一个Stream，然后将所有Stream中的元素合并成一个Stream，返回一个新的Stream对象。
具体来说，flatMap()方法接收一个函数作为参数，这个函数将一个元素转换为一个新的流。然后，flatMap()方法将所有这些新的流合并成一个新的流，最后返回这个新的流。如果这个函数返回的是一个空的流，那么这个流中就不会包含任何元素。
Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2), Arrays.asList(3, 4));
stream.flatMap(Collection::stream).forEach(System.out::println);
4. distinct
该方法用于对Stream中的元素进行去重，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "apple");
stream.distinct().forEach(System.out::println);
5. sorted
该方法用于对Stream中的元素进行排序，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.sorted().forEach(System.out::println);
6. peek
该方法用于在执行Stream中的下一个操作时对元素进行操作，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.peek(s -> System.out.println("before filter: " + s)).filter(s -> s.length() > 5) .peek(s -> System.out.println("after filter: " + s)).forEach(System.out::println);
7. limit
该方法用于截取Stream中前n个元素，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.limit(2).forEach(System.out::println);
8. skip
该方法用于跳过Stream中前n个元素，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.skip(2).forEach(System.out::println);
9. parallel
该方法用于将Stream转换为并行流，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.parallel().forEach(System.out::println);
10. sequential
该方法用于将Stream转换为串行流，返回一个新的Stream对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.parallel().sequential().forEach(System.out::println);
Stream的终止操作
终止操作是指对Stream进行最终操作，产生一个结果或副作用，但不再返回Stream对象。
以下是常用的Stream终止操作：
1. forEach
该方法用于对Stream中的元素进行遍历操作。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
stream.forEach(System.out::println);
2. toArray
该方法用于将Stream中的元素转换为数组。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
String[] strArr = stream.toArray(String[]::new);
3. reduce
该方法用于将Stream中的所有元素按照指定的规则进行归约操作，返回一个Optional对象。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); Optional<Integer> result = stream.reduce((x, y) -> x + y);
result.ifPresent(System.out::println);
4. collect
该方法用于将Stream中的元素收集到一个集合中，返回一个新的集合对象。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear"); List<String> list = stream.collect(Collectors.toList());
5. count
该方法用于计算Stream中的元素个数，返回一个long类型的值。
Stream<String> stream = Stream.of("apple", "banana", "orange", "pear");
long count = stream.count();
System.out.println(count);
6. anyMatch
该方法用于判断Stream中是否存在满足指定条件的元素，返回一个boolean类型的值。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); boolean result = stream.anyMatch(x -> x > 2);
System.out.println(result);
7. allMatch
该方法用于判断Stream中的所有元素是否都满足指定条件，返回一个boolean类型的值。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); boolean result = stream.allMatch(x -> x > 0);
System.out.println(result);
8. noneMatch
该方法用于判断Stream中的所有元素是否都不满足指定条件，返回一个boolean类型的值。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); boolean result = stream.noneMatch(x -> x > 5);
System.out.println(result);
9. findAny
该方法用于获取Stream中的任意一个元素，返回一个Optional对象。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); Optional<Integer> result = stream.findAny();
result.ifPresent(System.out::println);
10. findFirst
该方法用于获取Stream中的第一个元素，返回一个Optional对象。
Stream<Integer> stream = Stream.of(1, 2, 3, 4); Optional<Integer> result = stream.findFirst();
result.ifPresent(System.out::println);