JDK 各版本特性

class Person {
   private Hobby hobby;
}


class Hobby {
   private String scope;
}

Person  person = buildPerson();
if (person != null) {
   Hobby hobby = person.getHobby();
   if (hobby != null) {
      String scope = hobby.getScope();
      System.out.println(scope);
   }
}

Optional.ofNullable(person)
	.map(p -> p.getHobby())
	.map(h -> h.getScope())
	.ifPresent(scope ->System.out.println(scope));

public interface InterfacePerson {
	static void staticInterfacePerson() {
		System.out.println("InterfacePerson 的静态 staticInterfacePerson");
	}
			 
	static void staticInterfacePerson2() {
		System.out.println("InterfacePerson 的静态 staticInterfacePerson2");
			 
	}
			 
	default void defaultInterfacePerson() {
		System.out.println("InterfacePerson 的默认 defaultInterfacePerson");
			 
	}
			 
	default void defaultInterfacePerson2() {
		System.out.println("InterfacePerson 的默认 defaultInterfacePerson2");
	}
}
			
public interface InterfacePerson2 {
	static void staticInterfacePerson() {
		System.out.println("InterfacePerson2 的静态 staticInterfacePerson");
	}
			 
	default void defaultInterfacePerson() {
		System.out.println("InterfacePerson2 的默认 defaultInterfacePerson");
	}
}

@FunctionalInterface
public interface TestFunction<T, U,E,F,G,GH,HV, R> {
	R apply(T t, U u, E e, F f, G g, GH gh, HV hv);
}

module limit.module {
	//exports 公开指定包的所有公共成员
	exports com.my.package.name;
}

module limit.module {
	//exports…to 限制访问的成员范围
	export com.limit.package.name to com.target.limit.package;
}

public interface PrivateInterface {
	private void privateM(){
	
	}
}

try (FileInputStream inputStream = new FileInputStream("a.txt");) {
	
} catch (IOException e) {
	throw new RuntimeException(e);
}

final FileInputStream inputStream = new FileInputStream("a.txt");
					
try (inputStream) {
			 
} catch (IOException e) {
	throw new RuntimeException(e);
}

var i = 0;
					
var url = new URL("https://mp.weixin.qq.com/");
			 
var list = new ArrayList<>();
			 
var map = new HashMap<String, String>();
			 
for (var n : list){
	System.out.print(n+ " ");
}

static <E> List<E> copyOf(Collection<? extends E> coll) {
	return ImmutableCollections.listCopy(coll);
}

var list = new ArrayList<>();
			 
list.stream().collect(Collectors.toUnmodifiableList());
			 
list.stream().collect(Collectors.toUnmodifiableSet());

Optional.ofNullable(cache.getIfPresent(key))
	.orElseThrow(() -> new PersonalException( "personal Exception for key: " + key));

var request = HttpRequest.newBuilder()
	.uri(URI.create("https://javastack.cn"))
	.GET()
	.build();var client = HttpClient.newHttpClient();
		 
// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());System.out.println(response.body());
			
// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
	.thenApply(HttpResponse::body)
	.thenAccept(System.out::println);

//判断字符串是否为空
System.out.println(" ".isBlank());
			
// 去除字符串首尾空格
System.out.println("结果:"+" 去除字符串首尾空格 ".strip()+"结束");
			
// 去除字符串首部空格
System.out.println("结果:"+"去除字符串首部空格 ".stripLeading()+"结束");
			
// 去除字符串尾部空格
System.out.println("结果:"+" 去除字符串尾部空格 ".stripTrailing()+"结束");
			
// 重复字符串多少次
System.out.println(" 重复字符串多少次 ".repeat(2));
			
// 返回由行终止符分隔次数。
System.out.println("A\nB\nC".lines().count());
			
// 返回由行终止符分隔的字符串集合。
System.out.println("A\nB\nC".lines().collect(Collectors.toList()));

var obj= Optional.empty();
			 
//判断指定的 Optional 对象是否为空
System.out.println(obj.isEmpty());

// 下面两者是等价的
Consumer<String> consumer = (var c) -> System.out.println(c);
 
Consumer<String> consumer = (String c) -> System.out.println(c);

NumberFormat fmtShort = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.SHORT);
String resultShort = fmtShort.format(10000000);
System.out.println(resultShort);
	 
NumberFormat fmt2Short = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
String result2Short = fmt2Short.format(10000000);
System.out.println(result2Short);
	 
NumberFormat fmtLong = NumberFormat.getCompactNumberInstance(Locale.CHINESE, NumberFormat.Style.LONG);
String resultLong = fmtLong.format(10000000);
System.out.println(resultLong);
	 
NumberFormat fmt2Long = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.LONG);
String result2Long = fmt2Long.format(10000000);
System.out.println(result2Long);

public String indent(int n) {
	if (isEmpty()) {
		return "";
	}
					
	Stream<String> stream = lines();
	if (n > 0) {
		final String spaces = " ".repeat(n);
		stream = stream.map(s -> spaces + s);
	} else if (n == Integer.MIN_VALUE) {
		stream = stream.map(s -> s.stripLeading());
	} else if (n < 0) {
		stream = stream.map(s -> s.substring(Math.min(-n, s.indexOfNonWhitespace())));
	}
					
	return stream.collect(Collectors.joining("\n", "", "\n"));
}

public <R> R transform(Function<? super String, ? extends R> f) {
	return f.apply(this);
}

//indent() 方法可以实现字符串缩进。
String text = "缩进";
			
// 缩进 4 格
text = text.indent(4);
System.out.println(text);
			
//transform() 增加的直接使用的方法函数式编程方法。
String result = "源数据".transform(input -> input + " 增加");
System.out.println(result);

public static long mismatch(Path path, Path path2) throws IOException

public final class NioSocketImpl extends SocketImpl implements PlatformSocketImpl {
			
}

$ java -XX:ArchiveClassesAtExit=my_app_cds.jsa -cp my_app.jar

$ java -XX:SharedArchiveFile=my_app_cds.jsa -cp my_app.jar

a.b.c.i = 99; // 假设这段代码会发生空指针

Java 14 之前：
	Exception in thread "main" java.lang.NullPointerException
		at NullPointerExample.main(NullPointerExample.java:5)

Java 14 之后：
	// 增加参数后提示的异常中很明确的告知了哪里为空导致Exception in thread "main" java.lang.NullPointerException:
	Cannot read field 'c' because 'a.b' is null.
		at Prog.main(Prog.java:5)

// 增加参数后提示的异常中很明确的告知了哪里为空导致Exception in thread "main" java.lang.NullPointerException:
	Cannot read field 'c' because 'a.b' is null.
		at Prog.main(Prog.java:5)

$ java -XX:+UseZGC className

String o = "";
// 原来
if (o instanceof String) {
	String s = (String) o;
}
			
Object c = null;
c = "";
// 新的
if (c instanceof String b) {
	b = "b";
	System.out.println("c=" + c);
	System.out.println("b=" + b);
}

public class Outer {
	class Inner {
		static int age;
	}
}

RandomGeneratorFactory<RandomGenerator> l128X256MixRandom = RandomGeneratorFactory.of("L128X256MixRandom");
			
// 使用时间戳作为随机数种子
RandomGenerator randomGenerator = l128X256MixRandom.create(System.currentTimeMillis());
			
// 生成随机数
randomGenerator.nextInt(10));

$ jwebserver
Binding to loopback by default. For all interfaces use "-b 0.0.0.0" or "-b ::".
Serving /cwd and subdirectories on 127.0.0.1 port 8000
URL: http://127.0.0.1:8000/

<pre>{@code
	lines of source code
}</pre>

/**
 * The following code shows how to use {@code Optional.isPresent}:
 * {@snippet :
 * if (v.isPresent()) {
 *     System.out.println("v: " + v.get());
 * }
 * }
*/

try (var scope = new StructuredTaskScope<Object>()) {
	// 使用fork方法派生线程来执行子任务
	Future<Integer> future1 = scope.fork(task1);
	Future<String> future2 = scope.fork(task2);
	// 等待线程完成
	scope.join();
	// 结果的处理可能包括处理或重新抛出异常
	... process results/exceptions ...
} // close

final static ScopedValue<...> V = new ScopedValue<>();
		 
// In some method
ScopedValue.where(V, <value>)
	.run(() -> { ... V.get() ... call methods ... });
		 
// In a method called directly or indirectly from the lambda expression
... V.get() ...

List<Future<String>> futures = executor.invokeAll(tasks);

String result = executor.invokeAny(tasks);

public static void main(String[] args) throws IOException {
	try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
		Future<String> res1 = scope.fork(() -> runTask(1));
		Future<String> res2 = scope.fork(() -> runTask(2));
		Future<String> res3 = scope.fork(() -> runTask(3));
		scope.join();
		System.out.println("scope:" + scope.result());
	} catch (ExecutionException | InterruptedException e) {
		throw new RuntimeException(e);
	}
}

public static String runTask(int i) throws InterruptedException {
	Thread.sleep(1000);
	long l = new Random().nextLong();
	String s = String.valueOf(l);
	System.out.println(i + "task：" + s);
	return s;
}

public static void main(String[] args) throws IOException {
	try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
		Future<String> res1 = scope.fork(() -> runTaskWithException(1));
		Future<String> res2 = scope.fork(() -> runTaskWithException(2));
		Future<String> res3 = scope.fork(() -> runTaskWithException(3));
		scope.join();
		scope.throwIfFailed(Exception::new);

		String s = res1.resultNow();
		System.out.println(s);
		String result = Stream.of(res1, res2,res3)
		.map(Future::resultNow)
		.collect(Collectors.joining());
		System.out.println("result:" + result);
	} catch (Exception e) {
		e.printStackTrace();
	}
}

public static String runTaskWithException(int i) throws InterruptedException {
	Thread.sleep(1000);
	long l = new Random().nextLong(3);
	if (l == 0) {
		throw new InterruptedException();
	}
	String s = String.valueOf(l);
	System.out.println(i + "task：" + s);
	return s;
}

# 启用分代 ZGC (defaults to non-generational)
$ java -XX:+UseZGC

# 启用非分代 Generational ZGC
$ java -XX:+UseZGC -XX:+ZGenerational

# 如果旧版 可能需要开启实验室功能
-XX:+UnlockExperimentalVMOptions
-XX:+UseZGC

-server
-Xms2048m
-Xmx2048m
-XX:ReservedCodeCacheSize=512m
#-XX:+UseG1GC
# 如果旧版 可能需要开启实验室功能
#-XX:+UnlockExperimentalVMOptions
-XX:+UseZGC
-XX:SoftRefLRUPolicyMSPerMB=50
-XX:CICompilerCount=2
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-XX:+IgnoreUnrecognizedVMOptions
-XX:CompileCommand=exclude,com/intellij/openapi/vfs/impl/FilePartNodeRoot,trieDescend
-ea
-Dsun.io.useCanonCaches=false
-Dsun.java2d.metal=true
# update
-Dsun.java2d.opengl=true
-Djbr.catch.SIGABRT=true
-Djdk.http.auth.tunneling.disabledSchemes=""
-Djdk.attach.allowAttachSelf=true
-Djdk.module.illegalAccess.silent=true
-Dkotlinx.coroutines.debug=off

编辑运行配置，添加 vm 启动参数：

-XX:+UseZGC

public record Person(String name, int age) {}

Person person = new Person("Alice", 25);
System.out.println(person.name());
System.out.println(person.age());

Map<String, Object> data = new HashMap<>();
data.put("key1", "aaa");
data.put("key2", 111);

if (data.get("key1") instanceof String s) {
	log.info(s);
}

if (data.get("key") instanceof String s) {
	log.info(s);
} else if (data.get("key") instanceof Double s) {
	log.info(s);
} else if (data.get("key") instanceof Integer s) {
	log.info(s);
}

现在可以这样：

switch (data.get("key1")) {
	case String s -> log.info(s);
	case Double d -> log.info(d.toString());
	case Integer i -> log.info(i.toString());
	default -> log.info("");
}

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
	IntStream.range(0, 10_000).forEach(i -> {
		executor.submit(() -> {
		Thread.sleep(Duration.ofSeconds(1));
		return i;
	});
});}  // executor.close() is called implicitly, and waits

一般来说，虚拟线程是一种新的线程类型，它可以提高应用程序的性能和资源利用率，同时还可以使用传统的线程相关api。虚拟线程与协程有许多相似之处，但也有一些不同之处。

Virtual Threads确实可以使多线程编程更容易、更高效。与传统的操作系统线程相比，创建和销毁虚拟线程的开销更小，线程上下文切换的开销也更小，因此可以大大降低多线程编程中的资源消耗和性能瓶颈。

使用Virtual Threads，开发人员可以像编写传统线程代码一样编写代码，而不必担心线程的数量和调度，因为JVM将自动管理虚拟线程的数量和调度。此外，虚拟线程还支持传统的线程相关api，如ThreadLocal、Lock和Semaphore，这使得开发人员更容易将传统线程代码迁移到虚拟线程中。

虚拟线程的引入使多线程编程更高效、更简单、更安全，允许开发人员更多地关注业务逻辑，而不必过多关注底层线程管理。

public class SimpleThread implements Runnable{
	@Override
	public void run() {
		System.out.println("name：" + Thread.currentThread().getName());
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
}

Thread thread = new Thread(new SimpleThread());
thread.start();

Thread.ofPlatform().name("thread-test").start(new SimpleThread());

Thread thread = Thread.startVirtualThread(new SimpleThread());

Thread.ofVirtual()
	.name("thread-test")
	.start(new SimpleThread());
// Or
Thread thread = Thread.ofVirtual()
	.name("thread-test")
	.uncaughtExceptionHandler((t, e) -> {
		System.out.println(t.getName() + e.getMessage());
}).unstarted(new SimpleThread());
thread.start();

ThreadFactory factory = Thread.ofVirtual().factory();
Thread thread = factory.newThread(new SimpleThread());
thread.setName("thread-test");
thread.start();

ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();
Future<?> submit = executorService.submit(new SimpleThread());
Object o = submit.get();

List<String> list = new SequencedArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

for (String fruit : list.reversed()) {
	System.out.println(fruit);
}

String name = "Joan";

String info = STR."My name is \{name}";

assert info.equals("My name is Joan"); // true