Java8 Stream详解及中间操作方法使用示例（一）
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
Java 8 引入了 Stream API提供了一种新的处理集合和数组的方式。Stream API 可以让我们更加便捷、灵活地处理数据尤其是大规模数据。在这里我将详细介绍 Java 8 中的 Stream API。
什么是 Stream
Stream 是 Java 8 中引入的一个新的概念它代表着一种元素序列的表现形式。具体来说它是对集合和数组等数据源的抽象类似于 I/O 流但它不会改变数据源本身。Stream 的出现使得我们可以更方便、更高效地对数据进行操作它可以帮助我们轻松地实现过滤、映射、排序、统计等操作同时还能够支持并行处理大大提高了程序的效率。
Stream 操作类型
Stream API 的操作可以分为以下几类
- 创建流的操作创建流指的是将一个集合或其他数据源转换为 Stream 流对象的过程。通常情况下我们可以使用 Stream 类的静态方法来创建流对象如 Stream.of()、Collections.stream() 等。这些方法将返回一个 Stream 流对象该对象可用于对数据进行各种操作。下面是一些常用的创建流的方法。
of(T... values)创建一个由指定元素组成的流。 empty()创建一个空的流。 generate(Supplier<T> s)创建一个无限流每次调用 get() 方法都会生成新的数据。 iterate(T seed, UnaryOperator<T> f)创建一个无限流在每次迭代时都会应用指定的函数。 concat(Stream<? extends T> a, Stream<? extends T> b)创建一个包含两个流的顺序流先是流 a再是流 b。 builder()创建一个用于构建链式操作的 Builder 对象。 ofNullable(T t)创建一个包含零个或一个元素的流元素为指定对象可以为 null。 range(int startInclusive, int endExclusive)创建一个包含从 startInclusive 开始含到 endExclusive 结束不含的整数序列流。 rangeClosed(int startInclusive, int endInclusive)创建一个包含从 startInclusive 开始含到 endInclusive 结束含的整数序列流。- 中间操作Intermediate Operations中间操作是指转换 Stream 类型的操作可以将一个 Stream 转换成另一个 Stream。下面是一些常用的中间操作方法。这些方法都是惰性求值的只会创建一个新的 Stream 对象而不是从数据源中读取数据。
filter(Predicate<T> predicate)根据指定的条件过滤流中的元素。 map(Function<T, R> mapper)将流中的元素映射为另外一种类型。 flatMap(Function<T, Stream<R>> mapper)将流中的每个元素都转换成一个新的流然后把所有的新流合并为一个大流。 distinct()去除流中的重复元素。 sorted()按自然顺序排序流中的元素。 sorted(Comparator<T> comparator)按指定的比较器来排序流中的元素。 peek(Consumer<T> action)对每个元素执行指定的操作并且返回一个新的流。 limit(long maxSize)从流中截取指定数量的元素。 skip(long n)跳过前面的n个元素返回剩余的元素。- 结束操作Terminal Operations结束操作是指结束 Stream 该如何处理的操作并且会触发 Stream 的执行。下面是一些常用的结束操作方法。结束操作会对数据源进行遍历因此是及早求值的。
forEach(Consumer<T> action)对流中的每个元素执行指定的操作。 toArray()将流中的元素转换成数组。 reduce(T identity, BinaryOperator<T> accumulator)使用指定的累加器对流中的元素进行聚合。 collect(Collector<T,A,R> collector)将流中的元素收集到一个容器中。 min(Comparator<T> comparator)返回流中的最小元素。 max(Comparator<T> comparator)返回流中的最大元素。 count()返回流中元素的数量。 anyMatch(Predicate<T> predicate)判断流中是否有任意一个元素匹配指定的条件。 allMatch(Predicate<T> predicate)判断流中是否所有元素都匹配指定的条件。 noneMatch(Predicate<T> predicate)判断流中是否没有任何一个元素匹配指定的条件。 findFirst()返回流中的第一个元素。 findAny()返回流中的任意一个元素。其他方法Java 8 Stream API 还提供了一些其他的方法可以帮助我们更好地处理流中的数据。其中parallel() 和 sequential() 可以用来选择并行处理或者串行处理isParallel() 可以帮助我们判断当前流是否为并行流。而 unordered() 可以告诉流不必保证元素的顺序。onClose() 方法则可以在流关闭时执行一个指定的处理程序。最后使用 spliterator() 方法可以创建一个 Spliterator 对象用来遍历流中的元素。
parallel()将流转为并行流多线程处理可以提高处理效率。 sequential()将流转为串行流单线程处理。 unordered()告诉流不必保证元素的顺序。 isParallel()判断流是否是并行流。 onClose(Runnable closeHandler)在流关闭时执行指定的处理程序。 spliterator()创建一个 Spliterator 来遍历流的元素。
Stream中间操作方法详细介绍
filter(Predicate<? super T> predicate)
filter(Predicate<? super T> predicate)方法是用来过滤流中的元素返回一个新的流其中仅包含满足指定条件的元素。下面是一个使用示例
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class StreamFilterExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> filteredList = list.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); System.out.println(filteredList); // 输出 [2, 4] } }以上代码展示了如何使用
filter(Predicate<? super T> predicate)方法来过滤流中的元素。首先创建了一个整型列表list然后通过stream()方法将其转换为一个流。接着使用filter(n -> n % 2 == 0)方法得到一个新的流其中仅包含偶数元素并通过collect(Collectors.toList())方法将其中的元素收集到一个列表中得到一个只包含偶数的整型列表filteredList最终将其打印出来。需要注意的是
filter(Predicate<? super T> predicate)方法使用了一个Predicate接口类型的参数即一个函数式接口用于筛选流中符合指定条件的元素。在上述代码中使用的是一个 lambda 表达式n -> n % 2 == 0表示筛选偶数元素。
map(Function<? super T,? extends R> mapper)
map()方法是Stream类中的一个中间操作方法它接收一个Function类型的参数mapper用于将流中每个元素按照指定规则映射成另一个元素并生成一个新的流。具体来说该方法会对流中的每个元素应用mapper函数并将函数返回值构成新流。例如假设有一个由字符串构成的流现在需要获取每个字符串的长度并生成一个新的整数流可以使用
map()方法实现List<String> strList = Arrays.asList("Java", "Python", "C#", "JavaScript"); strList.stream() .map(str -> str.length()) .forEach(System.out::println);以上代码中首先从字符串列表中创建一个
Stream然后通过map()方法将每个字符串转换成其长度并生成一个新的整数流。最后通过forEach()方法输出每个元素到控制台。需要注意的是由于
map()方法是一个中间操作方法因此对流的操作不会立即执行而是在遇到终止操作方法时才会执行。同时由于map()方法只是映射了流中的每个元素并未改变原始流因此不会影响流中后续元素的处理。另外需要注意
map()方法的映射函数不能返回null否则会抛出NullPointerException异常。如果需要在映射过程中排除某些元素可以使用filter()方法。
flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
flatMap()方法是Stream类中的一个中间操作方法它将一个元素映射为一个Stream然后把所有Stream合并成一个Stream。具体来说flatMap()方法接收一个函数作为参数该函数用于将一个元素转换为另一个Stream。flatMap()方法会遍历每个元素并将该元素传递给该函数进行转换最终将所有Stream合并成一个新的Stream。例如假设有一个包含多个字符串的列表现在需要将每个字符串转换成一个字符数组并将所有字符数组合并成一个字符串列表可以使用
flatMap()方法实现List<String> strList = Arrays.asList("hello", "world"); List<String> charList = strList.stream() .flatMap(str -> Arrays.stream(str.split(""))) .collect(Collectors.toList()); System.out.println(charList); // 输出结果为 ["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]以上代码中首先从字符串列表中创建一个
Stream然后对每个字符串执行Arrays.stream(str.split(""))方法将字符串转换为字符数组并返回一个Stream最后通过flatMap()将所有Stream合并成一个新的Stream再通过collect()方法将Stream转换为List。需要注意的是如果函数返回的是一个数组或集合等对象那么
flatMap()方法会直接将这个对象添加到结果Stream中而不是将它的元素逐个添加到结果Stream中。如果需要将这个对象中的元素逐个添加到结果Stream中可以使用flatMap()方法配合Arrays.stream()或Collection.stream()方法实现。例如假设有一个包含多个单词的列表现在需要将其中长度大于 3 的单词的字符转换成小写字母可以使用
flatMap()方法实现List<String> words = Arrays.asList("Java", "Stream", "API"); List<String> letters = words.stream() .filter(word -> word.length() > 3) .flatMap(word -> Arrays.stream(word.toLowerCase().split(""))) .collect(Collectors.toList()); System.out.println(letters); // 输出结果为 ["j", "a", "v", "a", "s", "t", "r", "e", "a", "m"]以上代码中首先从单词列表中创建一个
Stream然后过滤出长度大于 3 的单词并对每个单词执行Arrays.stream(word.toLowerCase().split(""))方法将单词转换为小写字母字符数组并返回一个Stream最后通过flatMap()将所有Stream合并成一个新的Stream再通过collect()方法将Stream转换为List。注意由于toLowerCase()方法返回的是一个字符串对象因此需要先调用split()方法将字符串拆分成字符数组。
flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
flatMapToDouble()方法是Stream类中的一个中间操作方法它将一个元素映射为一个DoubleStream并将所有DoubleStream合并成一个新的DoubleStream。具体来说flatMapToDouble()方法接收一个函数作为参数该函数用于将一个元素转换为另一个DoubleStream。flatMapToDouble()方法会遍历每个元素并将该元素传递给该函数进行转换最终将所有DoubleStream合并成一个新的DoubleStream。例如假设有一个包含多个字符串的列表现在需要将每个字符串转换成一个浮点数数组并将所有浮点数求和可以使用
flatMapToDouble()方法实现List<String> strList = Arrays.asList("1.0", "2.0", "3.0"); double sum = strList.stream() .flatMapToDouble(str -> DoubleStream.of(Double.parseDouble(str))) .sum(); System.out.println(sum); // 输出结果为 6.0以上代码中首先从字符串列表中创建一个
Stream然后对每个字符串执行DoubleStream.of(Double.parseDouble(str))方法将字符串转换为浮点数并返回一个DoubleStream最后通过flatMapToDouble()将所有DoubleStream合并成一个新的DoubleStream并调用sum()方法求和。需要注意的是如果函数返回的是一个数组或集合等对象那么
flatMapToDouble()方法会直接将这个对象添加到结果DoubleStream中而不是将它的元素逐个添加到结果DoubleStream中。如果需要将这个对象中的元素逐个添加到结果DoubleStream中可以使用flatMapToDouble()方法配合Arrays.stream()或Collection.stream()方法实现。例如假设有一个包含多个单词的列表现在需要将其中长度大于 3 的单词的字符转换成小写字母的 ASCII 码并将所有 ASCII 码求平均值可以使用
flatMapToDouble()方法实现List<String> words = Arrays.asList("Java", "Stream", "API"); double avg = words.stream() .filter(word -> word.length() > 3) .flatMapToDouble(word -> word.toLowerCase().chars().asDoubleStream()) .average() .orElse(0.0); System.out.println(avg); // 输出结果为 99.54545454545455以上代码中首先从单词列表中创建一个
Stream然后过滤出长度大于 3 的单词并对每个单词执行word.toLowerCase().chars().asDoubleStream()方法将单词转换为小写字母字符数组并返回一个DoubleStream最后通过flatMapToDouble()将所有DoubleStream合并成一个新的DoubleStream并调用average()方法求平均值。注意由于chars()方法返回的是一个IntStream因此需要调用asDoubleStream()方法将其转换为DoubleStream。如果列表为空可以通过调用orElse()方法设置一个默认值。
flatMapToInt(Function<? super T,? extends IntStream> mapper)
flatMapToInt()方法是Stream类中的一个中间操作方法它将一个元素映射为一个IntStream并将所有IntStream合并成一个新的IntStream。具体来说flatMapToInt()方法接收一个函数作为参数该函数用于将一个元素转换为另一个IntStream。flatMapToInt()方法会遍历每个元素并将该元素传递给该函数进行转换最终将所有IntStream合并成一个新的IntStream。例如假设有一个包含多个字符串的列表现在需要将每个字符串转换成一个整数数组并将所有整数求和可以使用
flatMapToInt()方法实现List<String> strList = Arrays.asList("1", "2", "3"); int sum = strList.stream() .flatMapToInt(str -> IntStream.of(Integer.parseInt(str))) .sum(); System.out.println(sum); // 输出结果为 6以上代码中首先从字符串列表中创建一个
Stream然后对每个字符串执行IntStream.of(Integer.parseInt(str))方法将字符串转换为整数并返回一个IntStream最后通过flatMapToInt()将所有IntStream合并成一个新的IntStream并调用sum()方法求和。需要注意的是如果函数返回的是一个数组或集合等对象那么
flatMapToInt()方法会直接将这个对象添加到结果IntStream中而不是将它的元素逐个添加到结果IntStream中。如果需要将这个对象中的元素逐个添加到结果IntStream中可以使用flatMapToInt()方法配合Arrays.stream()或Collection.stream()方法实现。例如假设有一个包含多个单词的列表现在需要将其中长度大于 3 的单词的字符转换成小写字母的 ASCII 码并将所有 ASCII 码求平均值可以使用
flatMapToInt()方法实现List<String> words = Arrays.asList("Java", "Stream", "API"); double avg = words.stream() .filter(word -> word.length() > 3) .flatMapToInt(word -> word.toLowerCase().chars()) .average() .orElse(0.0); System.out.println(avg); // 输出结果为 99.54545454545455以上代码中首先从单词列表中创建一个
Stream然后过滤出长度大于 3 的单词并对每个单词执行word.toLowerCase().chars()方法将单词转换为小写字母字符数组并返回一个IntStream最后通过flatMapToInt()将所有IntStream合并成一个新的IntStream并调用average()方法求平均值。注意由于chars()方法返回的是一个IntStream因此不需要调用其他方法进行转换。如果列表为空可以通过调用orElse()方法设置一个默认值。
flatMapToLong(Function<? super T,? extends LongStream> mapper)
flatMapToLong()方法是Stream类中的一个中间操作方法它将一个元素映射为一个LongStream并将所有LongStream合并成一个新的LongStream。具体来说flatMapToLong()方法接收一个函数作为参数该函数用于将一个元素转换为另一个LongStream。flatMapToLong()方法会遍历每个元素并将该元素传递给该函数进行转换最终将所有LongStream合并成一个新的LongStream。例如假设有一个包含多个字符串的列表现在需要将每个字符串转换成一个长整数数组并将所有长整数求和可以使用
flatMapToLong()方法实现List<String> strList = Arrays.asList("1", "2", "3"); long sum = strList.stream() .flatMapToLong(str -> LongStream.of(Long.parseLong(str))) .sum(); System.out.println(sum); // 输出结果为 6以上代码中首先从字符串列表中创建一个
Stream然后对每个字符串执行LongStream.of(Long.parseLong(str))方法将字符串转换为长整数并返回一个LongStream最后通过flatMapToLong()将所有LongStream合并成一个新的LongStream并调用sum()方法求和。需要注意的是如果函数返回的是一个数组或集合等对象那么
flatMapToLong()方法会直接将这个对象添加到结果LongStream中而不是将它的元素逐个添加到结果LongStream中。如果需要将这个对象中的元素逐个添加到结果LongStream中可以使用flatMapToLong()方法配合Arrays.stream()或Collection.stream()方法实现。例如假设有一个包含多个单词的列表现在需要将其中长度大于 3 的单词的字符转换成小写字母的 ASCII 码并将所有 ASCII 码求平均值可以使用
flatMapToLong()方法实现List<String> words = Arrays.asList("Java", "Stream", "API"); double avg = words.stream() .filter(word -> word.length() > 3) .flatMapToLong(word -> word.toLowerCase().chars().asLongStream()) .average() .orElse(0.0); System.out.println(avg); // 输出结果为 99.54545454545455以上代码中首先从单词列表中创建一个
Stream然后过滤出长度大于 3 的单词并对每个单词执行word.toLowerCase().chars().asLongStream()方法将单词转换为小写字母字符数组并返回一个LongStream最后通过flatMapToLong()将所有LongStream合并成一个新的LongStream并调用average()方法求平均值。注意由于chars()方法返回的是一个IntStream因此需要调用asLongStream()方法将其转换为LongStream。如果列表为空可以通过调用orElse()方法设置一个默认值。
distinct()
distinct()用于去除流中重复的元素返回由不同元素组成的新流。下面是一个使用示例
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class DistinctExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 3, 2, 4, 2, 1, 5, 6, 4, 3); List<Integer> distinctList = list.stream() .distinct() .collect(Collectors.toList()); System.out.println(distinctList); // 输出 [1, 3, 2, 4, 5, 6] } }以上代码展示了如何使用
distinct()方法去除流中重复的元素。首先创建了一个整型列表list然后通过stream()方法将其转换为一个流。接着使用distinct()方法得到一个由不同元素组成的新流并通过collect(Collectors.toList())方法将其中的元素收集到一个列表中得到一个没有重复元素的整型列表distinctList最终将其打印出来。需要注意的是
distinct()方法使用了对象的hashCode()和equals()方法来判断元素是否重复。因此要确保列表中的元素已正确地实现了这两个方法。
sorted()
sorted()方法是一个中间操作用于对Stream对象的元素进行排序并返回一个新的Stream对象。该方法会使用元素所属类的compareTo()方法进行默认排序也可以接收一个Comparator函数来自定义排序规则。
具体用法如下
- 创建一个包含多个元素的Stream对象。
- 调用sorted()方法并可选地传入一个Comparator函数。
- 该方法将对Stream对象中的元素进行排序并返回一个新的Stream对象。
例如以下代码演示了如何使用sorted()方法对整数流进行排序
List<Integer> list = Arrays.asList(5, 3, 8, 1, 4); Stream<Integer> sortedStream = list.stream().sorted(); sortedStream.forEach(System.out::println); // 输出 1 3 4 5 8上述代码创建一个Integer类型的列表并将其转换成Stream对象。接下来调用sorted()方法该方法使用默认排序规则对Stream对象中的元素进行排序将返回一个新的Stream对象。最后使用forEach()方法遍历新的Stream对象并将其输出到控制台上。
需要注意的是Stream对象是惰性求值的因此在调用sorted()方法时并不会立即执行排序操作而是在遍历Stream对象时才进行排序。如果在排序时使用了Comparator函数则需要确保元素类型实现了Comparable接口。
sorted(Comparator<? super T> comparator)
sorted(Comparator<? super T> comparator)方法是一个中间操作用于对Stream对象的元素进行排序并返回一个新的Stream对象。该方法使用传入的Comparator函数来自定义排序规则。
具体用法如下
- 创建一个包含多个元素的Stream对象。
- 调用sorted(Comparator<? super T> comparator)方法并传入一个Comparator函数。
- 该方法将使用传入的Comparator函数对Stream对象中的元素进行排序并返回一个新的Stream对象。
例如以下代码演示了如何使用sorted()方法和Comparator函数对字符串流进行排序
List<String> list = Arrays.asList("java", "python", "ruby", "c++"); Stream<String> sortedStream = list.stream().sorted((s1, s2) -> s1.length() - s2.length()); sortedStream.forEach(System.out::println); // 输出 c++ java ruby python上述代码创建一个String类型的列表并将其转换成Stream对象。接下来调用sorted()方法并传入一个Comparator函数该函数按照字符串长度进行排序。该方法会返回一个新的Stream对象其中的元素已按照指定规则排序。最后使用forEach()方法遍历新的Stream对象并将其输出到控制台上。
需要注意的是传入的Comparator函数可以根据任意规则进行排序不一定要依赖元素所属类的compareTo()方法。由于Stream对象是惰性求值的因此在调用sorted()方法时并不会立即执行排序操作而是在遍历Stream对象时才进行排序。
peek(Consumer<? super T> action)
peek(Consumer<? super T> action)方法是一个中间操作用于在Stream的元素流中插入一些操作这些操作可以查看、调试或记录Stream中的元素。该方法不会改变原始Stream中的元素。
具体用法如下
- 创建一个包含多个元素的Stream对象。
- 调用peek(Consumer<? super T> action)方法并传入一个Consumer对象用于接收流中的每个元素。
- 该方法将在整个流上执行指定的操作并返回新的Stream对象。
例如以下代码演示了如何使用peek()方法输出列表中每个元素的值
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); list.stream().peek(x -> System.out.println("Processing element: " + x)) .forEach(System.out::println);输出结果为
Processing element: 1 1 Processing element: 2 2 Processing element: 3 3 Processing element: 4 4 Processing element: 5 5以上代码创建一个Integer类型的列表并将其转换成Stream对象。接下来调用peek()方法对每个元素执行操作并打印处理信息最后再调用forEach()方法打印每个元素的值。由于peek()方法不会改变原始Stream中的元素因此最终输出的结果与转换前的列表完全相同。
limit(long maxSize)
limit()方法是Stream类中的一个中间操作方法它接收一个 long 型参数maxSize用于将原始流截取为最多包含指定数量元素的新流。如果原始流包含的元素数量小于等于maxSize则新流与原始流相同如果原始流包含的元素数量大于maxSize则新流只包含前maxSize个元素。例如假设有一个由数字构成的流现在需要获取其中的前五个元素可以使用
limit()方法实现List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7); numList.stream() .limit(5) .forEach(System.out::println);以上代码中首先从数字列表中创建一个
Stream然后通过limit()方法将流截取为最多包含 5 个元素的新流最后通过forEach()方法输出每个元素到控制台。由于调用了limit()方法因此输出结果只包含前五个元素。需要注意的是由于
limit()方法是一个中间操作方法因此对流的操作不会立即执行而是在遇到终止操作方法时才会执行。同时由于limit()方法只截取了流的一部分元素因此不会影响流中后续元素的处理。另外如果提供的参数值小于等于0则新流中不包含任何元素。如果提供的参数值大于原始流的元素数量则新流与原始流相同。
skip(long n)
skip(long n)方法是一个中间操作用于跳过前n个元素并返回一个新的Stream对象。如果n大于流中的元素数量则将返回一个空的Stream对象。
具体用法如下
- 创建一个包含多个元素的Stream对象。
- 调用skip(long n)方法并传入要跳过的元素数目n。
- 该方法会返回一个新的Stream对象其中包含原始流中剩余的元素。
例如以下代码演示了如何使用skip()方法在字符串流中跳过前两个元素
List<String> list = Arrays.asList("apple", "banana", "orange", "pear"); Stream<String> stream = list.stream().skip(2); stream.forEach(System.out::println); // 输出 orange pear上述代码创建一个String类型的列表并将其转换成Stream对象。接下来调用skip()方法指定要跳过前两个元素。该方法返回一个新的Stream对象其中包含原始流中剩余的元素。最后使用forEach()方法遍历新的Stream对象并将其输出到控制台上。
需要注意的是Stream对象是惰性求值的因此在调用skip()方法时并不会立即执行跳过操作而是在遍历Stream对象时才进行跳过。跳过的元素也不会被保留在内存中因此可以在处理大型数据集时减少内存消耗。