lambda表达式

假设我们有一个List集合list，其中存储了一些整数类型的元素。我们想要将这些整数类型的元素加倍，并将结果收集到一个新的List集合中，代码如下：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

List<Integer> resultList = list.stream()
                                .map(i -> i * 2)
                                .collect(Collectors.toList());

System.out.println(resultList);
输出结果为：

[2, 4, 6, 8, 10]

在上述代码中，我们首先通过Arrays.asList()方法创建了一个包含整数元素的List集合list，然后使用stream()方法将其转换为流。接着，通过使用map()方法，对每个元素执行加倍操作（即将元素乘2）。最后，我们使用collect()方法将处理后的元素收集到一个新的List集合中。

在collect()方法中，我们传递了Collectors.toList()作为参数，从而将流中的元素收集到List集合中。

Stream API方法：

filter(Predicate)：过滤流中的元素，只保留符合条件的元素。

map(Function)：对流中的元素执行一个函数，将返回值组成新的流。

flatMap(Function)：对流中的每个元素执行一个函数，将函数的返回值组成新的流。

distinct()：去除流中的重复元素，基于元素的 equals() 和 hashCode() 方法进行比较。

sorted()：将流中的元素按照自然顺序排序。

sorted(Comparator)：将流中的元素按照给定的 Comparator 排序。

limit(long)：获取流中前 n 个元素。

skip(long)：将流中的前 n 个元素跳过，获取后面的元素。

forEach(Consumer)：对流中的每个元素执行一个函数。

collect(Collector)：将流中的元素收集到一个集合中。

reduce(BinaryOperator)：将流中的元素按照给定的操作合并为一个结果。

allMatch(Predicate)：判断流中是否所有元素均符合给定的条件。

anyMatch(Predicate)：判断流中是否至少有一个元素符合给定的条件。

noneMatch(Predicate)：判断流中是否没有元素符合给定的条件。

count()：获取流中元素的个数。

min(Comparator)：获取流中的最小元素。

max(Comparator)：获取流中的最大元素。

findFirst()：获取流中的第一个元素。

findAny()：获取流中的任意一个元素。

这些方法可以灵活地组合使用，实现复杂的流操作，同时也有助于提高代码的可读性和简洁性。

代码示例

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

public class StreamApiExample {

    public static void main(String[] args) {
        // 创建一个包含整数的List
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 1. 过滤出偶数
        List<Integer> evenNumbers = numbers
                .stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("偶数：" + evenNumbers);

        // 2. 将每个元素加1并组成新的List
        List<Integer> incrementedNumbers = numbers
                .stream()
                .map(n -> n + 1)
                .collect(Collectors.toList());
        System.out.println("加1后的数字：" + incrementedNumbers);

        // 3. 将字符串List转换为字符流，然后合并为一个字符流
        List<String> words = Arrays.asList("hello", "world");
        List<Character> combinedChars = words
                .stream()
                .flatMap(str -> str.chars().mapToObj(c -> (char) c))
                .collect(Collectors.toList());
        System.out.println("字符串中的所有字符：" + combinedChars);
        //使用了 mapToObj 方法，将字符流中的每个整数元素转换成一个对应的 Character 对象
        //(c -> (char) c)是一个 lambda 表达式，将每个整数元素 c 转换成一个 char 类型的字符

        // 4. 去重
        List<Integer> distinctNumbers = Arrays.asList(1, 2, 3, 3, 4, 4, 5, 6);
        List<Integer> uniqueNumbers = distinctNumbers.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后的数字列表：" + uniqueNumbers);

        // 5. 将数字列表按照自然顺序排序
        List<Integer> sortedNumbers = Arrays.asList(3, 5, 1, 7, 2, 4, 6);
        List<Integer> naturalOrder = sortedNumbers.stream().sorted().collect(Collectors.toList());
        System.out.println("按照自然顺序排序后的数字列表：" + naturalOrder);

        // 6. 将数字列表按照倒序排序
        List<Integer> reverseOrder = sortedNumbers.stream().sorted((a, b) -> b - a).collect(Collectors.toList());
        System.out.println("按照倒序排序后的数字列表：" + reverseOrder);
		//其中，a 和 b 分别表示流中的两个整数元素，b - a 表示将它们降序排列。这里使用的是 lambda 表达式 (a, b) -> b - a，表示按照 b - a 的结果进行排序
		
        // 7. 获取前3个元素
        List<Integer> firstThree = numbers.stream().limit(3).collect(Collectors.toList());
        System.out.println("前三个数字：" + firstThree);

        // 8. 获取第4个元素以后的元素
        List<Integer> lastSeven = numbers.stream().skip(3).collect(Collectors.toList());
        System.out.println("第4个数字以后的数字：" + lastSeven);

        // 9. 对数字列表中的每个数字执行一个操作
        numbers.stream().forEach(number -> System.out.println("数字：" + number));

        // 10. 将数字列表收集到一个Set中
        List<Integer> duplicatedNumbers = Arrays.asList(1, 2, 3, 3, 4, 4, 5, 6);
        List<Integer> distinctNumbers2 = duplicatedNumbers.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后的数字列表：" + distinctNumbers2);

        // 11. 将数字列表中的元素相加
        Integer sum = numbers.stream().reduce(0, (a, b) -> a + b);
        System.out.println("数字列表中的元素相加的和：" + sum);
		//其中，0 是求和的初始值，(a, b) -> a + b 则是一个 lambda 表达式，表示如何进行求和。具体来说，a 和 b 分别表示流中的两个元素，a + b 表示将它们相加。这个 lambda 表达式的作用是将两个元素相加，然后将计算结果返回给 reduce() 方法，以便继续参与后续的运算。
		
        // 12. 判断数字列表中的元素是否都是偶数
        boolean allEvenNumbers = numbers.stream().allMatch(n -> n % 2 == 0);
        System.out.println("数字列表中的元素是否都是偶数：" + allEvenNumbers);

        // 13. 判断数字列表中是否至少存在一个偶数
        boolean anyEvenNumber = numbers.stream().anyMatch(n -> n % 2 == 0);
        System.out.println("数字列表中是否至少存在一个偶数：" + anyEvenNumber);

        // 14. 判断数字列表中是否不存在负数
        boolean noneNegativeNumber = numbers.stream().noneMatch(n -> n < 0);
        System.out.println("数字列表中是否不存在负数：" + noneNegativeNumber);

        // 15. 统计数字列表的元素个数
        long count = numbers.stream().count();
        System.out.println("数字列表的元素个数：" + count);

        // 16. 获取数字列表中的最小元素
        Integer min = numbers.stream().min(Integer::compareTo).orElseThrow(RuntimeException::new);
        System.out.println("数字列表中的最小元素：" + min);
		//.min(Integer::compareTo)：查找流中的最小值。其中，Integer::compareTo 是一个方法引用，表示使用 Integer 类型的默认比较器来比较流中的元素大小。这个比较器会将流中的元素从小到大排序，找到第一个元素（即最小值）。
		//.orElseThrow(RuntimeException::new)：如果查找的结果为 null，则抛出一个运行时异常。这个方法会判断最小值是不是 null，如果是的话就抛出运行时异常，否则就将最小值返回。
		
        // 17. 获取数字列表中的最大元素
        Integer max = numbers.stream().max(Integer::compareTo).orElseThrow(RuntimeException::new);
        System.out.println("数字列表中的最大元素：" + max);

        // 18. 获取数字列表中的第一个元素
        Integer first = numbers.stream().findFirst().orElseThrow(RuntimeException::new);
        System.out.println("数字列表中的第一个元素：" + first);

        // 19. 获取数字列表中的任意一个元素
        Integer any = numbers.stream().findAny().orElseThrow(RuntimeException::new);
        System.out.println("数字列表中的任意一个元素：" + any);
    }
}