Anotación @SafeVarargs en Java 9 con ejemplo

Anotación @SafeVarargs : la anotación @SafeVarargs se introduce en JDK 7. La anotación @SafeVarargs se usa para suprimir las advertencias de operación no segura en el momento de la compilación. Las advertencias de operación insegura aparecen en el momento de la compilación cada vez que en nuestro código invocamos el método que tiene varargs, es decir, un número variable de argumentos. La anotación @SafeVarargs se puede usar con el método/constructor y el método debe ser final o estático. Podemos usar la anotación @SafeVarargs con los métodos que no se pueden anular porque un método de anulación aún puede realizar una operación no segura en sus varargs. La anotación @SafeVarargs se usa para indicar que los métodos no causarán contaminación del montón. Estos métodos se consideran seguros.

En JDK 9, los desarrolladores de JDK ampliaron el uso de la anotación @SafeVarargs, ahora, además del método final o estático, también podemos usar la anotación @SafeVarargs con el método privado. Esto se debe a que los métodos privados no se pueden anular.

¿Qué son las advertencias de funcionamiento inseguro?

Java 5 introdujo el concepto de Varargs , o un parámetro de método de longitud variable, así como Generics y la advertencia de operaciones no verificadas o inseguras se agregó solo esta vez. Ahora la pregunta es ¿por qué el compilador lanza una advertencia cuando usamos el método con varargs o usamos Generics? Cuando el compilador arroja una advertencia de operación insegura, el compilador generalmente le pide que sea más explícito sobre los tipos, de una forma u otra.

Entendamos el concepto con algunos ejemplos:

// Program to illustrate the unsafe operation warnings
// message with respect to varargs parameter
  
import java.util.ArrayList;
import java.util.List;
  
public class Geeksforgeeks {
  
    // print is a method with variable argument
    private void print(List... topics)
    {
        for (List<String> topic : topics) {
            System.out.println(topic);
        }
    }
  
    public static void main(String[] args)
    {
        Geeksforgeeks obj = new Geeksforgeeks();
        List<String> list = new ArrayList<String>();
        list.add("OOPS");
        list.add("COLLECTION");
        obj.print(list);
    }
}

Consola de tiempo de compilación:

Note: Geeksforgeeks.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Producción:

[OOPS, COLLECTION]

Aquí tenemos un método con varargs de tipo List. Pero aquí no mencionamos el tipo de datos que almacenará List. Aquí el compilador le advertirá que no voy a revisar su código. No voy a verificar que los valores que agregará a ArrayList sean de un tipo en particular o no. Es por eso que arrojará advertencias de operación insegura en el momento de la compilación. Aquí el compilador quiere saber el tipo como

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

Si crearemos ArrayList con tipo, entonces el compilador no arrojará ningún mensaje de advertencia en el momento de la compilación.

Ejecutemos el mismo código nuevamente después de usar la anotación @SafeVarargs.

// Program to illustrate the
// @SafeVarargs with respect to varargs
  
import java.util.ArrayList;
import java.util.List;
  
public class Geeksforgeeks {
  
    // Here we used @SafeVarargs annotation,
    // now we will not get any unchecked
    // or unsafe operations warning message
    // at compile time
    @SafeVarargs
    private void print(List... topics)
    {
        for (List<String> topic : topics) {
            System.out.println(topic);
        }
    }
  
    public static void main(String[] args)
    {
        Geeksforgeeks obj = new Geeksforgeeks();
        List<String> list = new ArrayList<String>();
        list.add("OOPS");
        list.add("COLLECTION");
        obj.print(list);
    }
}

Producción:

[OOPS, COLLECTION]

Nota: supongamos que si desea ejecutar el código anterior en JDK 7 o JDK 8, obtendrá un error de compilación porque estas mejoras se realizan en Java 9, antes de Java 9: ​​los métodos privados no pueden marcarse con esta anotación.

// Program to illustrate the unsafe
// operation warnings message
// with respect to Generics
  
import java.util.ArrayList;
import java.util.List;
  
public class Geeks<T> {
  
    private List<T> topics = new ArrayList<>();
  
    // Here add() is a method with varargs of type T
    // Here T is unknown for
    // the compiler at the compile time
    // That's why It will throw unsafe
    // operation warning message
    public final void add(T... toAdd)
    {
        for (T topic : toAdd) {
            topics.add(topic);
        }
    }
  
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
        geek.add("OOPS",
                 "COLLECTIONS",
                 "EXCEPTION-HANDLING");
        System.out.println(geek.topics);
    }
}

Consola de tiempo de compilación:

Note: Geeks.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Producción:

[OOPS, COLLECTIONS, EXCEPTION-HANDLING]

Ejecutemos el mismo código nuevamente después de usar la anotación @SafeVarargs.

// Program to illustrate the
// @SafeVarargs with respect to Generics
  
import java.util.ArrayList;
import java.util.List;
  
public class Geeks<T> {
  
    private List<T> topics = new ArrayList<>();
  
    // Here by placing @SafeVarargs annotation
    // to add() method, we are ensuring to the
    // compiler that our action is safe.
    // That's why compiler will not throw
    // any warning message at the compile time.
    @SafeVarargs
    public final void add(T... toAdd)
    {
        for (T topic : toAdd) {
            topics.add(topic);
        }
    }
  
    public static void main(String[] args)
    {
        Geeks geek = new Geeks();
        geek.add("OOPS",
                 "COLLECTIONS",
                 "EXCEPTION-HANDLING");
        System.out.println(geek.topics);
    }
}

Producción:

[OOPS, COLLECTIONS, EXCEPTION-HANDLING]