Java8后新特性介绍

1.接口私有方法（Java9）

在Java9之前，interface接口只能定义abstract抽象方法和default默认方法。如果有多个默认方法使用了相同的处理逻辑，那只能写重复代码，或者再单独建个类进行调用。Java9解决了此类问题，其允许在接口中定义private私有方法，减少重用代码和多余的类。比如下面这个例子：

public interface MyInterface {    
	default void method1() {        
		System.out.println("Default method1");        
		commonMethod();    
	}
    default void method2() {        
    	System.out.println("Default method2");        
    	commonMethod();   
    }
 /** * 这是一段通用的处理逻辑 */    
 	private void commonMethod() {        
 		System.out.println("Common method in the interface");    
 	}
 }

在这个示例中，MyInterface接口有两个默认方法method1()和method2()，它们都调用了私有方法commonMethod()，避免了代码重复。并且当实现MyInterface时，只需要调用method1()或者method2()，无需关心其共同调用的commonMethod()的具体实现。

2.Optional增强（Java9）

stream()

在Java 9之前，如果想对Optional对象中的值进行操作，还得使用ifPresent()方法或者orElse()方法。例如，以下是一个Java 8的例子：

Optional<String> optional = ...;
optional.ifPresent(value -> System.out.println(value.length()));

在Java 9中，可以直接使用stream()方法和Stream的map()方法来达到相同的效果，代码如下：

Optional<String> optional = ...;
optional.stream().map(String::length).forEach(System.out::println);

还是能看出来有了stream()方法后，对于对象的操作也变得方便了许多。

ifPresentOrElse()

这个方法允许提供两个Runnable，第一个在Optional对象包含值时执行，第二个在Optional对象为空时执行。例如下面这两段代码，对比了Java8和Java9中不同的处理：

Optional<String> optionalValue = Optional.of("Hello");
// Java 8
	if (optionalValue.isPresent()) { 
		System.out.println("Value is present: " + optionalValue.get());
	} else { 
		System.out.println("Value is absent");
	}
// Java 9
optionalValue.ifPresentOrElse(  
	value -> System.out.println("Value is present: " + value), 
	() -> System.out.println("Value is absent"));

通过ifPresentOrElse方法，可以更加简洁地处理类似情况，而不再需要频繁使用条件语句。

or()

这个方法允许你在Optional对象为空时，提供一个备选的Optional对象。例如：

Optional<String> optional = Optional.empty();
Optional<String> backup = Optional.of("Backup value");
Optional<String> result = optional.or(() -> backup);
System.out.println(result.get());  // Prints "Backup value"

isEmpty()

用于检查Optional对象是否为空。例如：

Optional<String> optional = Optional.empty();
if (optional.isEmpty()) {    
	System.out.println("Optional is empty");
	}  // Prints "Optional is empty"

其实这个方法等价于!optionalValue.isPresent()，只是不再需要取反

Stream API增强（Java9）

takeWhile()

这个方法接收一个指定条件，它可以从一个有序的Stream中取出满足条件的所有元素，一旦遇到不满足条件的元素，就会停止处理后续元素。例如：

Stream.of("a", "b", "c", "de", "f")
	.takeWhile(s -> s.length() == 1)
	.forEach(System.out::print);  // Prints "abc"

在这个例子中，我们使用takeWhile()方法从一个Stream中取出所有长度为1的字符串，直到遇到一个长度不为1的字符串。

dropWhile()

该方法和takeWhile逻辑正好相反，通过指定条件来丢弃Stream流中满足条件的元素，一旦遇到不满足条件的元素，才会开始处理后续元素。

Stream.of("a", "b", "c", "de", "f")    
	.dropWhile(s -> s.length() == 1)    
	.forEach(System.out::print);  // Prints "def"

在这个例子中，使用dropWhile()方法丢弃所有长度为1的字符串，直到遇到一个长度不为1的字符串才开始处理后续的逻辑。

ofNullable()

该方法允许我们使用Optional对象来创建流。如果提供的元素为非空，则生成一个包含该元素的流；如果提供的元素为空，则生成一个空流。

Stream.ofNullable(null).forEach(System.out::print);  // Prints nothing

iterate()

该方法提供了一个新的重载形式，允许我们指定一个条件来定义流的终止条件，这样可以更灵活地控制Stream流的生成。

Stream<Integer> stream = Stream.iterate(1, n -> n < 10, n -> n * 2);
	stream.forEach(System.out::print);// Prints 1248

Switch表达式增强（Java12）

在之前的版本中，switch只能作为语句来使用，看下面的示例：

int day = 2;String dayOfWeek;
switch (day) {    
	case 1: 
		dayOfWeek = "Monday";       
		break;    
	case 2:         
		dayOfWeek = "Tuesday";        
		break;    
	case 3:         
		dayOfWeek = "Wednesday";       
		break;    
	case 4:        
		dayOfWeek = "Thursday";        
		break;    
	case 5:         
		dayOfWeek = "Friday";        
		break;    
	case 6:         
		dayOfWeek = "Saturday";       
		break;    
	case 7:         
		dayOfWeek = "Sunday";        
		break;    
	default:         
		throw new IllegalArgumentException("Invalid day of week: " + day);
		}
	System.out.println(dayOfWeek);  // Prints "Tuesday"

在Java12以后，switch可以直接作为表达式使用，直接看示例：

int day = 2;
String dayOfWeek = switch (day) {    
	case 1 -> "Monday";    
	case 2 -> "Tuesday";    
	case 3 -> "Wednesday";    
	case 4 -> "Thursday";    
	case 5 -> "Friday";    
	case 6 -> "Saturday";    
	case 7 -> "Sunday";    
	default -> throw new IllegalArgumentException("Invalid day of week: " + day);
};
System.out.println(dayOfWeek);  // Prints "Tuesday"

无论是代码量还是可读性上都有了改进。

instanceof增强（Java16）

在Java 16以前，当我们使用instanceof来检查一个对象是否是某个类型的实例时，如果检查成功，还得显式地将这个对象转型为对应类型，然后才能调用这个类型的方法或访问它的字段。例如：

Object obj = ...;
if (obj instanceof String) {    
	String str = (String) obj;    
	System.out.println(str.length());
}

在这个例子中，我们首先检查obj对象是否是String类型的实例，然后将obj对象转型为String类型，并将结果赋值给str变量，最后调用str变量的length()方法。
但是在Java 16中，可以在instanceof操作符后面直接定义一个变量，这个变量会自动被初始化为转型后的对象，可以直接使用这个变量，再也不用显式转型。例如：

Object obj = ...;
if (obj instanceof String str) {    
	System.out.println(str.length());
}

我们在instanceof操作符后面定义了一个str变量，这个变量自动被初始化为obj对象转型为String类型后的结果，然后我们直接调用str变量的length()方法，无需显式转型。这又是一个利于开发的特性，让代码更加简洁和直观。