3-11 JDK11 其他新特性

3-10 JDK11 中新增加的常用 API

import org.jetbrains.annotations.NotNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class LocalVarExample {

    /**
     * java8特性：lambda表达式语法
     */
    public static void lambdaInJava8() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("before java8");
            }
        }).start();

        new Thread(()-> System.out.println("in java8")).start();
        List<String> list = Arrays.asList("java8","jdk8","1.8");
        list.forEach(w->{
            System.out.println("lambda in java8->"+w);
        });
    }

    /**
     *Java10 新特性：局部变量类型推断
     */
    private static void varInJava10(){
        int var =10;
        var i =10;
        var str = "java10";
        var list = new ArrayList<String>();
        var map = Map.of(1,"a",2,"b");
        for(var entry : map.entrySet()){
            System.out.println(entry);
        }
    }

    /**
     *Java11 新特性：允许var在声明隐式类型的lambda表达式的形式参数时使用
     */
    private static void lambdaWithVarInJava11 (){
       List<Integer> nums = Arrays.asList(9,11,23,3,7,2,8);
//       nums.sort((s1,s2)->{
//           if(s1.equals(s2)){
//               return 0;
//           }else{
//               return s1 > s2 ? 1:-1;
//           }
//       });
       nums.sort((@NotNull var s1, @NotNull var s2)->{
           if (s1.equals(s2)) {
               return 0;
           } else {
               return s1 > s2 ? 1 : -1;
           }
       });
       nums.sort((s1,s2)-> s1 > s2 ? 1:-1);
       System.out.println(nums);
    }

    /**
     * Lambda参数的本地变量语法
     */
    public static void main(String[] args) {
//        lambdaInJava8();
//        varInJava10();
        lambdaWithVarInJava11();
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

/**
 * 标准HTTP客户端
 */
public class HttpClientExample {
    /**
     * 同步Get方法
     * @param uri
     * @throws Exception
     */
    private static void synGet(String uri) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder().uri(
                URI.create(uri)).build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }

    /**
     * 异步Get方法
     * @param uri
     * @throws Exception
     */
    private static void asyncGet(String uri) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder().uri(
                URI.create(uri)).build();
        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request,HttpResponse.BodyHandlers.ofString());
        future.whenComplete((resp,ex)->{
            if (ex!=null){
                ex.printStackTrace();
            }else {
                System.out.println(resp.statusCode());
                System.out.println(resp.body());
            }
        }).join();
    }

    public static void main(String[] args) throws Exception {
        String uri = "http://t.weather.sojson.com/api/weather/city/101030100";
        //synGet(uri);
        asyncGet(uri);
    }
}

import java.util.concurrent.TimeUnit;

/**
 * 改进Aarch64函数
 */
public class Aarch64Example {
    public static void mathOnJdk11() {
        long startTime = System.nanoTime();
        for (int i = 0; i < 100000000; i++) {
            Math.sin(i);
            Math.cos(i);
            Math.log(i);
        }
        long endTime = System.nanoTime();
        System.out.println(TimeUnit.NANOSECONDS.toMillis(endTime-startTime)+"ms");
    }

    public static void main(String[] args) {
        mathOnJdk11();
    }
}

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

/**
 * 动态语言API测试
 */
public class DynamicTest {
    private static void test(){
        System.out.println("动态语言API测试");
    }
    public static void main(String[] args) throws Throwable {
        // public方法的Lookup
//        MethodHandles.Lookup publicLookup = MethodHandles.publicLookup();
        // 所有方法的Lookup
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle mh = lookup.findStatic(DynamicTest.class,"test", MethodType.methodType(void.class));
        mh.invokeExact();
    }
}

动态语言API测试

G1垃圾收集器会将堆内存分配为等大小的region默认情况下是2048个region

对象内存分配过快，mixed gc来不及清理，导致old region被沾满会触发full gc，full gc是单线程执行

老年代占用的内存大小超过堆内存的预值时会触发mixed gc,预值可以在启动的时候指定

G1垃圾收集器

并发表及扫描垃圾回收器

并行垃圾收集器

串行垃圾收集器