Java8中创建Stream流的几种常见方式
目录
- 1. 通过Collection系列集合创建
- 2. 通过Arrays中的静态方法asList()创建
- 3. 通过Stream类中的静态方法of()
- 4. 通过BufferedReader的lines()方法创建
- 5. 通过Stream.iterate()或Stream.generate()创建无限流
- 6.方法补充
在Java 8中，Stream API 是一种新的处理数据的方式，它允许以声明式的方式来处理数据集合。Stream 可以让你以一种非常自然且高效的方式来表达对数据集合的复杂操作。本文将详细介绍在Java 8中创建 Stream 流的几种常见方式。
1. 通过Collection系列集合创建
Collection 接口在Java 8中新增了一个 stream() 方法和一个 parallelStream() 方法，可以用来生成相应的 Stream 对象。
示例代码
import java.util.ArrayList;
import java.util.List;
public class CollectionToStream {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
// 创建顺序流
Stream<String> stream = list.stream();
// 创建并行流
Stream<String> parallelStream = list.parallelStream();
}
}
2. 通过Arrays中的静态方法asList()创建
Arrays 类提供了一个 asList() 方法，可以将数组转换成列表，然后调用列表的 stream() 方法来创建 Stream。
示例代码
import java.util.Arrays;
import java.util.stream.Stream;
public class ArrayToStream {
public static void main(String[] args) {
String[] array = {"Apple", "Banana", "Cherry"};
// 使用Arrays.asList()转换成列表后创建Stream
Stream<String> stream = Arrays.asList(array).stream();
}
}
3. 通过Stream类中的静态方法of()
Stream 类提供了一个 of() 方android法，可以直接接受不定数量的参数，生成包含这些值的 Stream。
示例代码
import java.util.stream.Stream;
public class StreamOf {
public static void main(String[] args) {
Stream<String> stream = Stream.of("Apple", "Banana", "Cherry");
}
}
4. 通过BufferedReader的lines()方法创建
BufferedReader 类提供了一个 lines() 方法，可以读取文件中的每一行文本，并返回一个 Stream，其中每个元素都是文件中的一行。
示例代码
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.stream.Stream;
public class BufferedReaderToStream {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("path/to/file.txt"))) {
Stream<String> lines = reader.lines();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 通过Stream.iterate()或Stream.generate()创建无限流
Stream 还提供了 iterate() 和 generate() 方法来创建无限流。这两个方法都可以接收一个 Supplier 函数接口作为参数，用于生成流中的元素。
iterate(T seed, UnaryOperator<T> f)：从种子值开始，根据函数生成后续元素。
generate(Supplier<T> s)：根据提供的 Supplier 生成流中的元素。
示例代码
import java.util.stream.Stream;
public class InfiniteStream {
public static void main(String[] args) {
// 无限流 - iterate
Stream<Integer> iterate = Stream.iterate(0, n -> n + 2);
iterate.limit(10).forEach(System.out::println); // 输出前10个偶数
// 无限流 - generate
Stream<Double> generate = Stream.generate(Math::random);
generate.limit(5).forEach(System.out::println); // 输出5个随机数
}
}
以上就是在Java 8中创建 Stream 的几种主要方式。每种方式都有其适用的场景，了解这些创建方式有助于我们在实际开发中更加灵活地使用 Stream API。
6.方法补充
在Java 8中，Stream API 提供了一种高效且易于使用的处理数据集合的方式。以下是几种常见的创建 Stream 的方法，并附上相应的示例代码：
1. 通过集合创建 Stream
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public clemGmqjass CollectionToStream {
public static void main(String[] args) {
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
// 通过集合的 stream() 方法创建 Stream
Stream<String> stream = list.stream();
// 打印 Stream 中的元素
stream.forEach(System.out::println);
}
}
2. 通过数组创建 Stream
import java.util.Arrays;
import java.util.stream.Stream;
public class ArrayToStream {
public static void main(String[] args) {
String[] array = {"Apple", "Banana", "Cherry"};
// 通过 Arrays.stream() 方法创建 Stream
Stream<String> stream = Arrays.stream(array);
// 打印 Stream 中的元素
stream.forEach(System.out::println);
}
}
3. 通过 Stream.of() 创建 Stream
import java.util.stream.Stream;
public class StreamOf {
public static void main(String[] args) {
// 通过 Stream.of() 方法创建 Stream
Stream<String> stream = Stream.of("Apple", "Banana", "Cherry");
// 打印 Stream 中的元素
stream.forEach(System.out::println);
}
}
4. 通过生成器创建 Stream
import java.util.stream.Stream;
public class StreamGenerate {
public static void main(String[] args) {
// 通过 Stream.generate() 方法创建无限流
Stream<String> infiniteStream = Stream.generate(() -> "Apple");
// 限制流的大小并打印前5个元素
infiniteStream.limit(5).forEach(System.out::println);
}
}
5. 通过迭代器创建 Stream
import java.util.stream.Stream;
public class StreamIterate {
public static void main(String[] args) {
// 通过 Stream.iterate() 方法创建无限流
Stream<Integer> infiniteStream = Stream.iterate(1, n -> n + 1);
// 限制流的大小并打印前5个元素
www.devze.com infiniteStream.limit(5).forEach(System.out::println);
}
}
6. 通过文件读取创建 Stream
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;
public class FileToStream {
public static void main(String[] args) {
try {
// 通过 Files.lines() 方法从文件中创建 Stream
Stream<String> lines = Files.lines(Paths.get("path/to/your/file.txt"));
// 打印文件中的每一行
lines.forEach(System.out::println);
// 关闭 Stream
lines.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
在Java 8中，Stream API 是处理集合数据的一种非常强大的工具，它允许你以声明式的方式处理数据集合。创建 Stream 的方式有很多种，下面详细介绍几种常见的创建 Stream 的方法，并提供相应的代码示例。
1. 从集合创建
你可以从任何实现了 Collection 接口的集合（如 List、Set 等）中创建一个 Stream。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class StreamFromCollection {
public static void main(String[] args) {
List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
// 从List创建Stream
Stream<String> stream = list.stream();
// 使用Stream
stream.forEacjavascripth(System.out::println);
}
}
2. 从数组创建
你可以从数组直接创建 Stream。
import java.util.stream.Stream;
public class StreamFromArray {
public static void main(String[] args) {
String[] array = {"Apple", "Banana", "Cherry"};
// 从数组创建Stream
Stream<String> stream = Arrays.stream(array);
// 使用Stream
stream.forEach(System.out::println);
}
}
3. 从值创建
使用 Stream.of() 方法可以从一系列值创建一个 Stream。
import java.util.stream.Stream;
public class StreamOfValues {
public static void main(String[] args) {
// 从值创建Stream
Stream<String> stream = Stream.of("Apple", "Banana", "Cherry");
// 使用Stream
stream.forEach(System.out::println);
}
}
4. 生成无限流
Stream API 提供了两种生成无限流的方法：iterate 和 generate。这些流理论上是无限的，但可以通过 limit 操作来限制大小。
使用 iterate
import java.util.stream.Stream;
public class InfiniteStreamIterate {
public static void main(String[] args) {
// 生成无限流，从0开始每次加2
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);
// 限制流的大小为5
infiniteStream.limit(5).forEach(System.out::println);
}
}
使用 generate
import java.util.Random;
import java.util.stream.Stream;
public class InfiniteStreamGenerate {
public static void main(String[] args) {
Random random = new Random();
// 生成无限流，每个元素都是随机数
Stream<Double> infiniteStream = Stream.generate(random::nextDouble);
// 限制流的大小为5
infiniteStream.limit(5).forEach(System.out::println);
}
}
5. 文件行读取
可以使用 Files.lines 方法从文件中读取行并创建 Stream。
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;
p编程客栈ublic class StreamFromFile {
public static void main(String[] args) {
try (Stream<String> lines = Files.lines(Paths.get("path/to/your/file.txt"))) {
// 处理每一行
lines.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}
}
}
到此这篇关于Java8中创建Stream流的几种常见方式介绍的文章就介绍到这了,更多相关Java8创建Stream流内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！
加载中,请稍侯......
精彩评论