Java Stream API的基本使用方法

前言

Java各个版本所更新的主要内容：

1.Java SE 8：引入了一些新特性，如lambda表达式、Stream API、格式化日期、国际化等。此外，还对并发编程进行了改进，引入了线程安全的Stream API。
2.Java SE 9：新增了分布式架构的支持，引入了CompletableFuture、ZK等新特性。此外，还对Jit编译器进行了改进，引入了Just-In-Time（JIT）编译器。
3.Java SE 10：主要是为了解决Java SE 9中的一些遗留问题，如null safety、improved ByteBuffer、stream API for Transforming、23种新的基本数据类型等。
4.Java SE 11：新增了许多新特性，如try-with-resources语法糖、独立密钥、Profiler、Crypto API for Java SE、gRPC等。此外，还对AOT和JIT进行了改进，引入了32位系统支持。
5.Java SE 12：主要是为了解决Java SE 11中的一些遗留问题，如security-77、Linux-specific changes、JVM常量库等。
6.Java SE 13：新增了HotSpot 1.13.10支持，削减了JDK知识库的大小，提高了JRE的性能。此外，还对AOT和JIT进行了改进，引入了JVM常量库。
7.Java SE 14：主要是为了修复Java SE 13中的一些漏洞，如CVE-2014-and-earlier、部分音频处理异常等。
8.Java SE 15：新增了Java Native Interface（JNI）支持，用于在Java应用程序中调用本地代码。此外，还对AOT和JIT进行了改进，引入了JVM常量库和Just-In-Time（JIT）编译器。
9.Java SE 16：主要是为了提高Java应用程序的性能和安全性，如JVM常量库、memory-mapped files、外部文件系统等。
10.Java SE 17：主要是为了解决Java SE 16中的一些遗留问题，如JCE-43、部分音频处理异常等。此外，还对AOT和JIT进行了改进，引入了Just-In-Time（JIT）编译器和%K%V等功能。
11.Java SE 18：新增了ZGC和Shenandoah等新特性，以及针对lambda表达式的语法变更。此外，还对并发编程进行了改进，引入了轻量级的stream API。
12.Java SE 19：主要是为了修复Java SE 18中的一些漏洞，如CVE-2020-1719等。
13.Java SE 20：新增了JDK-Convert-Tool和javax.el-api等新特性，以及对AOT和JIT进行了改进，引入了Just-In-Time（JIT）编译器和二次释放池等功能。
14.Java SE 21：主要是为了提高Java应用程序的性能和安全性，如JVM常量库、%K%V、嵌套的文件输入输出等。
15.Java SE 22：主要是为了解决Java SE 21中的一些遗留问题，如CVE-2021-candidates-197等。
16.Java SE 23：主要是为了提高Java应用程序的性能和安全性，如HotSpotSubproject、StandaloneMode、ZGC2、Shenandoah2等。
17.Java SE 24：主要是为了提高Java应用程序的性能和安全性，如autoboxing、华彩发光字等。
18.Java SE 25：主要是为了解决Java SE 24中的一些遗留问题，如CVE-2021-靠前年份等。
…

Stream API

Java Stream流（Stream API）是Java 8中引入的一种新的流式编程方式，它可以简化对集合的处理，提高代码的可读性和可维护性。

常用的方法

1.filter：根据指定条件过滤数据流，返回符合条件的元素。

public class DemoStreamAPI {
	public static void main(String[] args) {
		List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
		numbers.stream()  
			//过滤
        	.filter(n -> n % 2 != 0)  
        	//输出
        	.forEach(System.out::println);
	}
}

输出结果：

2.map：将数据流中的每个元素应用于指定的函数，返回一个新的数据流。

public class DemoStreamAPI {
	public static void main(String[] args) {
		List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
		numbers.stream()  
        	.filter(n -> n % 2 != 0)  
        	.map(n -> n * 2)  
        	.forEach(System.out::println);
	}
}

输出结果：

3.sorted：根据指定的比较器对数据流进行排序，返回一个新的排序后的数据流。

public class DemoStreamAPI2 {
	public static void main(String[] args) {  
        List<Order> ordersA = Arrays.asList(  
                new Order("2023-01-01", "completed", 100),  
                new Order("2023-01-02", "canceled", 50),  
                new Order("2023-01-03", "completed", 200),  
                new Order("2023-01-04", "canceled", 150),  
                new Order("2023-01-05", "completed", 250),  
                new Order("2023-01-06", "canceled", 100)  
        );
        ordersA.stream()
        .sorted(Comparator.comparing(Order::getTotalAmount))
        .collect(Collectors.toList())
        .forEach(i -> {
        	System.out.println(i.getOrderDate() + "====" + i.getTotalAmount());
        });
    }  
}

输出结果：

4.limit：返回数据流中前指定个数的元素。

public class DemoStreamAPI2 {
	public static void main(String[] args) {  
        List<Order> ordersA = Arrays.asList(  
                new Order("2023-01-01", "completed", 100),  
                new Order("2023-01-02", "canceled", 50),  
                new Order("2023-01-03", "completed", 200),  
                new Order("2023-01-04", "canceled", 150),  
                new Order("2023-01-05", "completed", 250),  
                new Order("2023-01-06", "canceled", 100)  
        );
        ordersA.stream()
        .limit(2)
        .sorted(Comparator.comparing(Order::getTotalAmount))
        .collect(Collectors.toList())
        .forEach(i -> {
        	System.out.println(i.getOrderDate() + "====" + i.getTotalAmount());
        });
    }  
}

输出结果：

5.forEach：对数据流中的每个元素执行指定的操作。

查看

6.collect：将数据流中的每个元素收集到指定的集合中。

public class DemoStreamAPI2 {
	public static void main(String[] args) {  
        List<Order> ordersA = Arrays.asList(  
                new Order("2023-01-01", "completed", 100),  
                new Order("2023-01-02", "canceled", 50),  
                new Order("2023-01-03", "completed", 200),  
                new Order("2023-01-04", "canceled", 150),  
                new Order("2023-01-05", "completed", 250),  
                new Order("2023-01-06", "canceled", 100)  
        );
        Map<String, List<Order>> groupByOrderStatus = ordersA.stream()
        .sorted(Comparator.comparing(Order::getTotalAmount))
        .collect(Collectors.groupingBy(Order::getOrderStatus));
        System.out.println(groupByOrderStatus.toString());
    }  
}

输出结果：

{canceled=[Order [orderDate=2023-01-02, orderStatus=canceled, totalAmount=50], Order [orderDate=2023-01-06, orderStatus=canceled, totalAmount=100], Order [orderDate=2023-01-04, orderStatus=canceled, totalAmount=150]], completed=[Order [orderDate=2023-01-01, orderStatus=completed, totalAmount=100], Order [orderDate=2023-01-03, orderStatus=completed, totalAmount=200], Order [orderDate=2023-01-05, orderStatus=completed, totalAmount=250]]}

7.anyMatch，allMatch，noneMatch

*anyMatch*：检查数据流中的元素**有一个**符合指定的条件，返回true；
*allMatch*：检查数据流中的元素是否**所有**都符合指定的条件；
*noneMatch* ：检查数据流中的元素是否都不符合指定的条件。

public class DemoStreamAPI2 {
	public static void main(String[] args) {  
		List<String> list = new ArrayList<>();
		list.add("C");
		list.add("S");
		list.add("D");
		list.add("N");
		System.out.println(list.stream().anyMatch(i -> i.contains("C"))); // true
		System.out.println(list.stream().allMatch(i -> i.contains("C"))); // false
		System.out.println(list.stream().noneMatch(i -> i.contains("C"))); // false
    }  
}

8.reduce：可以对集合中的元素进行聚合操作，得到一个新的结果。

public class DemoStreamAPI2 {
	public static void main(String[] args) {  
		List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);  
		int sum = numbers.stream()  
		                .reduce(5, (a, b) -> a * b);  //集合中的元素做运算之后，再与第一个参数做运算
		System.out.println("Sum of numbers: " + sum);
    }  
}

输出结果：

总结

使用Stream API可以使代码更加简洁、清晰，提高开发效率。但是，使用不当可能会导致代码出现问题，因此需要仔细考虑使用场景和条件。在实际开发中，应该根据具体情况选择合适的数据结构和操作方法，以达到最佳的开发效果。