¿Cómo crear una matriz genérica en Java?

Debido a la implementación de los genéricos de Java, no puede tener un código como este:

public class GenSet<E> {
    private E a[];

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

¿Cómo puedo implementar esto manteniendo la seguridad de tipo?

Vi una solución en los foros de Java que dice así:

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Pero realmente no entiendo lo que está pasando.

Tengo que hacer una pregunta a cambio: ¿está GenSet"marcado" o "no marcado"? Qué significa eso?

• Comprobado : mecanografía fuerte . GenSetsabe explícitamente qué tipo de objetos contiene (es decir, su constructor fue llamado explícitamente con un Class<E>argumento, y los métodos arrojarán una excepción cuando se pasen argumentos que no son de tipo E. Ver Collections.checkedCollection.

  -> en ese caso, deberías escribir:

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }

• Sin marcar : mecanografía débil . En realidad, no se realiza ninguna verificación de tipo en ninguno de los objetos pasados ​​como argumento.

  -> en ese caso, deberías escribir

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }

  Tenga en cuenta que el tipo de componente de la matriz debe ser la eliminación del parámetro de tipo:

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }

Todo esto es el resultado de una debilidad conocida y deliberada de los genéricos en Java: se implementó usando el borrado, por lo que las clases "genéricas" no saben con qué argumento de tipo se crearon en tiempo de ejecución y, por lo tanto, no pueden proporcionar tipo- seguridad a menos que se implemente algún mecanismo explícito (verificación de tipo).

Puedes hacerlo:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

Esta es una de las formas sugeridas de implementar una colección genérica en Effective Java; Artículo 26 . Sin errores de tipo, no es necesario emitir la matriz repetidamente Sin embargo, esto desencadena una advertencia porque es potencialmente peligroso y debe usarse con precaución. Como se detalla en los comentarios, esto Object[]ahora se está haciendo pasar por nuestro E[]tipo y puede causar errores inesperados oClassCastException haciendo pasar s si se usa de manera insegura.

Como regla general, este comportamiento es seguro siempre que la matriz de conversión se use internamente (por ejemplo, para respaldar una estructura de datos) y no se devuelva o se exponga al código del cliente. Si necesita devolver una matriz de un tipo genérico a otro código, la reflexiónArray clase de que menciona es el camino correcto.

Vale la pena mencionar que, siempre que sea posible, pasará un tiempo mucho más feliz trabajando con Lists en lugar de matrices si usa genéricos. Ciertamente, a veces no tienes otra opción, pero usar el marco de colecciones es mucho más robusto.

Aquí le mostramos cómo usar los genéricos para obtener una matriz del tipo que está buscando y al mismo tiempo preservar la seguridad de la fuente (a diferencia de las otras respuestas, que le devolverán una Objectmatriz o generarán advertencias en el momento de la compilación):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

Eso se compila sin advertencias y, como puede ver main, para cualquier tipo de declaración de instancia GenSet, puede asignar aa una matriz de ese tipo, y puede asignar un elemento aa una variable de ese tipo, lo que significa que la matriz y los valores en la matriz son del tipo correcto.

Funciona mediante el uso de literales de clase como tokens de tipo de tiempo de ejecución, como se explica en los Tutoriales de Java . Los literales de clase son tratados por el compilador como instancias de java.lang.Class. Para usar uno, simplemente siga el nombre de una clase con .class. Entonces, String.classactúa como un Classobjeto que representa la clase String. Esto también funciona para interfaces, enumeraciones, matrices de cualquier dimensión (p String[].class. Ej. ), Primitivas (p int.class. Ej. ) Y la palabra clave void( p void.class. Ej .).

Classen sí es genérico (declarado como Class<T>, donde Trepresenta el tipo que Classrepresenta el objeto), lo que significa que el tipo de String.classesClass<String> .

Entonces, cada vez que llama al constructor GenSet, pasa un literal de clase para el primer argumento que representa una matriz del GenSettipo declarado de la instancia (por ejemplo, String[].classparaGenSet<String> ). Tenga en cuenta que no podrá obtener una matriz de primitivas, ya que las primitivas no se pueden usar para variables de tipo.

Dentro del constructor, llamar al método castdevuelve el Objectargumento pasado emitido a la clase representada por el Classobjeto en el que se llamó el método. Llamar al método estático newInstanceen java.lang.reflect.Arraydevuelve como una Objectmatriz del tipo representado por el Classobjeto pasado como primer argumento y de la longitud especificada por el intpasado como segundo argumento. Llamar al método getComponentTypedevuelve un Classobjeto que representa el tipo de componente de la matriz representada por el Classobjeto en el que se llamó el método (por ejemplo , String.classpara String[].class, nullsi el Classobjeto no representa una matriz).

Esa última oración no es del todo precisa. Llamar String[].class.getComponentType()devuelve un Classobjeto que representa la clase String, pero su tipo es Class<?>, no Class<String>, por lo que no puede hacer algo como lo siguiente.

String foo = String[].class.getComponentType().cast("bar"); // won't compile

Lo mismo ocurre con cada método Classque devuelve unClass objeto.

Con respecto al comentario de Joachim Sauer sobre esta respuesta (no tengo suficiente reputación para comentarlo yo mismo), el ejemplo que usa el elenco T[]dará como resultado una advertencia porque el compilador no puede garantizar la seguridad de tipo en ese caso.

Editar con respecto a los comentarios de Ingo:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

Esta es la única respuesta segura.

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

Para extender a más dimensiones, sólo tiene que añadir []parámetros de dimensión a 's y newInstance()( Tes un parámetro de tipo, clses una Class<T>, d1a través d5son números enteros):

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

Ver Array.newInstance()para más detalles.

En Java 8, podemos hacer una especie de creación de matriz genérica utilizando una referencia lambda o método. Esto es similar al enfoque reflexivo (que pasa a Class), pero aquí no estamos usando la reflexión.

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

Por ejemplo, esto es usado por <A> A[] Stream.toArray(IntFunction<A[]>) .

Esto podría también hacerse pre-Java 8 utilizando las clases anónimas pero es más engorroso.

Esto está cubierto en el Capítulo 5 (Genéricos) de Effective Java, 2nd Edition , item 25 ... Listas preferidas a las matrices

Su código funcionará, aunque generará una advertencia no verificada (que podría suprimir con la siguiente anotación:

@SuppressWarnings({"unchecked"})

Sin embargo, probablemente sería mejor usar una Lista en lugar de una Matriz.

Hay una discusión interesante sobre este error / característica en el sitio del proyecto OpenJDK .

No es necesario pasar el argumento de clase al constructor. Prueba esto.

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

y

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

resultado:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

Los genéricos de Java funcionan verificando los tipos en el momento de la compilación e insertando las conversiones apropiadas, pero borrando los tipos en los archivos compilados. Esto hace que las bibliotecas genéricas sean utilizables por código que no comprende los genéricos (que fue una decisión de diseño deliberada) pero que significa que normalmente no puede averiguar cuál es el tipo en tiempo de ejecución.

El Stack(Class<T> clazz,int capacity)constructor público requiere que pase un objeto de clase en tiempo de ejecución, lo que significa que la información de clase está disponible en tiempo de ejecución para codificarla. Y elClass<T> formulario significa que el compilador verificará que el objeto Class que pasa es precisamente el objeto Class para el tipo T. No es una subclase de T, no una superclase de T, sino precisamente T.

Esto significa que puede crear un objeto de matriz del tipo apropiado en su constructor, lo que significa que el tipo de los objetos que almacena en su colección verificará sus tipos en el momento en que se agreguen a la colección.

Hola, aunque el hilo está muerto, me gustaría llamar su atención sobre esto:

Los genéricos se utilizan para la verificación de tipos durante el tiempo de compilación:

• Por lo tanto, el propósito es verificar que lo que entra es lo que necesita.
• Lo que devuelve es lo que necesita el consumidor.
• Mira esto:

No se preocupe por las advertencias de tipografía cuando escriba una clase genérica. Preocúpate cuando lo estés usando.

¿Qué hay de esta solución?

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

Funciona y parece demasiado simple para ser verdad. ¿Hay algún inconveniente?

Mira también este código:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

Convierte una lista de cualquier tipo de objeto en una matriz del mismo tipo.

He encontrado una manera rápida y fácil que funciona para mí. Tenga en cuenta que solo he usado esto en Java JDK 8. No sé si funcionará con versiones anteriores.

Aunque no podemos instanciar una matriz genérica de un parámetro de tipo específico, podemos pasar una matriz ya creada a un constructor de clase genérico.

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

Ahora en main podemos crear la matriz así:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

Para una mayor flexibilidad con sus matrices, puede usar una lista vinculada, por ejemplo. ArrayList y otros métodos encontrados en la clase Java.util.ArrayList.

El ejemplo está utilizando la reflexión de Java para crear una matriz. Hacer esto generalmente no se recomienda, ya que no es seguro para escribir. En cambio, lo que debe hacer es usar una Lista interna y evitar la matriz.

Pasando una lista de valores ...

public <T> T[] array(T... values) {
    return values;
}

Hice este fragmento de código para crear una instancia reflexiva de una clase que se pasa para una simple utilidad de prueba automatizada.

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

Tenga en cuenta este segmento:

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

para el inicio de la matriz donde Array.newInstance (clase de matriz, tamaño de matriz) . La clase puede ser primitiva (int.class) y object (Integer.class).

BeanUtils es parte de la primavera.

En realidad, una forma más fácil de hacerlo es crear una matriz de objetos y convertirlos al tipo deseado, como en el siguiente ejemplo:

T[] array = (T[])new Object[SIZE];

donde SIZEes una constante y Tes un identificador de tipo

El lanzamiento forzado sugerido por otras personas no funcionó para mí, arrojando una excepción de lanzamiento ilegal.

Sin embargo, este elenco implícito funcionó bien:

Item<K>[] array = new Item[SIZE];

donde Item es una clase que definí que contiene el miembro:

private K value;

De esta forma, obtiene una matriz de tipo K (si el elemento solo tiene el valor) o cualquier tipo genérico que desee definir en la clase Elemento.

Nadie más ha respondido a la pregunta de lo que está sucediendo en el ejemplo que publicaste.

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Como otros han dicho, los genéricos se "borran" durante la compilación. Entonces, en tiempo de ejecución, una instancia de un genérico no sabe cuál es su tipo de componente. La razón de esto es histórica, Sun quería agregar genéricos sin romper la interfaz existente (tanto fuente como binaria).

Las matrices, por otro lado , conocen su tipo de componente en tiempo de ejecución.

Este ejemplo soluciona el problema al hacer que el código que llama al constructor (que conoce el tipo) pase un parámetro que le dice a la clase el tipo requerido.

Entonces la aplicación construiría la clase con algo como

Stack<foo> = new Stack<foo>(foo.class,50)

y el constructor ahora sabe (en tiempo de ejecución) cuál es el tipo de componente y puede usar esa información para construir la matriz a través de la API de reflexión.

Array.newInstance(clazz, capacity);

Finalmente, tenemos un tipo de conversión porque el compilador no tiene forma de saber que la matriz devuelta Array#newInstance()es del tipo correcto (aunque lo sepamos).

Este estilo es un poco feo, pero a veces puede ser la solución menos mala para crear tipos genéricos que necesitan conocer su tipo de componente en tiempo de ejecución por cualquier razón (creando matrices o instancias de su tipo de componente, etc.).

Encontré una especie de solución a este problema.

La siguiente línea arroja un error genérico de creación de matriz

List<Person>[] personLists=new ArrayList<Person>()[10];

Sin embargo, si encapsulo List<Person>en una clase separada, funciona.

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

Puede exponer a las personas en la clase PersonList a través de un captador. La línea a continuación le dará una matriz, que tiene un List<Person>elemento en cada elemento. En otras palabras, matriz de List<Person>.

PersonList[] personLists=new PersonList[10];

Necesitaba algo como esto en algún código en el que estaba trabajando y esto es lo que hice para que funcione. Hasta el momento no hay problemas.

Puede crear una matriz de Objetos y enviarla a E en todas partes. Sí, no es una forma muy limpia de hacerlo, pero al menos debería funcionar.

prueba esto.

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

Una solución fácil, aunque desordenada, para esto sería anidar una segunda clase "titular" dentro de su clase principal y usarla para guardar sus datos.

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

Tal vez no esté relacionado con esta pregunta, pero mientras recibía el " generic array creation" error por usar

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

Descubro los siguientes trabajos (y funcionó para mí) con @SuppressWarnings({"unchecked"}):

 Tuple<Long, String>[] tupleArray = new Tuple[10];

Me pregunto si este código crearía una matriz genérica efectiva.

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

Editar: ¿Quizás una forma alternativa de crear una matriz de este tipo, si el tamaño que necesitabas fuera conocido y pequeño, sería simplemente alimentar el número requerido de "nulos" en el comando zeroArray?

Aunque obviamente esto no es tan versátil como usar el código createArray.

Podrías usar un yeso:

public class GenSet<Item> {
    private Item[] a;

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

En realidad, encontré una solución bastante única para evitar la incapacidad de iniciar una matriz genérica. Lo que tiene que hacer es crear una clase que tome la variable genérica T así:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

y luego en tu clase de matriz solo haz que comience así:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

iniciar un new Generic Invoker[]causará un problema sin marcar, pero en realidad no debería haber ningún problema.

Para obtener de la matriz, debe llamar a la matriz [i] .variable de esta manera:

public T get(int index){
    return array[index].variable;
}

El resto, como cambiar el tamaño de la matriz, se puede hacer con Arrays.copyOf () de esta manera:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

Y la función de agregar se puede agregar así:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

Según vnportnoy, la sintaxis

GenSet<Integer> intSet[] = new GenSet[3];

crea una matriz de referencias nulas, que se completarán como

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

Que es de tipo seguro.

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

La creación genérica de matrices no está permitida en Java, pero puede hacerlo como

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}