Java 8 Stream API

2025年3月19日 | 阅读 9 分钟

Java 8 引入了用于处理对象集合的功能。流（Stream）不过是一系列对象，它支持各种可以流水线处理以产生所需结果的方法。在进一步深入本主题之前，建议读者掌握 Java 8 的基础知识。

创建流

有多种方法可以从各种资源创建流实例。

空流

要创建空流，必须使用 empty() 方法。

语法

E: 流元素的各种类型。

返回值: 返回一个空的顺序流。

注意：在调用带流参数的方法时，空流有助于避免 NullPointerException。

示例

文件名: EmptyStream.java

// important import statement
import java.util.stream.Stream;
import java.util.*;

public class EmptyStream
{

// main method
public static void main(String argvs[])
{
// an empty stream is created here
Stream<String> str = Stream.empty();

// printing elements in Stream
str.forEach(System.out::println);
}
}

输出

Nothing to display

从集合创建

可以从任何类型的集合（Collection、List、Set）创建流。

示例

文件名: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

public class StreamCreationEx
{
// main method
public static void main(String argvs[]) throws IOException 
{

// for ArrayList
Collection<String> colln = Arrays.asList("J2EE", "JAVA", "Hibernate", "Spring");
Stream<String> stream1 = colln.stream();
stream1.forEach(System.out::println);

// for List
List<String> lst = Arrays.asList("J2EE", "JAVA", "Hibernate", "Spring");
Stream<String> stream2 = lst.stream();
stream2.forEach(System.out::println);

// for HashSet
Set<String> st = new HashSet<>(lst);
Stream<String> stream3 = st.stream();
stream3.forEach(System.out::println);
}
}

输出

J2EE
JAVA
Hibernate
Spring
J2EE
JAVA
Hibernate
Spring
JAVA
Hibernate
J2EE
Spring

使用数组

数组也可以是流的来源，或者可以从现有数组或数组的一部分生成数组。

文件名: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.io.IOException;
import java.util.stream.Stream;

public class StreamCreationEx 
{
// main method
public static void main(String argvs[]) throws IOException 
{

// Array can be made as a Stream source 
Stream<String> strOfArray = Stream.of("a1", "b1", "c1", "d1");
strOfArray.forEach(System.out::println);

// making from the existing array or from the partion of the array:
String[] ar = new String[] { "a1", "b1", "c1", "d1" };
Stream<String> strOfArrayFull = Arrays.stream(ar);
strOfArrayFull.forEach(System.out::println);

Stream<String> strOfArrayPart = Arrays.stream(ar, 0, 4);
strOfArrayPart.forEach(System.out::println);
}
}

输出

a1
b1
c1
d1
a1
b1
c1
d1
a1
b1
c1
d1

使用 Stream.builder()

当使用构建器时，必须在语句的右侧指定所需的类型，否则，build() 方法会创建 Stream<Object> 实例。

语法

参数

E: 流元素的各种类型。

返回值: 返回一个流构建器。

示例

文件名: StreamCreationEx.java

// important import statements
import java.util.Arrays;
import java.io.IOException;
import java.util.stream.Stream;

public class StreamCreationEx 
{
// main method
public static void main(String argvs[]) throws IOException 
{

Stream<String> strBuilder = Stream.<String>builder().add("a1").add("b1").add("c1").build();
strBuilder.forEach(System.out::println);

}
}

输出

a1
b1
c1

使用 Stream.generate()

Stream generate(Supplier<T> s) 返回一个无限的顺序无序流，其中每个元素都由提供的 Supplier 生成。它适用于创建常量流、随机元素流等。

语法

其中，stream 是一个接口，E 是流元素的类型。sup 是生成元素的 Supplier，返回值是新的无限顺序无序 Stream。

示例

文件名: StreamCreationEx.java

// important import statements
import java.util.stream.Stream;
import java.util.*;

public class StreamCreationEx  
{
      
// main method
public static void main(String argvs[]) 
{

// using the Stream.generate() method 
// for generating the 6 random Integer values
Stream.generate(new Random()::nextInt)
.limit(6).forEach(System.out::println); 
}
}

输出

使用 Stream.iterate()

iterate(E, java.util.function.Predicate, java.util.function.UnaryOperator) 方法允许迭代流中的元素直到满足指定条件。该方法返回一个顺序流，该流通过对起始元素进行提供的 next 函数的迭代应用而生成，该函数满足作为参数传递的 hasNext 谓词。只要 hasNext 条件返回 false，流就会终止。

语法

参数：该方法共有三个参数。

st: 起始元素。

hasNext: 用于确定流是否应终止的应用于元素的谓词。

next: 应用于前一个元素以生成新元素的函数。

返回值: 该方法将返回一个新的顺序流。

示例

文件名: StreamCreationEx.java

// import statement for the Stream
import java.util.stream.Stream;
public class StreamCreationEx 
{
// main method

public static void main(String[] argvs)
{

// creating a stream using the iterate
Stream<Double> str = Stream.iterate(2.0, decimal -> decimal > 0.1, decimal -> decimal / 2);

// printing the values
str.forEach(System.out::println);
}
}

输出

2.0
1.0
0.5
0.25
0.125

使用原始类型流()

Java 8 提供了从三种原始类型：int、long 和 double 创建流的功能。由于 Stream<E> 是泛型接口，并且无法使用原始类型作为泛型的类型参数，因此创建了三个新的特殊接口：IntStream、LongStream、DoubleStream。

IntStream 示例

文件名: IntStream.java

// import statements for the Instant, Duration and IntStream
import java.time.Instant;  
import java.time.Duration; 
import java.util.stream.IntStream;

public class IntStream 
{

public static void intStrmRangeTest() 
{
    Instant st = Instant.now();
    int s = IntStream.range(1, 3).sum();

    System.out.println("Sum of the operation of intStreamRangeTest : " + s);
    Instant e = Instant.now();
    System.out.println("Time Elapsed of the intStreamRangeTest: " + Duration.between(st, e).toNanos());
}

public static void intStrmRangeClosedTest() 
{
    Instant st = Instant.now();
    int s = IntStream.rangeClosed(1, 4).sum();

    System.out.println("Sum of the operation of intStreamRangeClosedTest: " + s);
    Instant e = Instant.now();
    System.out.println("Time elapsed of the intStreamRangeClosedTest: " + Duration.between(st, e).toNanos());
}
// main method
public static void main(String[] argvs)
{

intStrmRangeTest();
intStrmRangeClosedTest();

}
}

输出

Sum of the operation of intStreamRangeTest : 3
Time Elapsed of the intStreamRangeTest: 41313298
Sum of the operation of intStreamRangeClosedTest: 10
Time elapsed of the intStreamRangeClosedTest: 562842

LongStream 示例

文件名: LongStream.java

// importing LongStream
import java.util.stream.LongStream;

public class LongStreamClass
{

// main method
public static void main(String argvs[])
{
// Making a LongStream
LongStream lg = LongStream.of(-7L, -9L, -11L);

// Keeping the elements count in the LongStream
long totalCount = lg.count();

// Printing the elements count 
System.out.println("The total count is: " + totalCount);
}
}

输出

The total count is: 3

DoubleStream 示例

文件名: DoubleStream.java

// importing DoubleStream
import java.util.stream.DoubleStream;

public class DoubleStreamClass
{

// main method
public static void main(String argvs[])
{
// Making a DoubleStream
DoubleStream dg = DoubleStream.of(-8D, -9D, -10D);

// Keeping the elements count in the DoubleStream
long totalCount = dg.count();

// Printing the elements count 
System.out.println("The total count is: " + totalCount);
}
}

输出

The total count is: 3

使用 String 流

字符串也可以通过 String 类中的 chars() 方法来创建流。

String 流

文件名: StringStream.java

// import statements for IntStream
import java.util.stream.IntStream;

public class StringStream 
{

// main method
public static void main(String[] argvs)
{

IntStream strmOfChar = "javaTpoint".chars();

// counting the total number of characters present
// in the word count javaTpoint
long characterCount = strmOfChar.count();
System.out.println("The total number of character count is: " + characterCount);

}
}

输出

The total number of character count is: 10

引用流

我们可以实例化流，并保持对其的引用，只要只进行中间操作。在执行终端操作后，流将变得不可访问。下面将对此进行说明。

文件名: IllegalStateExpn.java

// important import statements
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Optional;

public class IllegalStateExpn
{
// main method
public static void main(String argvs[]) throws IOException 
{

Stream<String> strm = Stream.of("a1", "b1", "c1").filter(element -> element.contains("b1"));
Optional<String> anyEle = strm.findAny();
Optional<String> firstEle = strm.findFirst(); // the stream is inaccessible here

}
}

输出

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.base/java.util.stream.ReferencePipeline.findFirst(ReferencePipeline.java:647)
	at StreamCreationEx.main(StreamCreationEx.java:14)

说明:我们在主线程中遇到了 IllegalStateException。这是因为 Java 8 中的流永远不能被重用，这种行为也是合乎逻辑的。这是因为流被设计为以函数式风格对源元素应用有限的操作序列，而不是保留元素。如果想避免此异常，应编写以下代码。

文件名: IllegalStateExpnCorrection.java

// important import statements
import java.util.stream.Stream;
import java.io.IOException;
import java.util.Optional;
import java.util.List;
import java.util.stream.Collectors;  

public class IllegalStateExpnCorrection
{
// main method
public static void main(String argvs[]) throws IOException 
{

List<String> elemnts = Stream.of("a1", "b1", "c1").filter(element -> element.contains("a1")).collect(Collectors.toList());
Optional<String> anyEle = elemnts.stream().findAny();
Optional<String> firstEle = elemnts.stream().findFirst();
System.out.println(firstEle);

}
}

输出

Optional[a1]

流管道

为了按顺序对数据源的元素执行操作并聚合它们的结果，需要三个部分。

源
中间操作(S)
终端操作。

中间操作会修改或过滤流中的元素，并返回一个新的流。例如：filter、distinct、map、limit、sorted。

终端操作会产生副作用或结果，标志着流的结束。例如：forEach、reduce、collect、min、count、anyMatch、max、noneMatch、allMatch。

管道会对中间操作和终端操作进行链式处理，以一种表达性和流畅的方式处理数据。每个操作都接收前一个操作的输入并为下一个操作生成输出。管道允许声明式和简洁的编码。结果可以在终端操作中找到。

文件名: PipelineStream.java

// import statement
import java.util.*;

public class PipelineStream
{
// main method
public static void main(String argvs[]) 
{
// input list
List<Integer> nums = Arrays.asList(11, 12, 13, 14, 15);

int total = nums.stream().filter(y -> y % 2 != 0).map(y -> y * 2).reduce(0, Integer::sum);

System.out.println("The sum of twice of odd numbers in the input list is: " + total); 

}
}

输出

The sum of twice of odd numbers in the input list is: 78

惰性求值

惰性求值，也称为按需求值，是一种求值策略，其中求值被推迟，直到其值被需要为止。只有在对流调用终端操作时，才会对流执行所有中间操作。在 Java 流中，惰性求值是允许进行显著优化的主要特性之一。

文件名: LazyEvaluation.java

// Import statements for Stream and Collectors
import java.util.stream.Stream;
import java.util.stream.Collectors;  

public class LazyEvaluation 
{
// main method
public static void main(String[] argvs) 
{
    Stream<Integer> strm = Stream.of(2, 4, 5, 9, 15)
            .filter(y -> y % 2 == 1) // filtering the odd numbers
            .peek(y -> System.out.println("Filter Done: " + y)); // displaying the message

    System.out.println("Result is: ");
    System.out.println(strm.collect(Collectors.toList())); // last print statement
}
}

输出

Result is: 
Filter Done: 5
Filter Done: 9
Filter Done: 15
[5, 9, 15]

说明:众所周知，主方法中的第一条语句首先执行，然后是第二条，之后是第三条，依此类推。按照这个概念，输出应该是

Filter Done: 5
Filter Done: 9
Filter Done: 15
Result is: 
[5, 9, 15]

然而，情况并非如此。包含"Result is: "的打印语句首先执行，filter() 和 peek() 方法根本不执行。当最后一条打印语句中的终端操作 collect() 执行时，这些方法才会被执行。

关于 Java 流需要记住的要点

以下是一些用户必须了解的重要要点。

流是元素的序列，可以使用操作管道进行处理或修改。它们不是数据结构。
流支持两种操作类型：一种是中间操作，另一种是终端操作。中间操作会过滤或转换流，而终端操作会产生副作用或结果。
流的设计方式使其具有惰性，这意味着元素处理会在有需求时发生。
Java 流并非适用于所有场景。在某些情况下，使用循环进行传统迭代可能更有效和更合适。

下一主题Java 中的整数 XOR 运算

Java 8 Stream API

创建流

空流

注意：在调用带流参数的方法时，空流有助于避免 NullPointerException。

从集合创建

使用数组

使用 Stream.builder()

使用 Stream.generate()

使用 Stream.iterate()

使用原始类型流()

使用 String 流

引用流

流管道

惰性求值

关于 Java 流需要记住的要点

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 8 Stream API

创建流

空流

注意：在调用带流参数的方法时，空流有助于避免 NullPointerException。

从集合创建

使用数组

使用 Stream.builder()

使用 Stream.generate()

使用 Stream.iterate()

使用原始类型流()

使用 String 流

引用流

流管道

惰性求值

关于 Java 流需要记住的要点

相关帖子

Java 8 到 Java 17 的 Java 新字符串类方法

Java 中的 Bitset 类

Java 中的常量类型

Java 中的图像处理 - 图像比较 - Javatpoint

How to Convert String to JSON Object in Java

Java 中使用二分查找查找最长只包含元音的子字符串

Minimum Non-Zero Product of the Array Elements in Java

Java byte keyword

Java Apps

Java IDEs

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器