Java知识回顾 （18）Java 8、9、11的新特性

Java 8

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。

新特性

Java8 新增了非常多的特性，我们主要讨论以下几个：

• Lambda 表达式 − Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中。

• 方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

• 默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。

• 新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。

• Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。

• Date Time API − 加强对日期与时间的处理。

• Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。

• Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

更多的新特性可以参阅官网：What's New in JDK 8

详细的新特性：

序号	特性
1	Lambda 表达式
2	方法引用
3	函数式接口
4	默认方法
5	Stream
6	Optional 类
7	Nashorn, JavaScript 引擎
8	新的日期时间 API
9	Base64

排序的示例

// 使用 java 7 排序
private void sortUsingJava7(List<String> names){
   Collections.sort(names, new Comparator<String>() {
      @Override
      public int compare(String s1, String s2) {
         return s1.compareTo(s2);
      }
   });
}

// 使用 java 8 排序
private void sortUsingJava8(List<String> names){
   Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
}

JAVA 9

Java 9 发布于 2017 年 9 月 22 日，带来了很多新特性，其中最主要的变化是已经实现的模块化系统。接下来我们会详细介绍 Java 9 的新特性。

新特性

• 模块系统：模块是一个包的容器，Java 9 最大的变化之一是引入了模块系统（Jigsaw 项目）。
• REPL (JShell)：交互式编程环境。
• HTTP 2 客户端：HTTP/2标准是HTTP协议的最新版本，新的 HTTPClient API 支持 WebSocket 和 HTTP2 流以及服务器推送特性。
• 改进的 Javadoc：Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。
• 多版本兼容 JAR 包：多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本。
• 集合工厂方法：List，Set 和 Map 接口中，新的静态工厂方法可以创建这些集合的不可变实例。
• 私有接口方法：在接口中使用private私有方法。我们可以使用 private 访问修饰符在接口中编写私有方法。
• 进程 API: 改进的 API 来控制和管理操作系统进程。引进 java.lang.ProcessHandle 及其嵌套接口 Info 来让开发者逃离时常因为要获取一个本地进程的 PID 而不得不使用本地代码的窘境。
• 改进的 Stream API：改进的 Stream API 添加了一些便利的方法，使流处理更容易，并使用收集器编写复杂的查询。
• 改进 try-with-resources：如果你已经有一个资源是 final 或等效于 final 变量,您可以在 try-with-resources 语句中使用该变量，而无需在 try-with-resources 语句中声明一个新变量。
• 改进的弃用注解 @Deprecated：注解 @Deprecated 可以标记 Java API 状态，可以表示被标记的 API 将会被移除，或者已经破坏。
• 改进钻石操作符(Diamond Operator) ：匿名类可以使用钻石操作符(Diamond Operator)。
• 改进 Optional 类：java.util.Optional 添加了很多新的有用方法，Optional 可以直接转为 stream。
• 多分辨率图像 API：定义多分辨率图像API，开发者可以很容易的操作和展示不同分辨率的图像了。
• 改进的 CompletableFuture API ： CompletableFuture 类的异步机制可以在 ProcessHandle.onExit 方法退出时执行操作。
• 轻量级的 JSON API：内置了一个轻量级的JSON API
• 响应式流（Reactive Streams) API: Java 9中引入了新的响应式流 API 来支持 Java 9 中的响应式编程。

更多的新特性可以参阅官网：What's New in JDK 9

详细的：

序号	特性
1	模块系统
2	REPL (JShell)
3	改进的 Javadoc
4	多版本兼容 JAR 包
5	集合工厂方法
6	私有接口方法
7	进程 API
8	Stream API
9	try-with-resources
10	@Deprecated
11	内部类的钻石操作符(Diamond Operator)
12	Optional 类
13	多分辨率图像 API
14	CompletableFuture API

Java 11

美国时间 2018年09 月 25 日，Oralce 正式发布了 Java 11，这是据 Java 8 以后支持的首个长期版本。

Java 8 扩展支持到 2025 年，而 Java 11 扩展支持到 2026 年。Java 11 长期支持，也已经包含了 9 和 10 的全部功能，9 和 10 自然就活到头了。

局部变量类型推断

var str = "我是刘zzz";

var list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
list.add(233);//如果 new ArrayList<Strnig>规定的泛型是 String，就不能这么写了
list.forEach(s-> System.out.println(s));

lamada 语法

new Thread(()->{
    for (int i=0; i<5; i++){
        System.out.println(i);
    }
}).start();

public interface Customer {
    void accpet(String str);
}

Customer customer = (var str1) -> System.out.println(str1.toUpperCase());
        customer.accpet("sdflksjf");

增强的方法

 //集合的创建可以更简单，Set 也有 of()
  List<String> list1 = List.of("aa","bb","cc");//Arrays.asList() 效果一样
  list1.add("dd");//java.lang.UnsupportedOperationException
  System.out.println(list1);

Stream 流

/**
 * 流的处理的三个步骤
  * 1，创建流
  * 2，中间操作
  * 3，终止操作
  */
 Stream<Integer> stream1 = Stream.of(1,10, 3, 20, 30, 50);
 //stream.forEach(t-> System.out.println(t));
 stream1.forEach(System.out::println);//有参数无返回值

 //如果为空不会报错，但传入null会报空指针，
 Stream<Object> stream2 = Stream.of();//Stream.of(null);
 stream2.forEach(System.out::println);
 //对于 null 的情况，可以用 ofNullable
 Stream<Object> stream3 = Stream.ofNullable(null);
 stream3.forEach(System.out::println);

 System.out.println("****************");
 Stream<Integer> stream4 = Stream.of(1,5, 3, 20, 30, 50);
 //Stream<Integer> takeWhile = stream4.takeWhile(t -> t % 2 != 0);//为奇数时留下，形成新 Stream
 //takeWhile.forEach(System.out::println);
 Stream<Integer> dropWhile = stream4.dropWhile(t -> t % 2 != 0);//为奇数时丢弃，形成新 Stream
 dropWhile.forEach(System.out::println);

 //流的迭代，创建流
 Stream<Integer> iterate = Stream.iterate(1, t -> (2 * t) + 1);
 //如果不加limit(10)，会无限迭代输出，这是 jdk11 之前的做法(用 limit 限制)
 iterate.limit(10).forEach(System.out::println);
 //jdk 11 的做法
 System.out.println("***************");
 Stream<Integer> stream = Stream.iterate(1, t -> t < 1000, t -> (2 * t) + 1);
 stream.forEach(System.out::println);

字符串和 Operational

String str1 = "\t \n\r ";
//判断字符串是否是空白字符
System.out.println(str1.isBlank());
System.out.println("*****===========");
str1 = "\t abc \r \n  ";
//去除字符串首尾中的空白，包括英文和其它所有语言的空白字符
String strip = str1.strip();
//去除字符串首部的空白，包括汉字
String stripLeading = strip.stripLeading();
//去除字符串尾部的空白，包括汉字
String stripTrailing = strip.stripTrailing();
System.out.println(strip+"<====>"+strip.length());

str1 = "java";
str1.repeat(3);//把str1 重复三次，输出   javajavajava

//去除字符串首尾中的空白，只能去除码值小于32的(如果是中文全角的空白是去除不了的)
String trim = str1.trim();
System.out.println(trim+"<====>"+trim.length());

String str = null;
//of 和 get() 都不建议用，如果传入的null,会报空指针
/**Optional<String> stringOptional = Optional.of(str);
System.out.println(stringOptional.get());**/

//一般用 ofNullable，取值用 orElse()
Optional<String> optionalS = Optional.ofNullable(str);
//如果str不为null,返回str的内容，否则返回 "空串代替"
String orElse = optionalS.orElse("空串代替");
////如果 str 不为null,返回 str 的内容，否则执行 f() 方法
orElse = optionalS.orElse(f());
System.out.println(orElse);
//orElse 和 orElseGet 区别：无论 str是否为空，orElse里面的都会执行，orElseGet 只有 str 为空才执行
String orElseGet = optionalS.orElseGet(() -> f());
System.out.println(orElseGet);

//orElseThrow也有重载方法，跟orElseGet 用法类似..
String orElseThrow = optionalS.orElseThrow();
System.out.println(orElseThrow);//抛出 NoSuchElementException，底层还是空指针，不过源码做了控制而已

static String f(){
   System.out.println("执行了f() 这个方法");
    return "lhg";
}

字符串和输入流的 API

以前输入输出文件

FileInputStream fis = new FileInputStream("D:\\ideaProjects\\Demo_JDK12\\src\\com\\lhg\\demo\\StringTest.java");
FileOutputStream fos = new FileOutputStream("d://demo.java");
BufferedReader br = new BufferedReader(new FileReader("D:\\ideaProjects\\Demo_JDK12\\src\\com\\lhg\\demo\\StringTest.java"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d:/demo3.java"));
byte[] buff = new byte[fis.available()];//fis.available():得到文件的有效字节数
int len;//读进缓冲数组里面
String line;
//br bw方式
while ((line = br.readLine()) != null){
    bw.write(line);
    bw.newLine();
}
//fis fos 方式
while((len=fis.read(buff)) != -1){
    fos.write(buff, 0, len);
}

fos.close();
fis.close();
bw.close();
br.close();

通过 Stream

 FileInputStream fis = new FileInputStream("D:\\ideaProjects\\Demo_JDK12\\src\\com\\lhg\\demo\\StringTest.java");
 byte[] buff = new byte[fis.available()];//fis.available():得到文件的有效字节数
 int len;//读进缓冲数组里面
 fis.close();
 String string = new String(buff);
 string.lines().forEach(System.out::println);//可以直接输出或其它操作

transfer 复制流

InputStream is = StringTest.class.getClassLoader().getResourceAsStream("config.properties");
try(var os = new FileOutputStream("config_bak.properties")){
    is.transferTo(os);//输入流的数据自动复制到输出流
}
is.close();

Http 客户端

更简化的编译运行程序
之前的做法是 先javac Demo.java，然后java Demo 运行程序，
现在直接 java Demo.java 一步到位，不过 Demo.java 文件中所引用的 类必须全部来自文件本身(比如这个类 引用了 Teacher 这个类，那么 Teacher 这个类必须定义在 Demo.java 中)，如果 Demo.java 中有多个类，多个 main方法，哪个类在前，就执行哪个类的 main 方法(当然只有一个 public 类)

垃圾收集器改进

默认的 gc

epsilon gc

设置好后，重新运行上面那段代码，发现程序会因为堆空间不足很快退出

 ZGC java 11 最为瞩目的特性没有之一

参考

Java 11 正式发布，这 8 个逆天新特性教你写出更牛逼的代码

java 11 新特性