Java新特性总结（Java8-11）

Champion-Dai

已于 2022-04-18 23:18:08 修改

阅读量649

点赞数

分类专栏：沐白杂记（Java）文章标签： java新特性 java8 java11 java

于 2022-04-18 23:14:39 首次发布

本文链接：https://blog.csdn.net/qq_38584262/article/details/124262289

版权

沐白杂记（Java）专栏收录该内容

59 篇文章 8 订阅

订阅专栏

Java新特性（java8-11）

文章目录

Java新特性（java8-11）

一、Java8

1.1 Lambda & Functional Interface

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

public class LambdaExamples {
    
    @Test
    public void test(){
        new Thread(() -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

误区：

认为的：通过匿名函数生成Runnable对象，传递给Thread
事实上：内部优化直接调用了匿名函数（invokedynamic指令)

1.2 方法引用`::`操作符

public class MethodReference {
    @Test
    public void test(){

        var val = List.of(1,2,3,4,5).stream()
                .map(Object::toString)
                .map(Integer::new)
                .reduce((a,b)->a+b);
                
        System.out.println(val);

    }
}

1.3 Stream

一个Monad。函数式、流计算重磅炸弹，只要是平时在编码中多进行应用，多用就熟了。主要讲下新建流的几种方式

（1）值创建流。根据值来创建stream，可以通过Stream.of()显示的来创建流。对应的流中的参数类型可以不受限制：

Stream<String> valueStream = Stream.of("1","2","d");
boolean optionalFlag = valueStream.map(value -> {
            			 return value + 2;})      			
        				.reduce((a,b) ->a+b)
        				.isPresent();

（2）数组创建流。根据数组来创建stream，可以通过Arrays.stream()来创建流。

Stream<String> arrayStream = Arrays
							.asList("1","2","3")
							.stream();

(3) 文件创建流。根据数组来创建stream，可以通过Files.lines()来创建流。

		try {
            Long count = Files.lines(Paths.get(""), Charset.defaultCharset())
            				  .count();
        } catch (IOException e) {
            e.printStackTrace();
        }

(4) 函数生成。根据函数来创建stream，可以通过Stream.generate()或者Stream.iterate()来创建流。但是根据函数生成的流是无限制大小，因此一般可以加上limit来控制流的大小。

Stream.iterate(1, n-> n * 2).limit(3).count();

Stream.generate(Math::random).limit(4).count();

1.4 Optional

一个Monad。流计算必备工具，减少空值检查。什么是Optional 类：Optional 类 (java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在用 Optional 可以更好的表达这个概念；并且可以避免空指針异常。

常用API:

（1）Option.of(T t)。创建一个 Optional 实例

@Test
public void test01(){
// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
    Optional<Employee> op = Optional.of(new Employee());
    Employee employee = op.get();
}

(2) Optional.ofNullable(T t)。若 t 不为 null，创建 Optional 实例，否则空实例

@Test
public void test03(){
    Optional<Employee> op = Optional.ofNullable(new Employee());
    Employee employee = op.get();
}

(3) isPresent()：判断是否包含某值

 // Optional.isPresent - 判断值是否存在
   //a是一个Optional<Integer>对象
 System.out.println("第一个参数值存在: " + a.isPresent());
 
 //输出    第一个参数值存在: false

（4）orElse(T t)：如果调用对象包含值，返回该值，否则返回 t

    // Optional.orElse - 如果值存在，返回它，否则返回默认值
       //a是一个Optional<Integer>对象
      Integer value1 = a.orElse(0);

(5) get(): Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException

 //Optional.get - 获取值，值需要存在，否则抛出异常：NoSuchElementException
    //a是一个Optional<Integer>对象
      Integer value2 = a.get();

（6） map(Function f) 如果有值对其处理，并返回处理后的 Optional，否则返回 Optional.empty()

Optional<Employee> op4 = Optional.ofNullable(new Employee(1, "张三"));
Optional<Integer> map = op4.map(e -> e.getAge());
System.err.println(map.get());

（7）Optional.empty(T t)：创建一个空的 Optional 实例

（8）orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回 s 获取的值

（9）flatmap(Function mapper)：与 map 相似，要求返回值必须是 Optional

1.5 接口的方法(static, default, private)

static(java 8)
default(java 8)
private(java 9)

public interface Stream<T> extends BaseStream<T, Stream<T>> {

   // 每个Stream Monad都有这个方法
   default Stream<T> takeWhile(Predicate<? super T> predicate) {
   ...
       foo(); // 可以调用
   }
   
   // 可以通过Stream.empty()构造空的流
   public static<T> Stream<T> empty() {
    ...     
   }
    
   // 不是源代码中的程序
   private foo(){}
    
}

1.6 Java 8 Nashorn JavaScript

在Java8中增加，在Java11中标记为Deprecated，在Java15中移出的新特性。支持javascriptES5语法。

public void test_engine() throws ScriptException {

    var jscode = " [1,2,3].map(function(x){return x + 1;}).join('-');";
    ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
    ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");

    Object result = nashorn.eval(jscode);


    System.out.println(result);
    // 2-3-4

}

脚本这么多专门选JS没有优势。

1.7 本地化日期处理升级

提供了Local和Zoned两种处理日期的方式，在新的API中不再允许mutable的操作（非线程安全）；另外对时区采取更好的处理方法：如果用户的系统不考虑国际化，那么就用Local的日期，如果考虑国际化，可以构造带时区的DateTime。

@Test
public void test_date(){
    // 2022年2月22日
    var date = LocalDate.of(2022, 2, 22);

    // 10:55:59
    var time = LocalTime.of(10, 55, 59);

    // 当前时间
    var datetime = LocalDateTime.of(date, time);

    var zoneDT = ZonedDateTime.of(datetime, ZoneId.of("Asia/Shanghai"));
}

1.8 内置了Base64工具

tips：对0~255之间的字符，Base64编码是以4个可见字符去描述3个字符。会增加数据的体积，但是因为所有字符都可以读，用Base64编码描述的字符串，在URL、XML中都不会被转义。

Base64.Decoder和Base64.Encoder类。

二、Java9

2.1 模块系统

Java9开始，引入模块化系统，目的是能够实现模块化的关键目标，可配置的封装隔离机制。推荐写的比较好的一个博客：https://www.cnblogs.com/felordcn/p/16049873.html

2.2 交互式编程环境(JShell)

除了上图中的能力，也提供API，可以动态的eval程序。

2.3 新的HTTP 2.0 Clinet

主要针对旧Client，提供Buidler，方便用户设置header和参数。

另外支持HTTP2.0，HTTP2.0兼容HTTP1.1的能力，主要是从性能角度进行了调优。理解HTTP2.0主要是这几个特性：

多个HTTP 请求/返回在一个TCP请求上多路复用（客户端要负责实现多路复用）
头部压缩算法（客户端要负责解压）
Server Push：服务器可能会给客户端额外的文件（浏览器要负责识别，并缓存这些文件，客户端不一定要实现）

 HttpClient httpClient 
                = HttpClient.newHttpClient(); 
  

HttpRequest httpRequest 
    = HttpRequest 
    .newBuilder() 
    .headers("x-key", "123456", "x-name", "something")
    .uri(new URI("https://www.baidu.com")) 
    .GET() 
    .build(); 

HttpResponse<String> response 
    = httpClient.send( 
    httpRequest, 
    HttpResponse.BodyHandler.asString()); 

System.out.println(response.statusCode());
System.out.println(response.body());

2.4 改进了Javadoc

大家平时读的很多Java的文档（特别是官方的文档），就是用Javadoc生成的。所以这也是Java文档——比较难读的原因之一。写程序的人注释往往是为了让内部人员读懂，而文档是面向外部人员。

例如：

javadoc -d foo -html5 MyHelloWorld.java

可以生成符合HTML5标准的网页。

2.5 支持multirelease jar包

项目目录结构可以这样安排，不同的版本的程序在不同的目录下。

|-java
|   └──java8
|       └── hello
|           └── xxx.java
|   └──java9
|       └── hello
|           └── xxx.java

然后可以通过javac 编译成不同版本的class文件：

javac --release 9 java8/hello/xxx.java
javac --release 8 java9/hello/xxx.java

最后用jar 可以产生不同版本的jar 包：

jar -c -f xxx.jar -C java8 . --release 9 -C java9.

这样xxx.jar 中会同时有java8和java9的程序。

java -cp test.jar hello // 不同java版本访问不同的类

这个功能的意义是什么？

Java升级太快了，多版本同时发布，让程序的提供者可以兼容不同用户的需求。

2.6 集合的工厂方法

var set = Set.of("Apple", "Google");
var list = List.of("...", "abc", "123"); 
var map = Map.of("String", 5, "Integer", 6);

2.7 增加ProcessHandler

增加了一个ProcessHandler用于查看某个特定进程的信息：启动时间、关联参数等等。目前是加强对进程的支持。

ProcessBuilder builder = new ProcessBuilder("ls -l");
Process p = builder.start();
ProcessHandle.Info info = p.info();

// start time
info.startInstance();

// arguments
info.arguments();

2.8 Stream API增加了方法

为了方便操作，提供了更多的Stream API。

takeWhile

字面意思：take while x != 7 is hold ，中文意思：在x != 7的时候，拿出结果，否则停下来

Stream.of(2,1,3,7,4,6,8,0).takeWhile(x -> x != 7)
   .collect(Collectors.toList());
// [2,1,3]

dropWhile

字面意思： drop while x!=7 is hold，中文意思：在x!=7的时候，丢弃，否则停下来

Stream.of(2,1,3,7,4,6,8,0).dropWhile(x -> x!=7)
  .collect(Collectors.toList());
//[7, 4, 6, 8, 0]

iterate

 Stream.iterate(
     10,  // 初始值
     x -> x < 100, // 终结断言
     x->x+2 // 递推函数
 ).collect(Collectors.toList());

// [10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

另外一个例子：

jshell> Stream.iterate("i", x -> x.length() < 20, x->x+"i").collect(Collectors.toList());
//[i, ii, iii, iiii, iiiii, iiiiii, iiiiiii, iiiiiiii, iiiiiiiii, iiiiiiiiii, iiiiiiiiiii, iiiiiiiiiiii, iiiiiiiiiiiii, iiiiiiiiiiiiii, iiiiiiiiiiiiiii, iiiiiiiiiiiiiiii, iiiiiiiiiiiiiiiii, iiiiiiiiiiiiiiiiii, iiiiiiiiiiiiiiiiiii]

ofNullable

Stream.ofNullable(null); // Stream.empty()

2.9 <>钻石操作符语法优化

允许匿名类使用钻石操作符。

Iterable<Integer> it = new Iterable<>() {
    @Override
    public Iterator<Integer> iterator() {
        ...
    }
};

2.10 CompletableFuture改进

CompletableFuture是java异步计算能力的核心，代表一个需要在未来被计算出来的的值。

在 Java9中针对已有能力，对CompletableFuture进行了提升。

2.10.1 增加completeOnTimeout方法

 @Test
public void test() throws ExecutionException, InterruptedException {
    var future = new CompletableFuture<>();
    Executors.newCachedThreadPool().submit(() -> {
        //Thread.sleep(1000);
        // future.complete("Hello");
        // 等价于 
        // completeOnTimeout是Java9新语法
        future.completeOnTimeout("Hello", 1000, TimeUnit.MILLISECONDS);
        return null;
    });
    // sync. method blocking...
    var value = future.get();
    System.out.println(value);

}

2.10.2 增加直接成功/失败的future工厂方法

@Test
public void test2() throws ExecutionException, InterruptedException {
    var successFuture = CompletableFuture.completedFuture("Hello");
    var failFuture = CompletableFuture.failedFuture(new InterruptedException());

    System.out.println(successFuture.get()); // hello

    if(failFuture.isCompletedExceptionally()) {
        System.out.println("error"); // print
    }
    System.out.println(failFuture.get()); // Exception
}

2.11 try-with-resources的改进

Java中的一部分资源对象会继承于Closeable接口，这就可以使用try-with-resources 能力。例如：

public abstract class InputStream implements Closeable {
    ...
}

如果要使用的话：

@Test
public void test() throws FileNotFoundException, IOException {
    var fin = new FileInputStream("somefile");
    try(fin) { // AutoClose
        fin.read();
    }

}

上面直接对某个实现了Closeable的对象进行try，并且主动触发close能力，是Java9的一个优化。

三、Java 10

3.1 局部变量类型推断

var list = new LinkedList<Integer>();
// list is LinkedList<Integer>

var o = Stream.of(1,2,3);
// o is Stream<Integer>

3.2 JDK代码仓库整理

所有JDK代码不再使用8个仓库存储：root、corba、hotspot、jaxp、jaxws、jdk、langtools、nashorn。

统一成为1个仓库。

主要是解决原子提交的问题：1个功能可能需要更新多个代码仓库。

3.3 G1增加并行能力

在mark-sweep-compact的GC算法上，再增加并行能力。

见JVM GC部分

3.4 优化：应用程序数据共享（Application Data Sharing)

ADS：允许多个JVM实例共享共同用到的类，这些类以共享内存的形式存在。这样对于运行了多个JVM的机器，可以节省内存空间以及类的加载速度。

3.5 计划移除JNI头生成工具

JNI（Java Native Interface)是Java程序和Native(C, C++)程序沟通的接口。一个Java类，如果要Native调用，通常是在Android开发当中，需要生成一个C/C++的头文件。之前可以用javah来生成，现在用javah工具生成的时候，会有一行warning。

以后JNI的能力会被Panama项目替代，一个专门为非java语言提供接口的库。

3.6 增加实验性的Graal编译器

可以配置参数开启：

-XX：+ UnlockExperimentalVMOptions -XX：+ UseJVMCICompiler

Graal是一款同时支持JIT和AOT的编译器。

JIT(Just in Time)一边编译一边执行，执行完第一次之后，下一次不需要编译
AOT(Ahead of Time)，类似C/C++那样，先编译成机器码，再执行。注意，是机器码，越过了JVM的bytecode。

目前还是实验阶段，不建议用作生产。已经发现了不少的Bug，等待进一步的修复。

四、Java 11

4.1 引入NestedMembers概念

嵌套类和它的父亲作为一组NestedMembers，可以互相访问元数据。

public class Nested {

    class A{

        private String name = "123";
    }

    class B{
        public void bar() throws NoSuchFieldException {
            System.out.println(A.class.getDeclaredField("name"));
        }

    }

    @Test
    public void test() throws NoSuchFieldException {
        var b = new B();
        b.bar();
        // name 

        System.out.println(Arrays.toString(A.class.getNestMembers()));
        // [Nested, A, B]
        
        System.out.println(A.class.getNestHost());
        // Nested
        
        System.out.println(Arrays.toString(B.class.getNestMembers()));
        // [Nested, A, B]
        
        System.out.println(B.class.getNestHost());
        // Nested
    }
}

4.2 增加无操作GC回收器:Epsilon

Epsilon不会进行垃圾回收操作，是的，你没有看错，它不进行GC。

-XX:+UseEpsilonGC

Epsilon虽然不GC，但是仍然承担着内存分配的工作。（Java 的 GC也是Java的内存管理工具，更多见GC部分）

有点：

对于开发者明确知道不需要GC的程序有助于减少延迟
对于性能测试、压力测试场景，可以忽略GC带来的延迟

4.3 Lambda优化：允许使用 var定义匿名函数形参

@interface My{}
@Test
public void test1(){
    Predicate<String> predicate = (@My var a) -> true;
}

4.4 优化：增加字符串能处理函数

" ".isBlank();                // true
" Foo Bar ".strip();          // "Foo Bar"
" Foo Bar ".stripTrailing();  // " Foo Bar"
" Foo Bar ".stripLeading();   // "Foo Bar "
"Java".repeat(3);             // "JavaJavaJava"
"A\nB\nC".lines().count();    // 3