JDK7~13的新特性

jdk7
- 新的资源关闭方式 try-with-resources
jdk8
- 接口新增的默认方法、静态方法
- 新增的base64加解密api
- 新增的时间日期类、时间日期处理类
- 新增的NPE处理类Optional
- 新增的函数式接口、lambda表达式
- - 函数式接口
  - lambda表达式
  - jdk8内置的函数式接口
- 新增的方法引用方式::
- 新增的集合操作方式Stream
- 新的内存空间Matespace
jdk9
- 接口新增的私有方法
- 增强的try-with-resource
- 新增的创建只读集合的api
- 模块化
jdk10
- 新增的创建只读集合的api
- 新增的局部变量类型推断var
jdk11
- 新增的http客户端
- javac、java命令的优化
jdk13

jdk7

新的资源关闭方式 try-with-resources

以前的资源关闭方式 try…finally

OutputStream os = null;
try {os = new FileOutputStream("C:/Users/chy/Desktop/1.txt");os.write("hello".getBytes());
} catch (FileNotFoundException e) {//...
} catch (IOException e) {//...
} finally {if (os != null) {try {os.close();} catch (IOException e) {e.printStackTrace();}}
}

需要在finally中关闭，且在finally中还可能需要嵌套try，代码冗杂；如果需要关闭多个资源，关闭顺序还可能写错。

jdk7新增的资源关闭方式 try-with-resources

/*** 在try()中定义要关闭的资源，try代码块执行完毕后会自动关闭该资源，无需手动关闭。关闭时会自动flush刷出数据，无需手动调用flush()。* 相当于自动提供了一个关闭资源的finally代码块，如果执行try代码块时发生异常，资源也能正常关闭。* 如果有手动写的finally代码块，会在手动写的finally代码块之前执行。*/
try (OutputStream os = new FileOutputStream("C:/Users/chy/Desktop/1.txt")) {os.write("hello".getBytes());
} catch (FileNotFoundException e) {//...
} catch (IOException e) {//...
}/*** 如果有多个要关闭的资源，分号隔开。关闭顺序与声明顺序相反，后声明的先关闭。* 只要实现了AutoCloseable接口的类，都可以使用此种方式关闭资源。* IO流的4个抽象基类InputStream、OutputStream、Reader、Writer都实现了AutoCloseable接口，IO流基本都可以使用此方式关闭*/
try (OutputStream os1 = new FileOutputStream("C:/Users/chy/Desktop/1.txt");OutputStream os2 = new FileOutputStream("C:/Users/chy/Desktop/2.txt")
) {os1.write("hello".getBytes());
} catch (FileNotFoundException e) {//...
} catch (IOException e) {//...
}

自动关闭资源，方便，代码也简洁，尽量用try-with-resources代替try…finally来关闭资源。

jdk8

接口新增的默认方法、静态方法

public interface Animal {void run();void eat();default void breath() {System.out.println("默认方法实现...");}static void test() {System.out.println("静态⽅法...");}}

jdk8以前：接口中的方法只能是抽象方法，不能有方法体（实现）

jdk8

接口新增了默认方法：方法使用default修饰，必须提供方法体（实现）。实现类会继承默认方法，可根据需要重写默认方法，实现类调用默认方法时，如果进行了重写则默认调用本类中的默认方法，否则调用接口中的默认方法。①默认访问权限不需要任何访问权限关键字修饰，default并不是默认访问权限，接口中方法的访问权限只能是public；②默认方法只能存在于接口中，不能存在于抽象类、具体实现类中。
接口新增了静态方法：方法使用static修饰，必须提供方法体（实现），通过接口名调用。关于静态方法，注意：子类会继承父类的静态方法，但子接口、实现类不会继承父接口的静态方法。

接口新增了默认方法、静态方法，但和抽象类相比，接口依然不能表达对象状态的变化（接口中不能定义对象的成员字段），接口不能完全替代抽象类。

新增的base64加解密api

base64常用于数据的加解密，比如登录使用http+密码明文很不安全，最好使用https，如果坚持要用http，最好加密敏感数据后再进行传输。

jdk7的base64加解密方式

//原文本
String text = "年年有鱼";
//编码后的文本
String encodedText;//编码
BASE64Encoder encoder = new BASE64Encoder();
encodedText = encoder.encode(text.getBytes("UTF-8"));
System.out.println("编码后得到的文本：" + encodedText);//解码
BASE64Decoder decoder = new BASE64Decoder();
text = new String(decoder.decodeBuffer(encodedText), "UTF-8");
System.out.println("解码后得到的原文本：" + text);

编解码性能差，据说会在将来的版本中删除。

jdk8提供了性能更好的base64加解密方式

//原文本
String text = "年年有鱼";
//编码后的文本
String encodedText;//编码
Base64.Encoder encoder = Base64.getEncoder();
encodedText = encoder.encodeToString(text.getBytes("UTF-8"));
System.out.println("编码后得到的文本：" + encodedText);//解码
Base64.Decoder decoder = Base64.getDecoder();
text = new String(decoder.decode(encodedText), "UTF8");
System.out.println("解码后得到的原文本：" + text);

新增的时间日期类、时间日期处理类

jdk7的时间日期类：Date、Calendar，非线程安全，api设计差、不好使用。
jdk8新增的时间日期类：LocalDate 日期、LocalTime 时间、LocalDateTime 日期+时间，api众多，操作方便。
jdk7的时间日期处理类：DateFormat、SimpleDateFormat，SimpleDateFormat简单易用，但非线程安全
jdk8新增的时间日期处理类：DateTimeFormatter，同样好用，但线程安全

//新增的三个时间日期类，创建对象的方法都是静态方法，通过类名直接调用
LocalDateTime today = LocalDateTime.now();
LocalDateTime dt = LocalDateTime.of(2020, 1, 1, 1, 1, 1);//使用新增的时间日期处理类进行格式化
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatDT = dtf.format(today);
System.out.println("格式化后得到的时间日期：" + formatDT);//计算2个时间日期的差值。第二个参数减第一个参数
Duration duration = Duration.between(dt, today);
//Duration包含了多种差值表示方式
System.out.println("dt距today多少天：" + duration.toDays());
System.out.println("dt距today多少小时：" + duration.toHours());

新增的NPE处理类Optional

使用大段大段的if…else…判空，可读性差，可以用Optional替代对象成员变量的if判空。

User user = null;//user可以为null
Optional<User> optional = Optional.ofNullable(user);//user不能为null，为null时会发生NPE
Optional<User> optional = Optional.of(user);//Optional可以看做对对象的包装，判断内部对象是否为null
boolean present = optional.isPresent();//获取内部对象，内部对象为null时会发生NPE
User user = optional.get();//可以对optional中的对象进行过滤，满足条件才保留在optional中，以新对象的形式返回
//user可以为null，为null时不会发生NPE
optional = optional.filter(user -> StringUtils.isBlank(user.getUsername()) && user.getUsername().length() < 10);String defaultHeadImg = "/xxx/xxx.png";//user对象的headImg属性不为null，则返回headImg，为null则返回设置的默认值
String headImg = optional.map(user -> user.getHeadImg()).orElse(defaultHeadImg);//可以把lambda表达式的返回值作为默认值
String headImg = optional.map(user -> user.getHeadImg()).orElseGet(() -> defaultHeadImg);//也可以直接抛出异常
String headImg = optional.map(user -> user.getHeadImg()).orElseThrow(() -> new RuntimeException("未选择头像"));//以上三句代码，user为null时也不会发生NPE//也可以先进行判断，内部对象不为null才进行操作
optional.ifPresent(user -> {//传入的是对象地址，对形参的操作就是对实参的操作//...
});

创建Optional对象，对内部对象进行判空，再进行操作，这样使用Optional没有意义，比原先的if判空还写得复杂。
Optional适合在对象可能为null（需要判空）时单次获取对象的属性，不是每种判空都适合使用Optional，比如对包装类、String这些简单对象的判空，比如要多次获取对象的（多个）属性进行操作。高频使用map()方法会显得很繁琐，最好先对对象进行判空，再进行后续操作，有时候使用if直接判空更好。

新增的函数式接口、lambda表达式

函数式接口

jdk8新增了函数式接口，以支持函数式编程

@FunctionalInterface  //标识为函数式接口
public interface MyStringUtils {String join(String str1, String str2);}

函数式接口中的抽象方法有且只能有1个，可以有静态方法、默认实现的方法，但抽象方法必须有、且只能有1个。

lambda表达式

lambda表达式可以实现只有一个抽象方法的接口，不局限于函数式接口，只要接口中只有一个抽象方法，就可以使用lambda表达式实现。

//原来的写法：使用匿名内部类
MyStringUtils myStringUtils1 = new MyStringUtils() {@Overridepublic String join(String str1, String str2) {return str1 + str2;}
};//使用lambda表达式。lambda表达式实质是使用匿名内部类，语法糖，代码更加简洁
MyStringUtils myStringUtils2 = (str1, str2) -> str1 + str2;//相比于匿名内部类，lambda表达式除了简洁之外，还可以直接访问外部变量，但只能访问、不能修改
String username = "chy";
userlist.forEach(user -> {//可以直接使用外部变量usernameif (username.equals(user.getUsername())) {System.out.println(user);}
});

只有一个参数时，可以省略()
方法体中只有一条语句时，可以省略{ }
方法体中只有一条语句，且方法有返回值时，可以缺省return关键字

jdk8内置的函数式接口

jdk、各种框架都内置了多个函数式接口，jdk8常见的内置函数式接口如下

Consumer：void accept(T t); 消费型接口，有入参、无返回值，用于处理传入的参数。
Supplier：T get(); 供给型接口，无入参、有返回值，用于提供某个类型的实例。
Function<T, R>：R apply(T t); 函数型接口，有入参、有返回值，用于处理传入的数据，并返回结果。
BiFunction：R apply(T t, U u); Function只能接收⼀个参数，BiFunction可以接收2个参数
Predicate： boolean test(T t); 断⾔型接口，有入参、有返回值，返回值为布尔类型，用于校验传入的数据。

示例

public class Test {/*** 过滤list中的元素，返回满足条件的元素*/public static <T> List<T> filterList(List<T> list, Predicate<T> predicate) {List<T> resultList = new ArrayList<>();for (T ele : list) {//调用predicate的test()进行判断if (predicate.test(ele)) {resultList.add(ele);}}return resultList;}public static void main(String[] args) {List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu");//条件：字符串长度>5List<String> resultList = filterList(list, ele -> ele.length() > 5);System.out.println("满足条件的元素：" + resultList);}}

新增的方法引用方式::

在lambda表达式中，可以使用双冒号引用方法

User user = new User();
Optional<User> optional = Optional.ofNullable(user);//原来的调用方式：u.getHeadImg()
String headImg1 = optional.map(u->u.getHeadImg()).orElse("/xxx/defaultHeadImg.png");
//新的调用方式：User::getHeadImg
String headImg2 = optional.map(User::getHeadImg).orElse("/xxx/defaultHeadImg.png");

这种方法引用方式只能在lambda表达式中使用

新增的集合操作方式Stream

参考：https://blog.csdn.net/chy_18883701161/article/details/124169038

新的内存空间Matespace

jdk、jvm都只是一个标准、规范，有多种实现，此处以主流的jvm实现Hotspot为准。

jdk7用永久代（permanent generation）来此存储类的元数据，永久代使用的是jvm的内存空间，可能发生OOM。

jdk8使用元空间（Metaspace）代替永久代，元空间使用本地内存，受制于机器物理内存的大小，基本不会发生OOM。

jdk9

接口新增的私有方法

public interface Animal {private void m1() {System.out.println("私有方法");}default void m2() {System.out.println("默认方法");m1();}static void m3() {System.out.println("静态方法");}}

私有方法使用private修饰，自然不会被继承，只能在当前接口中调用，且必须提供方法体（实现），不然没有意义。

说明

接口中的私有方法、默认方法、静态方法都必须提供方法体（实现）。
私有方法不能被继承，默认方法可以被继承，接口中的静态方法不能被继承，但类中的静态方法可以被继承。

增强的try-with-resource

OutputStream os1 = new FileOutputStream("C:/Users/chy/Desktop/1.txt");
OutputStream os2 = new FileOutputStream("C:/Users/chy/Desktop/2.txt");//可以将资源声明放在try()外面，()中指定资源变量即可，有多个时分号隔开 try (os1; os2)
try (os1) {os1.write("hello".getBytes());
} catch (FileNotFoundException e) {e.printStackTrace();
} catch (IOException e) {e.printStackTrace();
}

新增的创建只读集合的api

之前创建只读集合的方式

List<String> list = new ArrayList<>();
list.add("chy");
//设置为只读集合。原集合不变，返回一个只读集合
list = Collections.unmodifiableList(list);Set<String> set = new HashSet<>();
set.add("chy");
//设置为只读集合
set = Collections.unmodifiableSet(set);Map<String, String> map = new HashMap<>();
map.put("name", "chy");
//设置为只读集合
map = Collections.unmodifiableMap(map);//Arrays.asList()创建的也是只读集合
List<String> list = Arrays.asList("chy1", "chy2");

jdk9新增的方式

List<String> list = List.of("chy1", "chy2");Set<String> set = Set.of("chy1", "chy2");Map<String, Object> map = Map.of("name", "chy", "age", 20);

模块化

jdk9将把jdk、jre、jar等分成较小的模块，使用时无需全部引入，只引入所需的模块即可，模块化降低了代码耦合度、大大缩小了应用体积。

jdk10

新增的创建只读集合的api

ArrayList<String> list1 = new ArrayList<>();
list1.add("chy");//jdk10的List、Set、Map都提供了静态方法copyOf()创建对应的只读集合，原集合不变，以新集合的方式返回
List<String> list2 = List.copyOf(list1);

jdk9、10的这2个api实质都是调用 ImmutableCollections 类的方法创建只读集合。immutable 只读的、不可变更的。

新增的局部变量类型推断var

//声明时可以声明为var类型，声明时就必须初始化，初始化时不能赋null，会自动根据赋的值推断变量类型
var a = 1;
var b = 2;
System.out.println(a + b);

var只能用于声明局部变量，不能用于声明方法形参，不能作为方法的返回值类型。

jdk11

新增的http客户端

基本使用

//要请求的uri
URI uri = URI.create("http://www.baidu.com");//创建httpClient。可以HttpClient.newHttpClient()直接创建HttpClient对象，但连接最好都设置超时时间
HttpClient httpClient = HttpClient.newBuilder().connectTimeout(Duration.ofMillis(5000)).build();//创建请求。get请求方式
HttpRequest request = HttpRequest.newBuilder().timeout(Duration.ofMillis(5000)).uri(uri)// 默认就是get方式，可省略// .GET()// 配置项.header("key1", "value1").header("key2", "value2").build();//执行请求
try {HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());//使用响应中的数据System.out.println(response.body());
} catch (IOException e) {e.printStackTrace();
} catch (InterruptedException e) {e.printStackTrace();
}

发送post方式的请求

//post请求方式传递表单数据
String formData = "username=chy&password=1234";
HttpRequest request1 = HttpRequest.newBuilder().uri(uri).header("Content-Type", "application/x-www-formurlencoded").POST(HttpRequest.BodyPublishers.ofString(formData)).build();//post方式传递json数据
String jsonData = "{\"username\":\"chy\",\"password\":\"abcd\"}";
HttpRequest request2 = HttpRequest.newBuilder().uri(uri).header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(jsonData)).build();

发送异步请求

// 同步请求
// HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
// System.out.println(response.body());// 异步请求
CompletableFuture<String> completableFuture = httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString()).thenApply(response -> response.body());//要执行的其它代码
//......//使用响应。completableFuture.get()会阻塞当前线程，直到请求完成返回了响应，或者超时
String resposeBody = completableFuture.get();
System.out.println(resposeBody);

发送http2请求

HttpRequest request = HttpRequest.newBuilder().timeout(Duration.ofMillis(5000)).uri(uri)//指定httpClient使用的http协议版本.version(HttpClient.Version.HTTP_2).header("key1", "value1").header("key2", "value2").build();

目前http协议的主流版本是http1.1，http2是下一代版本。http2强制使用https，需要服务器支持http2。

javac、java命令的优化

以前编译执行：先javac编译，再java执行，本地会生成.class文件。

jdk11：无需javac编译，直接java执行即可，本地不会生成.class文件。

jdk13

jdk13新增了文本块、增强了switch表达式，但这2个特性在jdk13中都是预览状态、没有正式发布。