Java中的流处理详解
在这篇文章中，我将详细介绍Java中的流处理，并结合实际代码示例，帮助大家更好地理解和应用流处理技术。
1. 什么是流处理
Java 8引入了Stream API，它提供了一种高效且可读性强的方式来处理集合数据。流可以看作是从支持数据处理操作的源生成的元素序列。流处理主要包括以下几种操作：创建流、中间操作和终端操作。
2. 创建流
可以从多种数据源创建流，比如集合、数组、文件等。以下是几种创建流的示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class StreamCreation {
public static void main(String[] args) {
// 从集合创建流
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream();
// 从数组创建流
String[] array = {"x", "y", "z"};
Stream<String> streamFromArray = Arrays.stream(array);
// 直接创建流
Stream<String> streamOf = Stream.of("1", "2", "3");
// 输出流的元素
streamFromList.forEach(System.out::println);
streamFromArray.forEach(System.out::println);
streamOf.forEach(System.out::println);
}
}3. 中间操作
中间操作会返回一个新的流，它们是惰性求值的，只有在终端操作时才会执行。常见的中间操作包括filter、map、flatMap、sorted等。以下是一些中间操作的示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamIntermediate {
public static void main(String[] args) {
List<String> list = Arrays.asList("a1", "a2", "b1", "c2", "c1");
// 过滤操作
List<String> filtered = list.stream()
.filter(s -> s.startsWith("c"))
.collect(Collectors.toList());
// 映射操作
List<String> mapped = list.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
// 排序操作
List<String> sorted = list.stream()
.sorted()
.collect(Collectors.toList());
// 输出结果
filtered.forEach(System.out::println);
mapped.forEach(System.out::println);
sorted.forEach(System.out::println);
}
}4. 终端操作
终端操作会触发流的执行，并且操作完成后流不再可用。常见的终端操作包括forEach、collect、reduce、count等。以下是终端操作的示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamTerminal {
public static void main(String[] args) {
List<String> list = Arrays.asList("a1", "a2", "b1", "c2", "c1");
// forEach操作
list.stream().forEach(System.out::println);
// collect操作
List<String> collected = list.stream()
.filter(s -> s.startsWith("a"))
.collect(Collectors.toList());
collected.forEach(System.out::println);
// reduce操作
String concatenated = list.stream()
.reduce("", (s1, s2) -> s1 + s2);
System.out.println(concatenated);
// count操作
long count = list.stream().count();
System.out.println(count);
}
}5. 并行流
Java提供了并行流来提高性能。在多核处理器上，并行流可以显著加快数据处理速度。以下是使用并行流的示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
public class ParallelStreamExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("a1", "a2", "b1", "c2", "c1");
// 使用并行流
list.parallelStream().forEach(System.out::println);
// 对比顺序流和并行流的性能
long startTime = System.currentTimeMillis();
list.stream().sorted().forEach(System.out::println);
long endTime = System.currentTimeMillis();
System.out.println("顺序流耗时: " + (endTime - startTime) + " ms");
startTime = System.currentTimeMillis();
list.parallelStream().sorted().forEach(System.out::println);
endTime = System.currentTimeMillis();
System.out.println("并行流耗时: " + (endTime - startTime) + " ms");
}
}6. 流的短路操作
短路操作是指在某些情况下可以提前结束流的操作，例如anyMatch、allMatch、noneMatch等。以下是短路操作的示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
public class StreamShortCircuit {
public static void main(String[] args) {
List<String> list = Arrays.asList("a1", "a2", "b1", "c2", "c1");
// anyMatch操作
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a"));
System.out.println(anyMatch);
// allMatch操作
boolean allMatch = list.stream().allMatch(s -> s.contains("1"));
System.out.println(allMatch);
// noneMatch操作
boolean noneMatch = list.stream().noneMatch(s -> s.endsWith("3"));
System.out.println(noneMatch);
}
}7. 使用自定义类进行流处理
除了使用内置的数据类型，还可以使用自定义类进行流处理。以下是一个示例：
import cn.juwatech.stream.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class CustomClassStream {
public static void main(String[] args) {
List<Person> people = Arrays.asList(
new Person("John", 30),
new Person("Jane", 25),
new Person("Tom", 35)
);
// 过滤操作
List<Person> filtered = people.stream()
.filter(p -> p.getAge() > 28)
.collect(Collectors.toList());
filtered.forEach(p -> System.out.println(p.getName()));
// 映射操作
List<String> names = people.stream()
.map(Person::getName)
.collect(Collectors.toList());
names.forEach(System.out::println);
}
}
class Person {
private String name;
private int age;
public Person(String name, int age) {
= name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}总结
通过以上内容，我们介绍了Java中流处理的创建、中间操作、终端操作、并行流、短路操作以及自定义类的流处理。希望这些示例代码能够帮助大家更好地理解和应用Java流处理技术。
