13 | *
14 | *
15 | *
16 | * @author WGR
17 | */
18 | public class _LocalHandShake {
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new04_heapallocation/_HeapAllication.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new04_heapallocation;
2 |
3 |
4 | /**
5 | * 在备用存储装置上的堆分配
6 | *
7 | *
8 | * JEP 316: Heap Allocation on Alternative Memory Devices
9 | * JEP 将使得 JVM 能够使用适用于不同类型的存储机制的堆。
10 | * @See
11 | *
12 | *
13 | * @author WGR
14 | *
15 | */
16 | public class _HeapAllication {
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new05_extunicode/_ExtUnicode.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new05_extunicode;
2 |
3 | /**
4 | * 额外的 Unicode 语言标签扩展
5 | *
6 | *
7 | * JEP 314: Additional Unicode Language-Tag Extensions
8 | * 改善 java.util.Locale 类和相关的 API 以实现额外 BCP 47 语言标签的 Unicode 扩展。
9 | * @See
10 | *
11 | *
12 | * @author WGR
13 | *
14 | */
15 | public class _ExtUnicode {
16 |
17 | }
18 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new06_jitcompiler/_JITCompiler.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new06_jitcompiler;
2 |
3 | /**
4 | * 试验性的基于Java的 JIT编译器
5 | *
6 | *
7 | * JEP 317: Experimental Java-Based JIT Compiler
8 | * 实现：
9 | * * 将 Graal 编译器研究项目引入到 JDK 中。并给将 Metropolis 项目成为现实，
10 | * * 使 JVM 性能与当前 C++ 所写版本匹敌（或有幸超越）提供基础。
11 | *
12 | * @See
13 | *
14 | *
15 | *
16 | * @author WGR
17 | *
18 | */
19 | public class _JITCompiler {
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new07_rootcertificates/_RootCertificates.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new07_rootcertificates;
2 |
3 |
4 | /**
5 | * 开源根证书
6 | *
7 | *
8 | * JEP 319: Root Certificates
9 | * 说明：
10 | * * 在 JDK 中将提供一套默认的 CA 根证书。关键的安全部件，如 TLS ，在 OpenJDK 构建中将默认有效。
11 | * * 这是 Oracle 正在努力确保 OpenJDK 二进制和 Oracle JDK 二进制功能上一样的工作的一部分，是一项有用的补充内容。
12 | *
13 | * @see
14 | * @See
15 | *
16 | *
17 | * @author WGR
18 | *
19 | */
20 | public class _RootCertificates {
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new08_ca/_new08_ca.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new08_ca;
2 |
3 | /**
4 | * 根证书颁发认证（CA）
5 | *
6 | *
7 | *
8 | * 这将使OpenJDK对开发人员更具吸引力，它还旨在减少OpenJDK和Oracle JDK构建之间的差异。
9 | * 附：暂时未在网上找到相关资料。
10 | *
11 | *
12 | *
13 | * @author WGR
14 | *
15 | */
16 | public class _new08_ca {
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new09_consolidatejdkf/_RemoveJavah.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new09_consolidatejdkf;
2 |
3 | /**
4 | *
5 | * 删除工具javah
6 | *
7 | *
8 | * JEP 313: Remove the Native-Header Generation Tool
9 | * 从JDK中移除了javah工具，这个很简单并且很重要。
10 | * @See
11 | *
12 | *
13 | * @author WGR
14 | *
15 | */
16 | public class _RemoveJavah {
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new10_removejavah/_RemoveJavah.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new10_removejavah;
2 |
3 | /**
4 | *
5 | * 删除工具javah
6 | *
7 | *
8 | * JEP 313: Remove the Native-Header Generation Tool
9 | * 从JDK中移除了javah工具，这个很简单并且很重要。
10 | * @See
11 | *
12 | *
13 | * @author WGR
14 | *
15 | */
16 | public class _RemoveJavah {
17 |
18 | }
19 |
20 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/new11_other/_API.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java10.new11_other;
2 |
3 | import java.io.BufferedReader;
4 | import java.io.ByteArrayInputStream;
5 | import java.io.ByteArrayOutputStream;
6 | import java.io.File;
7 | import java.io.FileInputStream;
8 | import java.io.FileNotFoundException;
9 | import java.io.InputStreamReader;
10 | import java.io.PrintWriter;
11 | import java.io.UnsupportedEncodingException;
12 | import java.util.ArrayList;
13 | import java.util.HashMap;
14 | import java.util.HashSet;
15 | import java.util.List;
16 | import java.util.Map;
17 | import java.util.Scanner;
18 | import java.util.Set;
19 |
20 | import org.junit.Test;
21 |
22 | /**
23 | *
24 | * Java10 新增扩展API类库
25 | *
26 | *
27 | * 新增方法：
28 | * * copyOf方法
29 | * * 重载toString()方法
30 | * * 流新增构造方法
31 | * * transferTo方法
32 | * * Formatter和Scanner新增构造
33 | *
34 | *
35 | *
36 | * @author WGR
37 | *
38 | */
39 | public class _API {
40 |
41 | /**
42 | * List/Set/Map 新增加了一个静态方法copyOf()
43 | */
44 | @Test
45 | public void testCopyOf() {
46 | var list = new ArrayList();
47 | list.add("a");
48 | list.add("b");
49 | list.add("c");
50 | list.add("d");
51 |
52 | var list2 = List.copyOf(list);
53 | list2.stream().forEach(System.out::println); // a b c d
54 |
55 | var set = new HashSet();
56 | set.add("赵");
57 | set.add("钱");
58 | set.add("孙");
59 | set.add("李");
60 |
61 | var set2 = Set.copyOf(set);
62 | set2.stream().forEach(System.out::println); // 赵 钱 孙 李
63 |
64 | var map = new HashMap<>();
65 | map.put("k1", "a");
66 | map.put("k2", "b");
67 |
68 | var map2 = Map.copyOf(map);
69 | var keys = map2.keySet();
70 | for (Object object : keys) {
71 | System.out.println(map2.get(object)); // a b
72 | }
73 | }
74 |
75 | /**
76 | *
77 | * 重载toString()方法，通过使用指定的字符集编码字节，将缓冲区的内容转换为字符串。
78 | * @throws UnsupportedEncodingException
79 | *
80 | */
81 | @Test
82 | public void testToString() throws UnsupportedEncodingException {
83 |
84 | String str = "上海天正";
85 | ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes("gbk"));
86 |
87 | ByteArrayOutputStream bos = new ByteArrayOutputStream();
88 |
89 | int c = 0;
90 | while((c = bis.read()) != -1) {
91 | bos.write(c);
92 | }
93 | //bos.toString() 默认的使用的UTF-8编码
94 | System.out.println(bos.toString());
95 | System.out.println(bos.toString("gbk"));
96 |
97 | }
98 |
99 | /**
100 | * java.io.PrintStream、java.io.PrintlWriter新增构造方法
101 | * @throws UnsupportedEncodingException
102 | * @throws FileNotFoundException
103 | */
104 | @Test
105 | public void testStructure1() throws Exception {
106 |
107 | String str = "上海天正";
108 | var p = new PrintWriter("d:/aa.txt", "gbk");
109 | p.println(str);
110 | p.flush();
111 | p.close();
112 |
113 | }
114 |
115 | /**
116 | * Reader:transferTo方法
117 | * 注：java9新增的是inputStream的transferTo方法
118 | *
119 | * @throws Exception
120 | *
121 | */
122 | @Test
123 | public void testTransferTo() throws Exception {
124 |
125 | var reader = new BufferedReader(new InputStreamReader(new FileInputStream("d:/aa.txt"), "gbk"));
126 | var p = new PrintWriter(new File("d:/cc.txt"));
127 | reader.transferTo(p);
128 | p.flush();
129 | p.close();
130 | reader.close();
131 |
132 | }
133 |
134 | /**
135 | * 新增构造方法
136 | * @throws Exception
137 | */
138 | @Test
139 | public void testStructure2() throws Exception {
140 |
141 | @SuppressWarnings("resource")
142 | var scan = new Scanner(new FileInputStream(new File("d:/aa.txt")),"gbk");
143 | scan.useDelimiter(" |,");
144 | while(scan.hasNext()) {
145 | System.out.println(scan.next());
146 | }
147 |
148 | }
149 |
150 |
151 |
152 | }
153 |
--------------------------------------------------------------------------------
/src/com/hepengju/java10/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java10的新特性
3 | *
4 | *
5 | * - 局部变量的类型推断 _VarInference.java
6 | *
- GC改进和内存管理 _GCimprove.java
7 | *
- 线程本地握手 _LocalHandShake.java
8 | *
- 备用内存设置上的堆分配 _HeapAllication.java
9 | *
- 其他Unicode语言 - 标记扩展 _ExtUnicode.java
10 | *
- 基于Java的实现性JIT编译器 _JITCompiler.java
11 | *
- 开源根证书 _RootCertificates.java
12 | *
- 根证书颁发认证
13 | *
- 将JDK生态整个单个存储库 _ConsolidataJDKF.java
14 | *
- 删除工具javah _RemoveJavah.java
15 | *
- 其他杂项改进
16 | *
17 | * - copyOf方法
18 | *
- 重载toString()方法
19 | *
- 流新增构造方法
20 | *
- transferTo方法
21 | *
- Formatter和Scanner新增构造
22 | *
23 | *
24 | *
25 | * @see What’s New in JDK 10
26 | *
27 | * @see What’s New in JDK 10
28 | *
29 | * @author hepengju
30 | *
31 | */
32 | package com.hepengju.java10;
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new01_string/_String.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new01_string;
2 |
3 | import java.io.FileInputStream;
4 |
5 | import org.junit.Test;
6 |
7 | /**
8 | *
9 | * 本类对String新增方法探索
10 | *
11 | *
12 | * 新增阐述：
13 | * * 新增strip、stripLeading、stripTrailing方法
14 | * * 新增repeat方法，重复
15 | * * 新增lines方法,变成流，方便操作
16 | *
17 | * @author WGR
18 | *
19 | */
20 |
21 | public class _String {
22 |
23 | /**
24 | * 新增isBlank方法
25 | * 判断字符串中的字符是否都是空白
26 | */
27 | @Test
28 | public void testIsBlank() {
29 |
30 | String string = " \t \r\n ";
31 | System.out.println(string.isBlank()); //true
32 |
33 | }
34 |
35 | /**
36 | * 新增strip、stripLeading、stripTrailing方法
37 | * strip 去重字符串首尾的空白, 包括英文和其他所有语言中的空白字符(功能比trim强大)
38 | * stripLeading 去重字符串首部的空白
39 | * stripTrailing 去重字符串尾部的空白
40 | * trim 去重字符串首尾的空白字符, 只能去除码值小于等于32的空白字符
41 | */
42 | @Test
43 | public void testStrip() {
44 |
45 | String string = " \t \r\n abc \t ";
46 | String string2 = string.strip();
47 | System.out.println(string2); //abc
48 | System.out.println(string2.length()); //3
49 |
50 | String string3 = string.trim();
51 | System.out.println(string3); //abc ;部分特殊空格去掉不了；
52 | System.out.println(string3.length()); //6
53 |
54 | String string4 = string.stripLeading();
55 | System.out.println(string4); //abc ;尾部空格没有去掉;
56 | System.out.println(string4.length()); //6
57 |
58 | String string5 = string.stripTrailing();
59 | System.out.println(string5); // abc;
60 | System.out.println(string5.length()); //10
61 |
62 | }
63 |
64 | /**
65 | * 新增repeat方法，重复
66 | */
67 | @Test
68 | public void testRepeat() {
69 | String string = "Java";
70 | String string2 = string.repeat(5); //JavaJavaJavaJavaJava
71 | System.out.println(string2);
72 | }
73 |
74 | /**
75 | * 新增lines方法,变成流，方便操作
76 | * @throws Exception
77 | */
78 | @Test
79 | public void testLines() throws Exception {
80 | FileInputStream fis = new FileInputStream("src/com/hepengju/java11/new03_string/_String.java");
81 | byte[] buffer = new byte[fis.available()];
82 | fis.read(buffer);
83 | fis.close();
84 | String string = new String(buffer);
85 | string.lines().forEach(System.out::println); //会输出整个文件内容
86 | }
87 |
88 |
89 |
90 | }
91 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new02_varforlambda/_VarForLambda.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new02_varforlambda;
2 |
3 | import java.util.Arrays;
4 |
5 | import org.junit.Test;
6 |
7 | /**
8 | * 对Lambda表达式的Var类型推断
9 | *
10 | *
11 | *
12 | * JEP 323: Local-Variable Syntax for Lambda Parameters
13 | * 局部变量类型推断就是左边的类型直接使用 var 定义
14 | * 而不用写具体的类型，编译器能根据右边的表达式自动推断类型
15 | *
16 | *
17 | *
18 | * @author WGR
19 | *
20 | */
21 | public class _VarForLambda {
22 |
23 | /**
24 | * 对Lambda表达式的Var类型推断
25 | */
26 | @Test
27 | public void testVarForLambda() {
28 | var numbers = new int[]{1, 2, 3, 4, 5, 6, 7};
29 |
30 | var subset = Arrays.stream(numbers).filter((var a) -> a > 5).toArray();
31 | for (int i = 0; i < subset.length; i++) {
32 | System.out.println(subset[i]); // 6 7
33 | }
34 | }
35 |
36 |
37 | /**
38 | * var对局部变量的类型推断
39 | */
40 | @Test
41 | public void testVar() {
42 |
43 | var javastack = "javastack";
44 | System.out.println(javastack); // javastack
45 | System.out.println(javastack.getClass()); // class java.lang.String
46 |
47 | // var javastack = "javastack"; 等价于 String javastack = "javastack";
48 |
49 |
50 |
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new03_httpClient/_HttpClient.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new03_httpClient;
2 |
3 | import java.net.URI;
4 | import java.net.http.HttpClient;
5 | import java.net.http.HttpRequest;
6 | import java.net.http.HttpResponse;
7 | import java.net.http.HttpResponse.BodyHandler;
8 | import java.net.http.HttpResponse.BodyHandlers;
9 | import java.util.concurrent.CompletableFuture;
10 |
11 | import org.junit.Test;
12 |
13 | /**
14 | *
15 | * JEP 321: HTTP Client (Standard)(重磅)
16 | * 新增HttpClient
17 | *
18 | *
19 | * 说明：
20 | * * Java 9开始引入的一个处理 HTTP请求的的孵化 HTTP Client API，该 API支持同步和异步。
21 | * * Java 11 中已经为正式可用状态。
22 | *
23 | * @See
24 | *
25 | *
26 | * @author WGR
27 | *
28 | */
29 | public class _HttpClient {
30 |
31 | /**
32 | * 异步方法（sendAsync）
33 | * 优点：不会造成堵塞
34 | * @throws Exception
35 | */
36 | @Test
37 | public void testName2() throws Exception {
38 |
39 | HttpClient client = HttpClient.newHttpClient();
40 | HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
41 | BodyHandler responseBodyHandler = BodyHandlers.ofString();
42 |
43 | CompletableFuture> sendAsync = client.sendAsync(request, responseBodyHandler);
44 | sendAsync.thenApply(t -> t.body()).thenAccept(System.out::println);
45 | //HttpResponse response = sendAsync.get();
46 | //String body = response.body();
47 | //System.out.println(body);
48 |
49 | }
50 |
51 | /**
52 | * 同步方法（send）
53 | * @throws Exception
54 | */
55 | @Test
56 | public void testSend() throws Exception {
57 |
58 | HttpClient client = HttpClient.newHttpClient();
59 | HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
60 |
61 | BodyHandler responseBodyHandler = BodyHandlers.ofString();
62 | HttpResponse response = client.send(request, responseBodyHandler);
63 | String body = response.body();
64 |
65 | System.out.println(body);//会输出整个html的内容
66 | }
67 |
68 | }
69 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new04_unicode10/_Unicode10.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new04_unicode10;
2 |
3 | import org.junit.Test;
4 |
5 | /**
6 | *
7 | * JEP 327: Unicode 10
8 | * Unicode 10.0 增强
9 | *
10 | *
11 | * @See
12 | * @See
13 | *
14 | *
15 | * @author WGR
16 | *
17 | */
18 | public class _Unicode10 {
19 |
20 | /**
21 | * 对Unicode10的测试
22 | */
23 | @Test
24 | public void testUnicode10() {
25 | String emoj = "\ud83d\ude02\ud83d\ude0d\ud83c\udf89\ud83d\udc4d";
26 | System.out.println(emoj); // 😂😍🎉👍
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new05_simplify/_Simplify.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new05_simplify;
2 |
3 | /**
4 | *
5 | * 更简化的编译运行程序
6 | * JEP 330: Launch Single-File Source-Code Programs
7 | *
8 | *
9 | *
10 | * JEP 330: 增强java启动器支持运行单个java源代码文件的程序。
11 | * 阐述：
12 | * * 执行源文件中的第一个类, 第一个类必须包含主方法。
13 | * * 并且不可以使用别源文件中的自定义类, 本文件中的自定义类是可以使用的。
14 | * @See
15 | *
16 | *
17 | *
18 | * @author WGR
19 | */
20 | public class _Simplify {
21 |
22 | public void testSimplify() {
23 |
24 | /* OLD
25 | * 编译 javac Javastack.java
26 | * 运行 java Javastack
27 | */
28 |
29 | /* NOW
30 | * 编译+运行 java Javastack.java
31 | */
32 |
33 |
34 |
35 | }
36 |
37 |
38 |
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new06_abandon/_Abandon.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new06_abandon;
2 |
3 |
4 | /**
5 | * 废弃和移除Java类
6 | *
7 | *
8 | *
9 | *
10 | * JEP 320: Remove the Java EE and CORBA Modules
11 | * 在java11中将java9标记废弃的Java EE及CORBA模块移除掉，具体如下：
12 | * （1） xml相关的，
13 | * java.xml.ws, java.xml.bind，java.xml.ws，
14 | * java.xml.ws.annotation，jdk.xml.bind，jdk.xml.ws被移除，
15 | * 只剩下java.xml，java.xml.crypto,jdk.xml.dom这几个模块；
16 | * （2） EE及CORBA相关的
17 | * java.corba，java.se.ee，java.activation，java.transaction被移除，
18 | * 但是java11新增一个java.transaction.xa模块.
19 | *
20 | * OTHER
21 | * JEP 336: Deprecate the Pack200 Tools and API
22 | * 移除项：
23 | * 1.移除了com.sun.awt.AWTUtilities
24 | * 2.移除了sun.misc.Unsafe.defineClass
25 | * 使用 java.lang.invoke.MethodHandles.Lookup.defineClass来替代
26 | * 3.移除了Thread.destroy()以及 Thread.stop(Throwable)方法
27 | * 4.移除了sun.nio.ch.disableSystemWideOverlappingFileLockCheck、sun.locale.formatasdefault属性
28 | * 5.移除了jdk.snmp模块
29 | * 6.移除了javafx，openjdk估计是从java10版本就移除了，oracle jdk10还尚未移除javafx，
30 | * 而java11版本则oracle的jdk版本也移除了javaf
31 | * 7.移除了Java Mission Control，从JDK中移除之后，需要自己单独下载
32 | * 8.移除了这些Root Certificates ：Baltimore Cybertrust Code Signing CA，SECOM ，AOL and Swisscom
33 | *
34 | * 废弃项：
35 | * 1.废弃了Nashorn JavaScript Engine
36 | * 2.废弃了-XX+AggressiveOpts选项
37 | * 3.-XX:+UnlockCommercialFeatures以及-XX:+LogCommercialFeatures选项也不再需要
38 | * 4.废弃了Pack200工具及其API
39 | *
40 | * @See
41 | * @See
42 | *
43 | *
44 | *
45 | * @author WGR
46 | *
47 | *
48 | */
49 | public class _Abandon {
50 |
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new07_epsilon/Garbage.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new07_epsilon;
2 |
3 | /**
4 | * 垃圾对象
5 | *
6 | * @author hepengju
7 | */
8 | @SuppressWarnings("unused")
9 | public class Garbage {
10 |
11 | private double d1 = 1;
12 | private double d2 = 2;
13 |
14 | // 这个方法是GC在清除本对象时, 会调用一次
15 | @Override @SuppressWarnings("all")
16 | public void finalize() {
17 | System.out.println(this + " collecting");
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new07_epsilon/_Epsilon.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new07_epsilon;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | import org.junit.Test;
7 |
8 |
9 |
10 | /**
11 | * JEP 318: Epsilon: A No-Op Garbage Collector
12 | * Epsilon垃圾收集器
13 | *
14 | *
15 | * 引入名为Epsilon的垃圾收集器，该收集器不做任何垃圾回收，可用于性能测试、短生命周期的任务等.
16 | *
17 | * 用法如下：
18 | * * -XX:+UseEpsilonGC (程序很快就因为堆空间不足而退出)
19 | * 执行结果:
20 | * * Terminating due to java.lang.OutOfMemoryError: Java heap space。
21 | * 主要用途:
22 | * * 性能测试(它可以帮助过滤掉GC引起的性能假象)
23 | * * 内存压力测试
24 | * * 非常短的JOB任务
25 | * * VM接口测试
26 | *
27 | * @author WGR
28 | *
29 | */
30 |
31 | public class _Epsilon {
32 |
33 | /**
34 | * 对Epsilon进行测试
35 | */
36 | @Test
37 | public void testEpsilon() {
38 | List list = new ArrayList<>();
39 | boolean flag = true;
40 | int count = 0;
41 | /*
42 | * 没有加-XX:+UseEpsilonGC时，会出现以前内容，最后出现java.lang.OutOfMemoryError.
43 | *
44 | * com.hepengju.java11.new10_epsilon.Garbage@6227d4e5 collecting
45 | * com.hepengju.java11.new10_epsilon.Garbage@50952207 collecting
46 | * com.hepengju.java11.new10_epsilon.Garbage@28375449 collecting
47 | * com.hepengju.java11.new10_epsilon.Garbage@7204167b collecting
48 | */
49 | while (flag) {
50 | list.add(new Garbage());
51 | if (count++ == 500) {
52 | list.clear();
53 | }
54 | }
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new08_jfr/_JFR.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new08_jfr;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | import com.hepengju.java11.new07_epsilon.Garbage;
7 |
8 | /**
9 | * JEP 328: Flight Recorder
10 | *
11 | *
12 | * 具体概述：
13 | * * Flight Recorder以前是商业版的特性，在java11当中开源出来
14 | * * 它可以导出事件到文件中，之后可以用Java Mission Control来分析
15 | * 用法如下：
16 | * * java -XX:StartFlightRecording
17 | * *
18 | * @see
19 | * 参考命令:
20 | * * jfr print test.jfr
21 | * * jfr print --events CPULoad,GarbageCollection test.jfr
22 | * * jfr print --json --events "GC,JVM,Java" test.jfr
23 | * * jfr summary test.jfr
24 | * * jfr metadata test.jfr
25 | *
26 | * 测试示例：
27 | * * jcmd 3628 JFR.start (3628为java的pid)
28 | * * jcmd 3628 JFR.dump filename=test.jfr name =1
29 | * * jcmd 3628 JFR.stop (会生成test.jfr的文件)
30 | * 附：
31 | * * 由于Java11没有提供jmc工具(java mission control)
32 | * * 只能用Jdk12查看这个test.jfr二进制文件，输入jfr(开启改功能)
33 | *
34 | *
35 | *
36 | * @author WGR
37 | *
38 | */
39 |
40 | public class _JFR {
41 |
42 | /**
43 | * 执行测试方法，测试记录文件
44 | */
45 | public void testJFR(){
46 |
47 | List list = new ArrayList<>();
48 | boolean flag = true;
49 | int count = 0;
50 | while (flag) {
51 | list.add(new Garbage());
52 | if (count++ == 20) {
53 | list.clear();
54 | }
55 | try {
56 | Thread.sleep(1);
57 | } catch (InterruptedException e) {
58 | e.printStackTrace();
59 | }
60 |
61 | }
62 | }
63 |
64 | }
65 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new09_zgc/_ZGC.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new09_zgc;
2 |
3 |
4 | /**
5 | * JEP 333: ZGC: A Scalable Low-Latency Garbage Collector(Experimental)(重磅)
6 | * ZGC垃圾收集器
7 | *
8 | *
9 | * 实现：
10 | * * 停顿时间不超过10ms
11 | * * 停顿时间不随heap大小或存活对象大小增大而增大
12 | * * 可以处理从几百兆到几T的内存大小
13 | * 概述：
14 | * * ZGC是个令人兴奋的新垃圾收集器，旨在为大堆提供非常低的暂停时间。
15 | * * 它通过使用着色指针和读屏障来实现这一点，这些是Hotspot新近开发的GC技术，并为未来增加了很多可能性。
16 | * 用法:
17 | * * -XX:+UseZGC
18 | * 测试：
19 | * * 由于ZGC不支持Windows系统，可以在Linux环境自测。
20 | *
21 | * @See
22 | * @See
23 | * @See
24 | *
25 | *
26 | *
27 | * @author WGR
28 | *
29 | */
30 | public class _ZGC {
31 |
32 | /*
33 | * Error occurred during initialization of VM
34 | * Option -XX:+UseZGC not supported
35 | */
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new10_lowoverhead/_LowOverhead.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new10_lowoverhead;
2 |
3 | import java.time.Duration;
4 | import java.util.concurrent.TimeUnit;
5 |
6 | import org.junit.Test;
7 |
8 | /**
9 | * JEP 331: Low-Overhead Heap Profiling
10 | * 对低消耗堆分析
11 | *
12 | * @See
13 | * @See
14 | *
15 | * @author WGR
16 | *
17 | */
18 | public class _LowOverhead {
19 |
20 | /**
21 | * 测试方法
22 | */
23 | @Test
24 | public void testLowOverhead() {
25 | TimeUnit tu = TimeUnit.DAYS;
26 | // 将 50 小时转换为天数
27 | System.out.println(tu.convert(Duration.ofHours(50))); // 2
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new11_keyagreement/_KeyAgreement.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new11_keyagreement;
2 |
3 | import java.math.BigInteger;
4 | import java.security.KeyFactory;
5 | import java.security.KeyPair;
6 | import java.security.KeyPairGenerator;
7 | import java.security.PublicKey;
8 | import java.security.spec.NamedParameterSpec;
9 | import java.security.spec.XECPublicKeySpec;
10 |
11 | import javax.crypto.KeyAgreement;
12 |
13 | /**
14 | * JEP 324: Key Agreement with Curve25519 and Curve448
15 | * Curve25519 和 Curve448 算法的密钥协议
16 | *
17 | *
18 | * 目的：
19 | * * 密码学要求使用 Curve25519 和Curve448 是因为它们的安全性和性能。
20 | * * JDK会增加两个新的接口XECPublicKey 和 XECPrivateKey。
21 | *
22 | * @See
23 | * @See
24 | *
25 | *
26 | * @author WGR
27 | *
28 | */
29 | public class _KeyAgreement {
30 |
31 | /**
32 | * 示例代码
33 | * @throws Exception
34 | */
35 | public void testKeyAgreement() throws Exception {
36 | KeyPairGenerator kpg = KeyPairGenerator.getInstance("XDH");
37 | NamedParameterSpec paramSpec = new NamedParameterSpec("X25519");
38 | kpg.initialize(paramSpec); // equivalent to kpg.initialize(255)
39 | // alternatively: kpg = KeyPairGenerator.getInstance("X25519")
40 | KeyPair kp = kpg.generateKeyPair();
41 |
42 | KeyFactory kf = KeyFactory.getInstance("XDH");
43 | BigInteger u = new BigInteger("9999999999999999999999999999999999999999999999999");
44 | XECPublicKeySpec pubSpec = new XECPublicKeySpec(paramSpec, u);
45 | PublicKey pubKey = kf.generatePublic(pubSpec);
46 |
47 | KeyAgreement ka = KeyAgreement.getInstance("XDH");
48 | ka.init(kp.getPrivate());
49 | ka.doPhase(pubKey, true);
50 | //byte[] secret = ka.generateSecret();
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/new12_other/_Other.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java11.new12_other;
2 |
3 | /**
4 | * JEP 181: Nest-Based Access Control（基于嵌套的访问控制）
5 | * JEP 309: Dynamic Class-File Constants（动态类文件常量）
6 | * JEP 315: Improve Aarch64 Intrinsics（改进 Aarch64 函数）
7 | * JEP 332: Transport Layer Security (TLS) 1.3（支持 TLS 1.3）
8 | *
9 | * @See
10 | * @See
11 | * @See
12 | * @See
13 | *
14 | * @author WGR
15 | *
16 | */
17 | public class _Other {
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/src/com/hepengju/java11/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java11的新特性
3 | *
4 | *
5 | * - String新增方法探索 _String.java
6 | *
- Lambda表达式的Var类型推断 _VarForLambda.java
7 | *
- HttpClient正式可用 _HttpClient.java
8 | *
- Unicode 10 _Unicode10.java
9 | *
- 更简化的编译运行 _Simplify.java
10 | *
- 废弃和移除Java类 _Abandon.java
11 | *
- Epsilon垃圾收集器 _Epsilon.java
12 | *
- Flight Recorder _JFR.java
13 | *
- 对低消耗堆分析 _LowOverhead.java
14 | *
- 算法的密钥协议 _KeyAgreement.java
15 | *
- 其他杂项改进
16 | *
17 | * - 基于嵌套的访问控制
18 | *
- 动态类文件常量
19 | *
- 改进 Aarch64 函数
20 | *
- 支持 TLS 1.3
21 | *
22 | *
23 | *
24 | * @see What's New in JDK 11
25 | *
26 | * @See java11 新特性
27 | *
28 | * WGR:网上视频或者资料大多包含9/10的新特性，11新特性只有部分，还望补充。
29 | *
30 | * @author hepengju
31 | *
32 | */
33 | package com.hepengju.java11;
--------------------------------------------------------------------------------
/src/com/hepengju/java12/new01_switch/_Switch.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java12.new01_switch;
2 |
3 | import org.junit.Assert;
4 | import org.junit.Test;
5 |
6 | /**
7 | * switch: 语句和表达式(预览)
8 | *
9 | *
10 | * 传统的Switch语句的问题:
11 | * - 匹配是自上而下的, 如果忘记写break, 后面的case语句不论匹配与否都会执行
12 | * - 所有的case语句共用一个块范围, 在不同的case语句定义的变量名不能重复
13 | * - 不能在一个case里写多个执行结果一致的条件
14 | * - 整个switch不能作为表达式返回值
15 | *
16 | * Java 12对switch声明语句进行扩展, 可将其作为增强版的 switch 语句或称为 "switch 表达式"来写出更加简化的代码
17 | * - 不仅可以作为语句（statement）,还可以作为表达式（expression）
18 | * - 两种写法都可以使用传统的 switch 语法, 或者使用简化的“case L ->”模式匹配语法作用于不同范围并控制执行流
19 | * - 为了保持兼容性, case 条件语句中依然可以使用字符 : ,但不能混用 -> 和 : ,否则会有编译错误
20 | *
21 | * 预览语言的说明
22 | * Switch 表达式也是作为预览语言功能的第一个语言改动被引入新版 Java 中来的, 预览语言功能的想法是在 2018 年
23 | * 初被引入 Java 中的, 本质上讲这是一种引入新特性的测试版的方法. 通过这种方式, 能够根据用户反馈进行升级、更改,
24 | * 在极端情况下, 如果没有被很好的接纳, 则可以完全删除该功能. 预览功能的关键在于它们没有被包含在Java SE规范中
25 | * 编译的时候需要追加参数: -parameters --enable-preview
26 | *
27 | *
28 | * @see JEP 325: Switch Expressions
29 | * @author hepengju
30 | */
31 | public class _Switch {
32 |
33 | /**
34 | * 日枚举
35 | */
36 | enum DayEnum {MON, TUE, WED, THU, FRI, SAT, SUN;}
37 | private DayEnum day = DayEnum.MON;
38 |
39 | /**
40 | * 旧版switch语句写法
41 | */
42 | @Test
43 | public void testSwitchOld() {
44 | System.out.print("OldSwitch: ");
45 | switch (day) {
46 | case MON:
47 | case TUE:
48 | case WED:
49 | System.out.println("123");
50 | break;
51 | case THU:
52 | case FRI:
53 | System.out.println("45");
54 | break;
55 | case SAT:
56 | System.out.println("party");
57 | break;
58 | case SUN:
59 | throw new IllegalArgumentException("sun is not allowed");
60 | }
61 | }
62 |
63 | /**
64 | * 新版switch语句的简化写法
65 | */
66 | @Test
67 | public void testSwitchNew() {
68 | System.out.print("NewSwitch: ");
69 | // 不存在则什么也不处理, 比如下面不存在SUN
70 | switch (day) {
71 | case MON, TUE, WED -> System.out.println("123");
72 | case THU, FRI -> System.out.println("45");
73 | case SAT -> System.out.println("party");
74 | }
75 | }
76 |
77 | /**
78 | * switch表达式(简单): 表达式必须覆盖所有值或者使用default, 否则编译报错
79 | */
80 | @Test
81 | public void testSwitchExpressionSimple() {
82 | String str = switch (day) {
83 | case MON, TUE, WED -> "123";
84 | case THU, FRI -> "45";
85 | case SAT -> "party";
86 | default -> "default";
87 | };
88 |
89 | Assert.assertEquals("123", str);
90 | }
91 |
92 | /**
93 | * switch表达式(语句块): 可以写一个复杂的语句块, 最后yield返回结果值(jdk12是break关键字)
94 | */
95 | @Test public void testSwitchExpressionWithYield() {
96 | String str = switch (day) {
97 | case MON, TUE, WED -> "123";
98 | case THU, FRI -> {
99 | String result = "4" + 5;
100 | yield result;
101 | }
102 | case SAT, SUN -> {
103 | String result = "party";
104 | yield result;
105 | }
106 | };
107 |
108 | Assert.assertEquals("123", str);
109 | }
110 |
111 | }
112 |
--------------------------------------------------------------------------------
/src/com/hepengju/java12/new02_JVMConstantsAPI/_JVMConstantsAPI.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java12.new02_JVMConstantsAPI;
2 |
3 | import org.junit.Test;
4 |
5 | import java.lang.constant.ClassDesc;
6 |
7 | /**
8 | * JVM 常量 API:
9 | *
10 | *
11 | * Java 12 中引入 JVM 常量 API，用来更容易地对关键类文件 (key class-file) 和运行时构件（run-time artifacts）的名义描述
12 | * (nominal description) 进行建模，特别是对那些从常量池加载的常量，这是一项非常技术性的变化，能够以更简单、标准的方式处理可加载常量。
13 | * 具体来说就是java.base模块新增了java.lang.constant包（而非 java.lang.invoke.constant ）。包中定义了一系列基
14 | * 于值的符号引用（JVMS 5.1）类型，它们能够描述每种可加载常量。
15 | *
16 | * - ConstantDesc: ClassDesc、MethodTypeDesc、MethodHandleDesc
17 | * - Constable
18 | *
19 | * String、Integer、Long、Float、Double均实现了这两个接口，而EnumDesc实现了ConstantDesc接口
20 | *
21 | *
22 | * @see java.lang.constant
23 | * @see jvms-5
24 | * @see JVM Constants API
25 | *
26 | * @author hepengju
27 | */
28 | public class _JVMConstantsAPI {
29 |
30 | @Test public void testConstantAPI(){
31 | // TODO 备注: 不是很理解, 从JEP334看好像是指class文件的解析和生成等情况下使用的
32 | ClassDesc jvmApi = ClassDesc.of("com.hepengju.java12.new02_JVMConstantsAPI", "_JVMConstantsAPI");
33 | System.out.println(jvmApi);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/com/hepengju/java12/new03_compactNumber/_CompactNumber.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java12.new03_compactNumber;
2 |
3 | import org.junit.Test;
4 |
5 | import java.text.NumberFormat;
6 | import java.util.Locale;
7 |
8 | /**
9 | * 压缩数字形式显示
10 | *
11 | * @author hepengju
12 | */
13 | public class _CompactNumber {
14 |
15 | private int num01 = 100;
16 | private int num02 = 10000;
17 | private int num03 = 100_0000;
18 | private int num04 = 1000_0000;
19 | private int num05 = 10_0000_0000;
20 |
21 | @Test
22 | public void testCompactNumber(){
23 | NumberFormat nf01 = NumberFormat.getCompactNumberInstance();
24 | NumberFormat nf02 = NumberFormat.getCompactNumberInstance(Locale.CHINA, NumberFormat.Style.SHORT);
25 | NumberFormat nf03 = NumberFormat.getCompactNumberInstance(Locale.CHINA, NumberFormat.Style.LONG);
26 | NumberFormat nf04 = NumberFormat.getCompactNumberInstance(Locale.US , NumberFormat.Style.SHORT);
27 | NumberFormat nf05 = NumberFormat.getCompactNumberInstance(Locale.US , NumberFormat.Style.LONG);
28 | NumberFormat nf06 = NumberFormat.getCompactNumberInstance(Locale.JAPAN, NumberFormat.Style.SHORT);
29 | NumberFormat nf07 = NumberFormat.getCompactNumberInstance(Locale.JAPAN, NumberFormat.Style.LONG);
30 |
31 | // 默认(根系统区域有关)
32 | out(nf01, num01, num02, num03, num04, num05); // 100 1万 100万 1000万 10亿
33 |
34 | // 中文短, 中文长
35 | out(nf02, num01, num02, num03, num04, num05); // 100 1万 100万 1000万 10亿
36 | out(nf03, num01, num02, num03, num04, num05); // 100 1万 100万 1000万 10亿
37 |
38 | // 英文短, 英文长
39 | out(nf04, num01, num02, num03, num04, num05); // 100 10K 1M 10M 1B
40 | out(nf05, num01, num02, num03, num04, num05); // 100 10 thousand 1 million 10 million 1 billion
41 |
42 | // 日文短, 日文长
43 | out(nf06, num01, num02, num03, num04, num05); // 100 1万 100万 1000万 10億
44 | out(nf07, num01, num02, num03, num04, num05); // 100 1万 100万 1000万 10億
45 | }
46 |
47 | private void out(NumberFormat nf, int... nums){
48 | for (int num : nums) {
49 | System.out.print(nf.format(num) + "\t");
50 | }
51 | System.out.println();
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/com/hepengju/java12/new04_other/_Other.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java12.new04_other;
2 |
3 | import org.junit.Assert;
4 | import org.junit.Test;
5 |
6 | import java.io.FileWriter;
7 | import java.io.IOException;
8 | import java.nio.file.Files;
9 | import java.nio.file.Path;
10 | import java.util.stream.Collectors;
11 | import java.util.stream.Stream;
12 |
13 | import static java.util.stream.Collectors.*;
14 |
15 | /**
16 | * 其他改进
17 | *
18 | *
19 | * String新增方法
20 | * - transform: 进行映射转换
21 | * - indent: 调整String实例的缩进
22 | * Files新增mismatch方法
23 | * Collectors新增teeing方法: 聚合两个downstream的结果
24 | *
25 | */
26 | public class _Other {
27 |
28 | /**
29 | * 字符串转换(映射)
30 | */
31 | @Test
32 | public void testStringTransform(){
33 | var result = "hello".transform(s -> s + " world")
34 | .transform(String::toUpperCase);
35 | Assert.assertEquals("HELLO WORLD", result);
36 | }
37 |
38 | /**
39 | * 字符串缩进
40 | */
41 | @Test
42 | public void testStringIndent(){
43 | // 正数增加空格, 负责删除空白字符
44 | var result = " JAVA\n Python\nC==";
45 | System.out.println(result);
46 | System.out.println(result.indent(4));
47 | System.out.println(result.indent(-4));
48 | }
49 |
50 | /**
51 | * 比较文件内容第一个不同字节的位置
52 | */
53 | @Test
54 | public void testFilesMisMatch() throws IOException {
55 | FileWriter fw01 = new FileWriter("a.txt");
56 | FileWriter fw02 = new FileWriter("b.txt");
57 | try(fw01; fw02){
58 | fw01.write("a");
59 | fw01.write("b");
60 | fw01.write("c");
61 | fw02.write("a");
62 | fw02.write("1");
63 | fw02.write("c");
64 | }
65 |
66 | long mismatch = Files.mismatch(Path.of("a.txt"), Path.of("b.txt"));
67 | System.out.println(mismatch);
68 |
69 | Files.delete(Path.of("a.txt"));
70 | Files.delete(Path.of("b.txt"));
71 | }
72 |
73 | // /**
74 | // * teeing: 三通(管道配件), 形象的表示将两个流汇聚到一个
75 | // */
76 | // @Test
77 | // public void testCollectorsTeeing(){
78 | // var result = Stream.of(5, 10, 15, 20).collect(
79 | // teeing(counting(), summingInt(n -> n), NumResult::new)
80 | // );
81 | // System.out.println(result); // _Other.NumResult(count=4, sum=50)
82 | // }
83 |
84 | // @Data
85 | // @AllArgsConstructor
86 | // class NumResult{
87 | // private Long count; // 个数
88 | // private Integer sum; // 总数
89 | // }
90 | }
91 |
--------------------------------------------------------------------------------
/src/com/hepengju/java12/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java12的新特性
3 | *
4 | *
5 | * - switch表达式(预览)
6 | *
- JVM常量API
7 | *
- 压缩数据格式
8 | *
9 | *
- Shenandoah GC: 低暂停时间的GC
10 | *
- Microbenchmark Suite: 微基准测试套件
11 | *
- One AArch64 Port,Not Two: 只保留一个AArch64实现
12 | *
- Default CDS Archives: 默认类数据共享归档文件
13 | *
- Abortable Mixed Collections for G1: 可中止的G1 Mixed GC
14 | *
- Promptly Return Unused Committed Memory from G1: G1及时返回未使用的已分配内存
15 | *
16 | *
17 | * @see What's New in JDK 12
18 | * @see JDK 12 Features
19 | *
20 | * @author hepengju
21 | *
22 | */
23 | package com.hepengju.java12;
--------------------------------------------------------------------------------
/src/com/hepengju/java13/new01_switch/_Switch.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java13.new01_switch;
2 |
3 | /**
4 | * switch: 语句和表达式(预览)
5 | *
6 | *
7 | * 在JDK 12中引入了Switch表达式作为预览特性。JDK 13提出了第二个switch表达式预览。JEP 354修改了这个特性，
8 | * 它引入了yield语句，用于返回值。这意味着，switch表达式(返回值)应该使用yield, switch语句(不返回值)应该使用
9 | * break。
10 | * 在 JDK 12中有一个，但是要进行一个更改：要从 switch 表达式中生成一个值 break，要删除with value语句以支持a
11 | * yield 声明。目的是扩展，switch 以便它可以用作语句或表达式，因此两个表单既可以使用 case ... : 带有连贯符号的
12 | * 传统标签，也可以使用新 case … -> 标签，而不需要通过，还有一个新的语句用于从 switch 表达式中产生值。这些
13 | * 更改将简化编码并为模式匹配做好准备。
14 | *
15 | * 和return的区别在于：return会直接跳出当前循环或者方法，而yield只会跳出当前switch块。
16 | *
17 | * 参考: java12新特性里面的_Switch, java13仅仅对于switch表达式的返回值由 "break 值" --> "yield 值"
18 | *
19 | *
20 | * @author hepengju
21 | */
22 | public class _Switch { }
23 |
--------------------------------------------------------------------------------
/src/com/hepengju/java13/new03_reImplSocket/_ReImplSocket.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java13.new03_reImplSocket;
2 |
3 | /**
4 | * 重新实现旧版套接字API
5 | *
6 | *
7 | * 现有问题
8 | * 重新实现了古老的 Socket 接口。现在已有的 java.net.Socket 和 java.net.ServerSocket 以及它们的实现类，都可以回溯到 JDK 1.0 时代了。
9 | * - 它们的实现是混合了 Java 和 C 的代码的，维护和调试都很痛苦。
10 | * - 实现类还使用了线程栈作为 I/O 的缓冲，导致在某些情况下还需要增加线程栈的大小。
11 | * - 支持异步关闭，此操作是通过使用一个本地的数据结构来实现的，这种方式这些年也带来了潜在的不稳定性和
12 | * - 跨平台移植问题。该实现还存在几个并发问题，需要彻底解决。
13 | * 在未来的网络世界，要快速响应，不能阻塞本地方法线程，当前的实现不适合使用了。
14 | *
15 | * 新的实现类
16 | * 全新实现的 NioSocketImpl 来替换JDK1.0的PlainSocketImpl。
17 | * - 它便于维护和调试，与 NewI/O (NIO) 使用相同的 JDK 内部结构，因此不需要使用系统本地代码。
18 | * - 它与现有的缓冲区缓存机制集成在一起，这样就不需要为 I/O 使用线程栈。
19 | * - 它使用 java.util.concurrent 锁，而不是 synchronized 同步方法，增强了并发能力。
20 | * - 新的实现是Java 13中的默认实现，但是旧的实现还没有删除，可以通过设置系统属性jdk.net.usePlainSocketImpl来切换到旧版本。
21 | *
22 | * @see java.net.SocketImpl
23 | *
24 | *
25 | * @author hepengju
26 | */
27 | public class _ReImplSocket { }
28 |
--------------------------------------------------------------------------------
/src/com/hepengju/java13/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java13的新特性
3 | *
4 | *
5 | * - switch表达式(预览)
6 | *
- 文本块(预览)
7 | *
- 重新实现旧版套接字API
8 | *
9 | *
- 动态CDS档案（动态类数据共享归档）
10 | *
- ZGC:取消使用未使用的内存
11 | *
12 | *
13 | * @see JDK 13 Features
14 | *
15 | * @author hepengju
16 | *
17 | */
18 | package com.hepengju.java13;
--------------------------------------------------------------------------------
/src/com/hepengju/java14/new01_instanceof/_Instanceof.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java14.new01_instanceof;
2 |
3 | import org.junit.Test;
4 |
5 | /**
6 | * instanceof模式匹配(预览)
7 | *
8 | *
9 | * 说明: 通过对 instanceof 运算符进行模式匹配来增强Java编程语言
10 | * 优点: 更简洁, 更安全
11 | *
12 | */
13 | public class _Instanceof {
14 |
15 | private Object obj = "Java";
16 |
17 | /**
18 | * 旧版写法
19 | */
20 | @Test
21 | public void testOld() {
22 | if (obj instanceof String) {
23 | String str = (String) obj;
24 | System.out.println("旧版写法结果: " + str.toUpperCase());
25 | } else {
26 | System.out.println("not string: " + obj.hashCode());
27 | }
28 | }
29 |
30 | @Test
31 | public void testNew() {
32 | if (obj instanceof String str) {
33 | System.out.println("新版写法结果: " + str.toUpperCase());
34 | } else {
35 | System.out.println("not string: " + obj.hashCode());
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/com/hepengju/java14/new02_jpackage/_JPackage.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java14.new02_jpackage;
2 |
3 | /**
4 | * jpackage 打包工具
5 | *
6 | * @see 打包工具
7 | */
8 | public class _JPackage {
9 | }
10 |
--------------------------------------------------------------------------------
/src/com/hepengju/java14/new03_JFREventStreaming/_JFREventStreaming.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java14.new03_JFREventStreaming;
2 |
3 | public class _JFREventStreaming {
4 | }
5 |
--------------------------------------------------------------------------------
/src/com/hepengju/java14/new04_helpfulNPE/_HelpfulNPE.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java14.new04_helpfulNPE;
2 |
3 | import lombok.AllArgsConstructor;
4 | import lombok.Data;
5 | import org.junit.Test;
6 |
7 | /**
8 | * 改善的NPE异常提示
9 | */
10 | public class _HelpfulNPE {
11 |
12 | @Test
13 | public void testNPE(){
14 | Pet pet = new Pet("silly dog");
15 | User user = new User("hepengju", pet);
16 |
17 | // java.lang.NullPointerException
18 | System.out.println(user.getPet().getName());
19 |
20 | // java.lang.NullPointerException: Cannot invoke "com.hepengju.java14.new04_helpfulNPE.Pet.getName()"
21 | // because the return value of "com.hepengju.java14.new04_helpfulNPE.User.getPet()" is null
22 | //user.setPet(null);
23 | //System.out.println(user.getPet().getName());
24 |
25 | // java.lang.NullPointerException: Cannot invoke "com.hepengju.java14.new04_helpfulNPE.User.getPet()"
26 | // because "user" is null
27 | user = null;
28 | System.out.println(user.getPet().getName());
29 | }
30 | }
31 |
32 | @Data @AllArgsConstructor
33 | class User {
34 | private String name;
35 | private Pet pet;
36 | }
37 |
38 | @Data @AllArgsConstructor
39 | class Pet {
40 | String name;
41 | }
42 |
--------------------------------------------------------------------------------
/src/com/hepengju/java14/new05_record/_Record.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java14.new05_record;
2 |
3 | import org.junit.Test;
4 |
5 | /**
6 | * 记录类
7 | */
8 | public class _Record {
9 |
10 | @Test
11 | public void testRecord() {
12 | Point p1 = new Point(10, 10);
13 | Point p2 = new Point(10, 10);
14 |
15 | System.out.println(p1); // Point[x=10, y=10]
16 | System.out.println(p1 == p2); // false
17 | System.out.println(p1.equals(p2)); // true
18 | }
19 | }
20 |
21 |
22 | record Point(int x, int y) {}
23 |
24 |
--------------------------------------------------------------------------------
/src/com/hepengju/java14/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java13的新特性
3 | *
4 | *
5 | * 1. instanceof模式匹配(预览)
6 | * 2. 打包工具(孵化器)
7 | * 3. JFR事件流
8 | * 4. 优化的NPE提示
9 | * 5. 记录类型 record(预览)
10 | *
11 | *
12 | * @see JDK 14 Features
13 | * @see JDK 14如期发布，16个新特性快速预览
14 | * @see JDK 14: Java 14 中的新特性
15 | * @see Java14来了
16 | *
17 | * @author hepengju
18 | */
19 | package com.hepengju.java14;
--------------------------------------------------------------------------------
/src/com/hepengju/java15/new01_sealedclass/_SealedClass.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java15.new01_sealedclass;
2 |
3 |
4 | /**
5 | * 密封的类和接口(预览)
6 | *
7 | *
8 | * 概述: 通过密封的类和接口来增强 Java 编程语言，这是新的预览特性。
9 | *
10 | * 目的: 用于限制超类的使用，密封的类和接口限制其它可能继承或实现它们的其它类或接口。
11 | *
12 | * 这个特性的目标包括——允许类或接口的开发者来控制哪些代码负责实现，提供了比限制使用超类的访问修饰符声明方式更多选择,
13 | * 并通过支持对模式的详尽分析而支持模式匹配的未来发展。
14 | * 在Java中，类层次结构通过继承实现代码的重用，父类的方法可以被许多子类继承。
15 | * 但是，类层次结构的目的并不总是重用代码。有时，其目的是对域中存在的各种可能性进行建模，
16 | * 例如图形库支持的形状类型或金融应用程序支持的贷款类型。当以这种方式使用类层次结构时，我们可能需要限制子类集从而来简化建模。
17 | *
18 | * 使用:
19 | * 使用修饰符sealed，您可以将一个类声明为密封类。密封的类使用reserved关键字permits列出可以直接扩展它的类。
20 | * 1. 密封类必须有子类
21 | * 2. 子类应为 sealed、non-sealed 或 final 修饰符
22 | *
23 | *
24 | * @see JEP 360: Sealed Classes (Preview)
25 | */
26 | public class _SealedClass {}
27 |
28 | // 示例1: 图形, 只允许 圆形,矩形,正方形
29 | // 注意: 也可以不使用 permits 关键字，然后将类定义与类放在相同的文件中, 即如下:
30 | //sealed class Shape /*permits Circle, Rectangle, Square, ExtShape*/ {};
31 | sealed class Shape permits Circle, Rectangle, Square, ExtShape {};
32 | final class Circle extends Shape {}
33 | final class Rectangle extends Shape {}
34 | final class Square extends Shape {}
35 |
36 | // 以下仅仅为展示语法, 无实际意义
37 | sealed class ExtShape extends Shape permits ExtShape01, ExtShape02, ExtShapeXX {}
38 | final class ExtShape01 extends ExtShape {}
39 | final class ExtShape02 extends ExtShape {}
40 | non-sealed class ExtShapeXX extends ExtShape {}
41 |
42 | // 示例2: 和record关键字一起使用
43 | sealed interface Expr permits ConstantExpr, PlusExpr, TimesExpr, NegExpr {}
44 | record ConstantExpr(int i) implements Expr {}
45 | record PlusExpr(Expr a, Expr b) implements Expr {}
46 | record TimesExpr(Expr a, Expr b) implements Expr {}
47 | record NegExpr(Expr e) implements Expr {}
--------------------------------------------------------------------------------
/src/com/hepengju/java15/new02_hiddenclass/_HiddenClass.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java15.new02_hiddenclass;
2 |
3 | /**
4 | * 隐藏类: TODO 没太看懂, 也就不知道如何编写示例
5 | *
6 | *
7 | * 该提案通过启用标准 API 来定义无法发现且具有有限生命周期的隐藏类，从而提高 JVM 上所有语言的效率。
8 | * JDK内部和外部的框架将能够动态生成类，而这些类可以定义隐藏类。通常来说基于JVM的很多语言都有动态生成类的机制，
9 | * 这样可以提高语言的灵活性和效率。
10 | * - 隐藏类天生为框架设计的，在运行时生成内部的class。
11 | * - 隐藏类只能通过反射访问，不能直接被其他类的字节码访问。
12 | * - 隐藏类可以独立于其他类加载、卸载，这可以减少框架的内存占用。
13 | *
14 | * Hidden Classes是什么呢？
15 | * Hidden Classes就是不能直接被其他class的二进制代码使用的class。Hidden Classes主要被一些框架用来生成运行时类，
16 | * 但是这些类不是被用来直接使用的，而是通过反射机制来调用。比如在JDK8中引入的lambda表达式，JVM并不会在编译的时候将lambda
17 | * 表达式转换成为专门的类，而是在运行时将相应的字节码动态生成相应的类对象。另外使用动态代理也可以为某些类生成新的动态类。
18 | *
19 | * 那么我们希望这些动态生成的类需要具有什么特性呢？
20 | * - 不可发现性。因为我们是为某些静态的类动态生成的动态类，所以我们希望把这个动态生成的类看做是静态类的一部分。所以我们不希望除了该静态类之外的其他机制发现。
21 | * - 访问控制。我们希望在访问控制静态类的同时，也能控制到动态生成的类。
22 | * - 生命周期。动态生成类的生命周期一般都比较短，我们并不需要将其保存和静态类的生命周期一致。
23 | *
24 | * API的支持
25 | * 所以我们需要一些API来定义无法发现的且具有有限生命周期的隐藏类。这将提高所有基于JVM的语言实现的效率。
26 | * 比如：
27 | * java.lang.reflect.Proxy可以定义隐藏类作为实现代理接口的代理类。
28 | * java.lang.invoke.StringConcatFactory可以生成隐藏类来保存常量连接方法；
29 | * java.lang.invoke.LambdaMetaFactory可以生成隐藏的nestmate类，以容纳访问封闭变量的lambda主体；
30 | *
31 | * 普通类是通过调用ClassLoader::defineClass创建的，而隐藏类是通过调用Lookup::defineHiddenClass创建的。
32 | * 这使JVM从提供的字节中派生一个隐藏类，链接该隐藏类，并返回提供对隐藏类的反射访问的查找对象。调用程序可以通过返回的
33 | * 查找对象来获取隐藏类的Class对象。
34 | *
35 | *
36 | * @see JEP 371: Hidden Classes
37 | */
38 | public class _HiddenClass {
39 | }
--------------------------------------------------------------------------------
/src/com/hepengju/java15/new03_textblock/_TextBlock.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java15.new03_textblock;
2 |
3 | import org.junit.Test;
4 |
5 | /**
6 | * 文本块(正式发布)
7 | *
8 | * @see com.hepengju.java13.new02_textblock._TextBlock
9 | */
10 | public class _TextBlock {
11 |
12 | /**
13 | * 新增默认的\, 输出为单行结果
14 | */
15 | @Test public void testToOneLine() {
16 | String sql =
17 | """
18 | SELECT employee_id,last_name,salary,department_id \
19 | FROM employees \
20 | WHERE department_id in (40,50,60) \
21 | ORDER BY department_id ASC\
22 | """;
23 | System.out.println("###");
24 | // SELECT employee_id,last_name,salary,department_id FROM employees WHERE department_id in (40,50,60) ORDER BY department_id ASC
25 | System.out.println(sql);
26 | System.out.println("###");
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/com/hepengju/java15/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Java15的新特性
3 | *
4 | *
5 | * 1. 密封类(预览)
6 | * 2. 隐藏类
7 | * 3. 文本块正式
8 | * 4. ZGC正式
9 | * 5. 记录类型 record(预览)
10 | *
11 | *
12 | * @see JDK 15 Features
13 | * @see 尚硅谷_Java15新特性教程
14 | *
15 | * @author hepengju
16 | */
17 | package com.hepengju.java15;
--------------------------------------------------------------------------------
/src/com/hepengju/java16/new01_toList/_StreamToList.java:
--------------------------------------------------------------------------------
1 | package com.hepengju.java16.new01_toList;
2 |
3 | import org.junit.Test;
4 |
5 | import java.util.List;
6 | import java.util.function.Consumer;
7 | import java.util.stream.Collectors;
8 | import java.util.stream.Stream;
9 |
10 | /**
11 | * Stream流新增 toList 方法
12 | *
13 | * @see com.hepengju.java08.new04_streamAPI._StreamAPI
14 | */
15 | public class _StreamToList {
16 |
17 | @Test
18 | public void testToList() {
19 | var srcList = List.of("a", "b", "c"); // Java9新增的of方法
20 | var list01 = srcList.stream().collect(Collectors.toList()); // Java8的搜集方法
21 | var list02 = srcList.stream().toList(); // Java16 简化的搜集方法, 注意: 结果是不可变的List
22 |
23 | System.out.println(list01);
24 | System.out.println(list02);
25 |
26 | list01.add("d"); // OK
27 | //list02.add("d"); // java.lang.UnsupportedOperationException
28 | }
29 |
30 | @Test
31 | public void testMapMulti01() {
32 | List numbers = List.of(1, 2.0, 3.3, 9999999999L, 0);
33 | List integers = numbers.stream().mapMulti((number, consumer) -> {
34 | if (number instanceof Integer i) consumer.accept(i);
35 | }).collect(Collectors.toList());
36 | System.out.println(integers); // [1, 0]
37 | }
38 |
39 | @Test
40 | public void testMapMulti02(){
41 | var nestedList = List.of(1, List.of(2, List.of(3, 4)), 5);
42 | List