Java中的流处理详解

Java中的流处理详解

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在这篇文章中，我将详细介绍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) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

总结

通过以上内容，我们介绍了Java中流处理的创建、中间操作、终端操作、并行流、短路操作以及自定义类的流处理。希望这些示例代码能够帮助大家更好地理解和应用Java流处理技术。

著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！