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