Stream流的一些常用方法

在 Java 中，Stream 是 Java 8 引入的一个新的抽象概念，用于对集合（如 List、Set 等）进行高效的操作，如过滤、映射、排序等。Stream 提供了许多常用方法，可分为中间操作和终端操作，下面为你详细介绍。

中间操作

中间操作会返回一个新的流，并且不会立即执行，只有在终端操作被调用时才会执行。

1. filter

用于过滤流中的元素，只保留满足指定条件的元素。

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); 
    }
}

上述代码使用 filter 方法过滤出列表中的偶数。

2. map

将流中的每个元素通过一个指定的函数进行转换，返回一个包含转换后元素的新流。

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);
        List<Integer> squaredNumbers = numbers.stream()
               .map(n -> n * n)
               .collect(Collectors.toList());
        System.out.println(squaredNumbers); 
    }
}

这里使用 map 方法将列表中的每个元素平方。

3. flatMap

将流中的每个元素转换为另一个流，然后将所有流合并成一个流。

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

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<Integer>> nestedList = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4)
        );
        List<Integer> flattenedList = nestedList.stream()
               .flatMap(List::stream)
               .collect(Collectors.toList());
        System.out.println(flattenedList); 
    }
}

此代码使用 flatMap 方法将嵌套列表扁平化。

4. 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); 
    }
}

distinct 方法确保结果列表中没有重复元素。

5. sorted

对流中的元素进行排序。

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

上述代码对列表中的元素进行自然排序。

终端操作

终端操作会触发流的执行，并产生一个最终结果。

1. forEach

对流中的每个元素执行指定的操作。

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

public class ForEachExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        numbers.stream()
               .forEach(System.out::println);
    }
}

此代码使用 forEach 方法打印列表中的每个元素。

2. collect

将流中的元素收集到一个集合或其他数据结构中。

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);
        List<Integer> squaredNumbers = numbers.stream()
               .map(n -> n * n)
               .collect(Collectors.toList());
        System.out.println(squaredNumbers); 
    }
}

这里使用 collect 方法将转换后的元素收集到一个列表中。

3. reduce

将流中的元素进行归约操作，得到一个最终结果。

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

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

上述代码使用 reduce 方法计算列表中元素的总和。

4. 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);
        long count = numbers.stream()
               .count();
        System.out.println(count); 
    }
}

count 方法返回列表中元素的个数。

5. anyMatch、allMatch、noneMatch

• anyMatch：判断流中是否至少有一个元素满足指定条件。
• allMatch：判断流中是否所有元素都满足指定条件。
• noneMatch：判断流中是否没有元素满足指定条件。

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

public class MatchExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        boolean anyEven = numbers.stream()
               .anyMatch(n -> n % 2 == 0);
        boolean allPositive = numbers.stream()
               .allMatch(n -> n > 0);
        boolean noneNegative = numbers.stream()
               .noneMatch(n -> n < 0);
        System.out.println(anyEven); 
        System.out.println(allPositive); 
        System.out.println(noneNegative); 
    }
}

这些方法用于对列表中的元素进行条件判断。