Java10&11的新特性

Java10的新特性

局部变量类型推断 Local-Variable Type Inference

集合新增创建不可变集合的方法

Java11的新特性

String中新增的方法

Optional加强

局部变量类型的推断的升级

HttpClient替换原有的HttpURLConnection

---

Java10的新特性

局部变量类型推断 Local-Variable Type Inference

public class Java10Test {
	/**
	 * 局部变量的类型推断
	 */
	@Test
	public void test1() {
		//1.声明变量时，根据所附的值，推断变量的类型
		var num = 10;
		
		var list = new ArrayList<>();
		list.add(123);
		
		//2.遍历操作
		for( var i : list) {
			System.out.println(i);
			System.out.println(i.getClass());
		}
		
		//3.普通的遍历操作
		for(var i = 0; i < 100; i++) {
			System.out.println(i);
		}
	}
	
	@Test
	public void test2() {
		//1.局部变量不复制，就不能实现类型推断
//		var num;
		
		//2.Lambda表达式中，左边的函数式接口不能声明为var
//		Supplier<Double> sup = () -> Math.random();
//		var sup = () -> Math.random();
		
		//3.方法引用中
//		Consumer<String> con = System.out::println;
//		var con = System.out::println;
		
		//4.数组的静态初始化中
//		int[] arr = new int[] {1, 2, 3, 4};
//		var arr = {1, 2, 3, 4};
	}
	
	@Test
	public void test3() {
		//情况1：没有初始化的局部变量声明
//		var s = null;
		//情况6：catch块
//		try {
//			
//		}catch(var e) {
//			e.printStackTrace()
//		}
	}
	//情况2：方法的返回值类型
//	public var method1() {
//		return 0;
//	}
	//情况3：方法的参数类型
//	public void method2(var num) {
//	}
	//情况4：构造器的参数类型
//	public Java10Test(var i) {
//	}
	//情况5：属性
//	var num = 10;
	
	@Test
	public void test4() {
		try {
			var url = new URL("www.baidu.com");
			var connection = url.openConnection();
			var reader = new BufferedReader(
					new InputStreamReader(connection.getInputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

工作原理

在处理var时，编译器先是查看表达式右边部分，并根据右边变量值的类型进行推断，作为左边变量的类型，然后将该类型写入到字节码当中。

注意

• var不是一个关键字

你不需要担心变量名或方法名会与var发生冲突，因为var实际上并不是一个关键字，而是一个类型名，只有在编译器需要直到类型的地方才需要用到它。除此之外，它就是一个普通合法的标识符。也就是说，除了不能用它作为类名，其他的都可以。

• 这不是JavaScript

首先我要说明的是，var并不会改变Java是一门静态类型语言的事实。编译器负责推断出类型。并把结果写入字节码文件，就好像是开发人员自己敲入类型一样。

集合新增创建不可变集合的方法

//集合中新增的copyOf(),用于创建一个只读的集合
	@Test
	public void test5() {
		//示例1：
		var list1 = List.of("Java", "Python", "C");
		var copy1 = List.copyOf(list1);
		System.out.println(list1 == copy1);//true
		
		//示例2：
		var list2 = new ArrayList<String>();
		var copy2 = List.copyOf(list2);
		System.out.println(list2 == copy2);//false
		
		//代码基本一致，为什么结果不同？
		//结论：copyOf(Xxx coll):如果参数coll本身就是一个只读集合，则copyOf()返回值即为当前的coll。
		//如果参数coll不是一个只读集合，则copyOf()返回一个新的集合，这个集合是只读的。
	}

Java11的新特性

String中新增的方法

public class Java11Test {
	//java 11新特性一：String中新增的方法
	@Test
	public void test1() {
		//isBlank():判断字符是否为空白
		System.out.println("  \\t  \\t  \\n   ".isBlank());
		//strip():去除首尾空白
		System.out.println("-----" + "  \\t abc \\t  \\n   ".strip() + "-----");
		System.out.println("-----" + "  \\t abc \\t  \\n   ".trim() + "-----");
		//stripTrailing():去除尾部空格
		System.out.println("-----" + "  \\t abc \\t  \\n   ".stripTrailing() + "-----");
		//stripLeading():去除头部空格
		System.out.println("-----" + "  \\t abc \\t  \\n   ".stripLeading() + "-----");
		//repeat(int count):重复count次
		String str1 = "abc";
		String str2 = str1.repeat(5);
		System.out.println(str2);
		
		//lines().count():行数统计
		String str3 = "abc\\nde\\nfg";
		System.out.println(str3.lines().count());
	}
}

Optional加强

//java11新特性二：Optional新增的方法
	@Test
	public void test2() {
		Optional<Object> op = Optional.empty();
		System.out.println(op.isPresent());//判断内部的value是否存在
		System.out.println(op.isEmpty());//判断内部的value是否为空
		
		op = Optional.of("abc");
		//orElseThrow():value非空，返回value；否则抛异常NoSuchElementException
		var obj = op.orElseThrow();
		System.out.println(obj);
		
		//or():value非空，返回对应的Optional；value为空，返回形参封装的Optional
		Optional<String> op1 = Optional.of("hello");
		op = Optional.empty();
		Optional<Object> op2 = op.or(() -> op1);
		System.out.println(op2);
	}

局部变量类型的推断的升级

//java11新特性三：局部变量类型的推断的升级
	@Test
	public void test3() {
		//错误的形式：必须要有类型，可以加上var
//		Consumer<String> con1 = (@Deprecated t) -> System.out.println(t.toUpperCase());
		//正确的形式:
		//使用var的好处是在使用lambda表达式时给参数加上注释
		Consumer<String> con2 = (@Deprecated var t) -> System.out.println(t.toUpperCase());
	}

HttpClient替换原有的HttpURLConnection

//java11新特性四：HttpClient替换原有的HttpURLConnection。
	@Test
	public void test4() {
		try {
			HttpClient client = HttpClient.newHttpClient();
			HttpRequest request = HttpRequest.newBuilder(URI.create("<http://127.0.0.1:8080/test/>")).build();
			BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
			HttpResponse<String> response =	client.send(request, responseBodyHandler);
			String body = response.body();
			System.out.println(body);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void test5() {
		HttpClient client = HttpClient.newHttpClient();
		HttpRequest request = HttpRequest.newBuilder(URI.create("<http://127.0.0.1:8080/test/>")).build();
		BodyHandler<String> responseBodyHandler = BodyHandlers.ofString();
		CompletableFuture<HttpResponse<String>> sendAsync = client.sendAsync(request, responseBodyHandler);
		sendAsync.thenApply(t -> t.body()).thenAccept(System.out::println);
//		HttpResponse<String> response = sendAsync.get();
//		String body = response.body();
//		System.out.println(body);
	}