java.util.stream

java.util.stream 是 Java 8 引入的一个强大的 API，用于处理集合（如 List、Set 等）中的元素。它提供了一种声明式的方式来处理数据，使得代码更加简洁、易读，并且可以方便地进行并行处理，提高性能。下面从多个方面详细介绍 java.util.stream。

流的概念

流（Stream）是一系列支持各种聚合操作的元素序列。它不是一种数据结构，而是从数据源（如集合、数组等）获取元素并进行处理的一种方式。流操作可以分为中间操作和终端操作：

• 中间操作：返回一个新的流，允许进行链式调用。常见的中间操作有 filter、map、sorted 等。
• 终端操作：产生一个最终结果或副作用，如 forEach、collect、count 等。终端操作执行后，流就会被消费，不能再进行其他操作。

流的创建

可以从多种数据源创建流，以下是一些常见的创建方式：

1. 从集合创建流：集合类（如 List、Set 等）提供了 stream() 和 parallelStream() 方法来创建顺序流和并行流。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamCreation {
    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();
    }
}

1. 从数组创建流：使用 Arrays.stream() 方法可以从数组创建流。

import java.util.Arrays;
import java.util.stream.Stream;

public class StreamFromArray {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};
        Stream<String> stream = Arrays.stream(array);
    }
}

1. 使用 Stream.of() 方法创建流：可以直接使用 Stream.of() 方法创建包含指定元素的流。

import java.util.stream.Stream;

public class StreamOfExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "cherry");
    }
}

常见的中间操作

1. filter(Predicate<? super T> predicate)：过滤流中的元素，只保留满足指定条件的元素。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}

1. map(Function<? super T, ? extends R> mapper)：将流中的每个元素映射为另一个元素。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squaredNumbers = numbers.stream()
                .map(n -> n * n)
                .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

1. sorted()：对流中的元素进行自然排序。如果元素实现了 Comparable 接口，则使用其自然顺序；也可以传入一个 Comparator 进行自定义排序。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortedExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
        List<Integer> sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedNumbers);
    }
}

1. 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> numbers = Arrays.asList(1, 2, 2, 3, 3, 3);
        List<Integer> distinctNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(distinctNumbers);
    }
}

常见的终端操作

1. forEach(Consumer<? super T> action)：对流中的每个元素执行指定的操作。

import java.util.Arrays;
import java.util.List;

public class ForEachExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("apple", "banana", "cherry");
        names.stream()
                .forEach(name -> System.out.println(name));
    }
}

1. collect(Collector<? super T, A, R> collector)：将流中的元素收集到一个集合或其他数据结构中。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squaredNumbers = numbers.stream()
                .map(n -> n * n)
                .collect(Collectors.toList());
        System.out.println(squaredNumbers);
    }
}

1. count()：返回流中元素的数量。

import java.util.Arrays;
import java.util.List;

public class CountExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        long count = numbers.stream()
                .count();
        System.out.println(count);
    }
}

1. reduce(T identity, BinaryOperator<T> accumulator)：将流中的元素合并为一个结果。

import java.util.Arrays;
import java.util.List;

public class ReduceExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);
        System.out.println(sum);
    }
}

并行流

并行流可以将流中的元素分成多个部分，并行地进行处理，从而提高性能。可以通过 parallelStream() 方法创建并行流。

import java.util.Arrays;
import java.util.List;

public class ParallelStreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.parallelStream()
                .reduce(0, (a, b) -> a + b);
        System.out.println(sum);
    }
}

需要注意的是，并行流并不总是能提高性能，因为并行处理会带来一些额外的开销，如线程创建和同步等。在使用并行流时，需要根据具体情况进行性能测试和优化。

综上所述，java.util.stream 提供了一种强大而灵活的方式来处理集合中的元素，使得代码更加简洁、易读，并且可以方便地进行并行处理。