Características de JDK10

Descripción general de JAVA10

El 21 de marzo de 2018, Oracle anunció oficialmente el lanzamiento oficial de JAVA10.

Ni JAVA9 ni JAVA10 son versiones LTS (soporte a largo plazo). A diferencia de las principales actualizaciones de versiones anteriores de JAVA, estas dos solo tienen aproximadamente medio año de tiempo de desarrollo y mantenimiento.

JAVA10 define un total de 109 características nuevas, incluido JEP, que es la única característica nueva real para los programadores. También hay algunas nuevas API y especificaciones JVM, así como cambios en las especificaciones del lenguaje JAVA.

Para conocer los 12 JEP (propuesta de mejora JDK) de JAVA10, consulte el documento oficial http://openjdk.java.net/projects/jdk/10/

Nuevas características específicas:

286: Inferencia de tipo de variable local

296: fusión de biblioteca JDK

304: interfaz unificada de recolección de basura

307: Proporcionar GC completo paralelo para G1

310: intercambio de datos de clase de aplicación

312: Interacción de protocolo de enlace ThreadLocal

313: Eliminar herramienta javah incluida en JDK

314: use extensiones de etiquetas de idioma Unicode adicionales

316: Capacidad para asignar ocupación de memoria a dispositivos de memoria de repuesto especificados por el usuario

317: Uso del compilador JIT basado en JAVA

319: certificado raíz

322: Lanzamientos basados ​​en tiempo

cambios en el nivel gramatical

Inferencia de tipos para variables locales

Las declaraciones de tipo explícitas de variables locales a menudo se consideran innecesarias. Dar un nombre bonito a menudo puede expresar claramente cómo proceder, reduciendo la verbosidad y el código formal, evitando información redundante y alineando las variables. Nombre, fácil de leer.

Como programadores de JAVA, al declarar una variable, generalmente escribimos el tipo de variable dos veces, la primera vez se usa para declarar el tipo de variable y la segunda vez se usa para el constructor.

List<String> list =new ArrayList<>();

El tipo de declaración de variables es complejo y largo de escribir, especialmente con el uso de genéricos.

Iterator<Map.Entry<Integer,Student>> iterator=set.iterator();

También solemos declarar una variable que solo se usa una vez, en la siguiente línea de código:

URL url=new URL("http://www.boge.com");
URLConnection connection= url.openConnection();
Reader reader =new BufferedReader(new InputStreamReader(connection.getInputStream));

En resumen: el identificador de variable (nombre de variable) puede permitirme saber claramente cómo usar la variable, no es necesario agregar una larga lista de declaraciones de tipo delante de él.

La inferencia de variables locales es algo similar a la forma de escribir tipos de variables débiles en JavaScript: el tipo de datos anterior se infiere de los datos posteriores y la declaración del tipo de datos se unifica como var.

Escenarios donde no se puede utilizar la inferencia de tipos

Hay situaciones en las que no podemos utilizar la inferencia de tipos. Específicamente, existen los siguientes escenarios.

declaración de variables

La declaración de una variable no puede utilizar inferencia de tipos porque no se puede inferir.

// 根据右边的数据推断类型,不赋值压根没给推断的机会,这是错的
var userName;

Valor inicial nulo

El caso en el que el valor inicial sea nulo tampoco es aceptable. Porque tampoco hay forma de inferir

// null值无法推断数据类型,这是不能使用类型推断
var userName=null;

expresión lambda

        // 这个是可以的
        Supplier<Double> supplier=()-> Math.random();
        // 这个是不行的 lambda表达式需要显式数据类型,不然无法明确是哪个接口
        var supplier2=()->Math.random();

referencia del método

        // 这是可以的进行方法引用的
        Consumer<String> consumer=System.out::println;
        // 这是不可以的,无法明确接口类型
        var consumer2=System.out::println;

Inicialización estática de matrices.

        //动态初始化数据可以进行类型推断
        var arr =new String[10];
        //静态初始化数组不可以使用类型推断
        var arr2 = {
    
    "a12","222","333","444","555"};

Las variables miembro no se pueden utilizar

La inferencia de tipos es solo para variables locales, las variables miembro no pueden usar inferencia de tipos

public class Demo07 {
    
    
    // 成员变量不能使用类型推断
    var name="小明";
    public void testMethod1(){
    
    
        // 局部变量可以使用类型推断
        var localname="小明";
    }
}

Otros escenarios imposibles

// 情况1 没有初始化的局部变量声明
var s; var x=null;
// 情况2 方法的返回值类型
public var test1()
// 情况3 方法的参数类型
public void test2(var a,var b)
// 情况4 构造器的参数类型
public Person(var name,var age)
// 情况5 属性
class Person{
    
    
    var name;
}
// 情况6 catch块
try{
    
    
}catch(var e){
    
    
}

Es necesario tener en cuenta los siguientes dos puntos

1. var no es una palabra clave

No necesitamos preocuparnos de que los nombres de variables o nombres de métodos entren en conflicto con var, porque var no es en realidad una palabra clave, sino un nombre de tipo, y solo se usa cuando el compilador necesita conocer el tipo. un identificador legal ordinario. En otras palabras, excepto que no se puede usar como nombre de clase, se puede usar todo lo demás. Pero ¿qué tonto insiste en usar var como nombre de clase?

2. Después de todo, esto no es JavaScript.

Var no cambia el hecho de que Java es un lenguaje estático. El compilador es responsable de inferir el tipo y escribir el resultado en el código de bytes. En otras palabras, el tipo de datos todavía está en el código de bytes y Java todavía está fuertemente tipado. El lenguaje de programación no está escrito explícitamente por los desarrolladores. JavaScript es un lenguaje de secuencias de comandos interpretado de tipo débil y la inferencia de tipos aquí son dos cosas diferentes.

Cambios en el nivel de API

método copyOf de recopilación

Se agrega un nuevo método copyOf a las colecciones en JDK10. Se utiliza para crear colecciones de solo lectura.

        // JAVA9中新增创建只读的方法
        var strings1 = List.of("Python", "JAVA", "Golang");
        // JAVA10中新增的创建只读集合的方法
        var strings2 = List.copyOf(strings1);
        // 判断两个集合在内存上是否是同一个,结果为true
        System.out.println(strings1==strings2);

        // 创建一个普通集合
        var strings3=new ArrayList<String>();
        // 通过copyOf方法创建一个只读集合
        var strings4 = List.copyOf(strings3);
        // 判断两个集合在内存上是否是同一个,结果为false
        System.out.println(strings3==strings4);

Conclusión : El método copyOf devuelve una colección de solo lectura a través de una colección. Si el parámetro es originalmente una colección de solo lectura, entonces se devuelve el parámetro. Si el parámetro no es una colección de solo lectura, cree una colección de solo lectura y devolverlo.

Resumir

JAVA10 no tiene muchas características ni cambios, después de todo, el tiempo de desarrollo es solo medio año.