112.java基础21(java11新特性回顾)

1.JShell

最低java9 jdk; 并配置环境变量
cmd 中启动 jshell 进入 命令行,可以直接执行java代码,不需要编译
/help  帮助界面

2.局部变量类型推断:

List<interger> list = new ArrayList<>();  
list.add("abc");  // 不能添加,转化不了Integer
var a = "abc"; == String a = "abc";

var b = new StringBuffer("123");
var a = new ArrayList<Integer>();

System.out.println(a.getClass()); // class java.util.ArrayList

var n; 无法推断类型,不能这样使用,同时类的属性的数据类型不可以使用var
    
Thread t = new Thread(()->Systeom.out.println(Thread.currentThread().getName()));
t.start();

有参数的lambda表达式使用
函数式接口:
	Consumer<T>: 消费型函数式接口
        public void accept(T t):
    Counsumer<String> consumer = t -> Systeom.out.println(t.toUpperCase());
	Counsumer<String> consumer = (var t) -> Systeom.out.println(t.toUpperCase());
	
 	Counsumer<String> consumer = (@Nullnull/Deprecated var t) -> Systeom.out.println(t.toUpperCase()); // 可以给变量加注解,没有用var声明不能加注解

3.集合中的一些增强的API:

package com.atguigu.java11;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Stream;
import org.junit.Test;
public class APITest {
	// 集合中的一些增强的API
	@Test
	public void test3() {
		LocalDate localDate = LocalDate.of(2019, 1, 21);
		// 在添加重复元素时, 不是无法添加, 而是抛出异常
		//Set<Integer> set = Set.of(100, 50, 20, 30, 10, 8, 100, 8);
		Set<Integer> set = Set.of(100, 50, 20, 30, 10, 8);
		System.out.println(set.getClass());
		Stream<Integer> stream = Stream.of(50, 20, 30, 70);
	}
	@Test
	public void test2() {
		//快速创建数组
		int[] arr = {1, 9, 3, 2, 8};
		// 快速把数据变成集合的方法
		List<String> list1 = Arrays.asList("aa", "yyy", "zzz", "123");
		//list1.add("ppp"); // 是一个不可以添加元素的集合
		// 集合的创建可以使用更简单的方式
		List<String> list2 = List.of("aa", "bbb", "cc", "DD");
		System.out.println(list2);
		//list2.add("yyy"); // 不可以添加元素
		System.out.println(list2);
	}
	@Test
	public void test1() {
		List<String> list = new ArrayList<>();
		list.add("aa");
		list.add("bbb");
		list.add("cc");
		list.add("DD");
		System.out.println(list);
	}
}

4.Stream 加强:

package com.atguigu.java11;

import java.util.stream.Stream;

import org.junit.Test;

/**
 * 流的处理
 * 1) 创建流
 * 2) 中间操作
 * 3) 终止操作
 */

public class StreamTest {
	
	@Test
	public void test3() {
		// 流的迭代, 创建流
		Stream<Integer> stream1 = Stream.iterate(1, t -> (2 * t) + 1);
		stream1.limit(10).forEach(System.out::println);
		
		System.out.println("*************************");
		// 有限的迭代
		Stream<Integer> stream2 = Stream.iterate(1, t -> t < 1000, t -> (2 * t) + 1);
		stream2.forEach(System.out::println);
	}
	
	@Test
	public void test2() {
		Stream<Integer> stream1 = Stream.of(3, 9, 20, 22, 40, 7);
		// 新方法, takeWhile, dropWhile
		// 从流中一直获取判定器为真的元素, 一旦遇到元素为假, 就终止处理.
		Stream<Integer> stream2 = stream1.takeWhile(t -> t % 2 != 0);
		stream2.forEach(System.out::println); // 输出 3,9
		System.out.println("**********************");
		stream1 = Stream.of(3, 9, 20, 22, 40, 7);
		Stream<Integer> stream3 = stream1.dropWhile(t -> t % 2 != 0);
		stream3.forEach(System.out::println); //输出 20,22,40,7
		
	}
	
	@Test
	public void test1() {
		Stream<Integer> stream1 = Stream.of(3, 9, 20, 22, 40);
		//stream1.forEach(t -> System.out.println(t));
		stream1.forEach(System.out::println);
		
		System.out.println("***********************************");
		
		Stream<Object> stream2 = Stream.of(); // 流中没有数据
		stream2.forEach(System.out::println);
		
		System.out.println("***********************************");
		
		// 传入null会被解析为是一个数组对象, 会进一步访问它的长度信息
		//Stream<Object> stream3 = Stream.of(null);
		//stream3.forEach(System.out::println);
		
		// 可以传入 一个null来创建流对象
		Stream<Object> stream3 = Stream.ofNullable(null);
		stream3.forEach(System.out::println);
	}
}

5.string 字符串新增方法:

package com.atguigu.java11;

import static org.junit.Assert.*;

import java.io.FileInputStream;

import org.junit.Test;

public class StringTest {
	
	@Test
	public void testName3() throws Exception {
		FileInputStream fis = new FileInputStream("src/com/atguigu/java11/StringTest.java");
		byte[] buffer = new byte[fis.available()];// fis.available() 整个文件的字符数
		fis.read(buffer);
		fis.close();
		String string = new String(buffer);
		string.lines().forEach(System.out::println); // string.lines()是stream流
	}
	
	@Test
	public void testName2() throws Exception {
		String string = "Java";
		String string2 = string.repeat(5); //复制五次
		System.out.println(string2); // JavaJavaJavaJavaJava
	}

	@Test
	public void testName() throws Exception {
		String string = " 	  
 ";
		System.out.println(string.isBlank()); // 判断字符串中的字符是否都是空白
		
		System.out.println("**************************");
		
		string = " 	  
 abc 	　";
		String string2 = string.strip(); // 去重字符串首尾的空白, 包括英文和其他所有语言中的空白字符
		System.out.println(string2);
		System.out.println(string2.length());
		
		String string3 = string.trim(); // 去重字符串首尾的空白字符, 只能去除码值小于等于32的空白字符
		System.out.println(string3);
		System.out.println(string3.length());
		
		System.out.println("**************************");
		String string4 = string.stripLeading(); // 去重字符串首部的空白
		System.out.println(string4);
		System.out.println(string4.length());
		
		String string5 = string.stripTrailing(); // 去重字符串尾部的空白
		System.out.println(string5);
		System.out.println(string5.length());
	}
}	

6.Optional 加强:

package com.atguigu.java11;

import static org.junit.Assert.*;
import java.util.Optional;
import org.junit.Test;

public class OptionalTest {
	@Test
	public void testName() throws Exception {
		// of方法中如果传入的参数是null, 会抛出空指针异常
		//Optional<String> optional = Optional.of(null);
		// ofNullable可以兼容空指针, 但是实际传入null后要小心
		Optional<Object> optional = Optional.ofNullable(null);
		Object object = optional.orElse("abc"); // 如果内部引用为空, 则返回参数中的引用, 否则返回内部引用: 打印abc
		System.out.println(object);
		
		Object object2 = optional.orElseThrow();
		System.out.println(object2);
	}
}

7.流自动文件复制:

package com.atguigu.java11;

import static org.junit.Assert.*;
import java.io.FileOutputStream;
import org.junit.Test;

public class InputStreamTest {
	@Test
	public void testName() throws Exception {
		var cl = this.getClass().getClassLoader();
		try (var is = cl.getResourceAsStream("file"); var os = new FileOutputStream("file2")) {
			is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中
		}
	}
}

8.HTTPClient:

package com.atguigu.java11;

import static org.junit.Assert.*;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandler;
import java.net.http.HttpResponse.BodyHandlers;
import java.util.concurrent.CompletableFuture;

import org.junit.Test;

public class HTTPClientTest {
	
	@Test
	public void testName2() throws Exception {
		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);
		
	}
	
	@Test
	public void testName() throws Exception {
		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);
	}
}

9.增强java启动器:

增强java启动器支持运行单个java源代码文件的程序.

注意点 :
1)执行源文件中的第一个类, 第一个类必须包含主方法
2)并且不可以使用别源文件中的自定义类, 本文件中的自定义类是可以使用的.

一个命令编译运行源代码
看下面的代码。
// 编译
javac Javastack.java
// 运行
java Javastack
在我们的认知里面，要运行一个 Java 源代码必须先编译，再运行，两步执行动作。而在未来的 Java 11 版本中，通过一个 java 命令就直接搞定了，如以下所示。
java Javastack.java

10.新的Epsilon垃圾收集器:

package com.atguigu.java11;

import java.util.ArrayList;
import java.util.List;

class Garbage {
	
	private double d1 = 1;
	private double d2 = 2;
	
	// 这个方法是GC在清除本对象时, 会调用一次
	@Override
	public void finalize() {
		System.out.println(this + " collecting");
	}
}

public class EpsilonTest {
	
	// 执行: -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC
	public static void main(String[] args) {
		List<Garbage> list = new ArrayList<>();
		boolean flag = true;
		int count = 0;
		while (flag) {
			list.add(new Garbage());
			if (count++ == 500) {
				list.clear();  // 将前五百个设置为垃圾对象,等待gc回收,之后创建的将不再进行回收,这个时候会导致内存溢出
			}
		}
	}
}
主要用途如下 :
	性能测试(它可以帮助过滤掉GC引起的性能假象)
	内存压力测试(例如,知道测试用例 应该分配不超过1GB的内存, 我们可以使用-Xmx1g –XX:+UseEpsilonGC, 如果程序有问题, 则程序会崩溃)
	非常短的JOB任务(对象这种任务, 接受GC清理堆那都是浪费空间)
	VM接口测试
	Last-drop 延迟&吞吐改进

11.zgc:

这个东西还是实验性质的,暂时可以做测试使用

// linux 64位中可以使用
package com.atguigu.java11;
import java.util.ArrayList;
import java.util.List;
public class ZGCTest {
	//  执行: -XX:+UnlockExperimentalVMOptions -XX:+UseZGC
	public static void main(String[] args) {
		List<Garbage> list = new ArrayList<>();
		boolean flag = true;
		int count = 0;
		while (flag) {
			list.add(new Garbage());
			if (count++ % 500 == 0) {
				list.clear();
			}
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}