>
Menu

Array genérico de Java - como simular matrizes genéricas em Java?

  • Principal
  • Outro
  • Array genérico de Java - como simular matrizes genéricas em Java?

java generic array how simulate generic arrays java

Este tutorial explica como simular a funcionalidade do array genérico em Java usando o array de objetos e também usando a classe de reflexão com exemplo simples:

Já discutimos Genéricos Java em um de nossos tutoriais anteriores. Java permite classes genéricas, métodos, etc. que podem ser declarados independentemente dos tipos. No entanto, o Java não permite que o array seja genérico.

A razão para isso é que em Java, os arrays contêm informações relacionadas aos seus componentes e essas informações são usadas para alocar memória em tempo de execução. Quando são usados ​​genéricos, devido ao apagamento de tipo, o código de byte não contém nenhuma informação genérica.

=> Visite aqui para aprender Java do zero.

Array Genérico Java

O que você aprenderá:

Matriz genérica em Java

Se você definiu uma matriz genérica, o tipo de componente não será conhecido no tempo de execução. Portanto, não é aconselhável definir arrays como genéricos em Java.

Uma definição de Matriz Genérica é mostrada abaixo:

E [] newArray = new E[length];

O compilador não sabe o tipo exato que deve ser instanciado, pois as informações de tipo não estão disponíveis no tempo de execução.

Portanto, em vez de arrays, sempre que os genéricos forem necessários, você deve preferir o componente de lista da estrutura de Coleções Java. No entanto, você pode criar estruturas genéricas que são semelhantes a array usando array de objetos e recurso de reflexão de Java.

Essas duas abordagens que nos permitem definir arrays de diferentes tipos de dados são explicadas a seguir em detalhes.

Criar e inicializar o array genérico

Nesta seção, vamos criar uma estrutura semelhante a um array de natureza genérica. Usando essas estruturas, você poderá criar arrays fornecendo o tipo de dados como um argumento.

como abrir arquivo json no android

Usando Object Array

Essa abordagem usa a matriz do tipo Objetos como membro da classe da matriz principal. Também usamos métodos get / set para ler e definir os elementos do array. Em seguida, instanciamos a classe de array principal que nos permite fornecer o tipo de dados conforme necessário.

Isso simula a matriz genérica.

O programa a seguir demonstra o uso de array de objetos para criar uma estrutura semelhante a array genérico.

import java.util.Arrays; class Array { private final Object[] obj_array; //object array public final int length; // class constructor public Array(int length) { // instantiate a new Object array of specified length obj_array = new Object [length]; this.length = length; } // get obj_array[i] E get(int i) { @SuppressWarnings('unchecked') final E e = (E)obj_array[i]; return e; } // set e at obj_array[i] void set(int i, E e) { obj_array[i] = e; } @Override public String toString() { return Arrays.toString(obj_array); } } class Main { public static void main(String[] args){ final int length = 5; // creating integer array Arrayint_Array = new Array(length); System.out.print('Generic Array :' + ' '); for (int i = 0; i

Resultado:

Usando a matriz de objeto para criar uma estrutura semelhante a uma matriz genérica.

No programa acima, definimos uma classe Array que é genérica. A matriz de objeto é um membro da classe que é instanciada usando um construtor e comprimento. Também usamos os métodos get e set genéricos, usados ​​para ler e definir um elemento de array de um tipo específico.

Em seguida, criamos instâncias desta classe de array. Ao criar instâncias, podemos especificar o tipo desejado. No programa acima, criamos dois arrays do tipo Integer e String e, em seguida, povoamos esses arrays com os valores apropriados (usando o método set).

Finalmente, usando o método 'toString' substituído, exibimos o conteúdo de cada uma dessas instâncias.

Usando Reflexão

Nesta abordagem, usamos uma classe de reflexão para criar uma matriz genérica cujo tipo será conhecido apenas em tempo de execução.

A abordagem é semelhante à anterior com apenas uma diferença, ou seja, usamos a classe de reflexão no próprio construtor para instanciar uma matriz de objeto passando explicitamente as informações do tipo de dados para o construtor da classe.

quais programas podem abrir um arquivo dwg

Esse tipo de informação é passado para o método de reflexão Array.newInstance.

O seguinte programa mostra o uso de reflexão para criar uma matriz genérica . Observe que toda a estrutura do programa é semelhante à abordagem anterior, apenas com a diferença no uso de recursos de reflexão.

importjava.util.Arrays; class Array { private final E[] objArray; public final int length; // class constructor public Array(ClassdataType, int length){ // create a new array with the specified data type and length at runtime using reflection this.objArray = (E[]) java.lang.reflect.Array.newInstance(dataType, length); this.length = length; } // get element at objArray[i] Eget(int i) { returnobjArray[i]; } // assign e to objArray[i] void set(int i, E e) { objArray[i] = e; } @Override public String toString() { return Arrays.toString(objArray); } } class Main { public static void main(String[] args){ final int length = 5; // create array with Integer as data type Arrayint_Array = new Array(Integer.class, length); System.out.print('Generic Array:' + ' '); for (int i = 0; i

Resultado:

Uso de reflexão para criar uma matriz genérica

O programa acima mostra arrays de dois tipos, ou seja, Integer e String criados a partir da classe genérica Arrays.

Erro de criação de array genérico

Já discutimos as implicações da criação de arrays genéricos em Java e por que não é possível ter arrays genéricos em Java. Outra explicação para isso é que os arrays em Java são covariantes, enquanto os genéricos não. Os genéricos são invariantes.

Por covariância, queremos dizer que uma matriz do subtipo pode ser atribuída à sua referência de supertipo.

Isso significa que a seguinte instrução funcionará bem.

Number numArray[] = new Integer[10];

Como Integer é um subtipo de Number, a instrução acima é compilada corretamente.

Mas se usarmos o mesmo conceito com genéricos, ele não funcionará, ou seja, com genéricos, não podemos atribuir o subtipo genérico a um supertipo genérico.

A instrução, ListobjList = new ArrayList (); fornecerá um erro de compilação, pois os genéricos não são covariantes como os arrays.

Tendo em mente o motivo acima, não podemos ter algo como o seguinte:

public static ArrayList[] myarray = new ArrayList[2];

Esta declaração não será compilada com o erro, “Criação de array genérico” já que não podemos declarar uma matriz de referências a um tipo genérico específico.

Podemos, no entanto, criar uma matriz de referências a um tipo genérico específico usando curinga. A instrução acima pode ser compilada com êxito com uma ligeira alteração do uso de um curinga, conforme mostrado abaixo.

public static ArrayListmyarray = new ArrayList[5];

A instrução acima será compilada com sucesso.

O programa a seguir mostra uma demonstração do uso de curingas.

import java.util.*; //generic array class classArr { T tarray[]; Arr(T myarray[]) { tarray = myarray; } @Override public String toString() { return Arrays.toString(tarray); } } public class Main { public static void main(String[] args) { // Arrtarray[] = new Arr[5]; //error: generic array creation //initialize new array objects Arr arr1 = new Arr(new Integer[]{2,4,6,8,10}); System.out.print('Array with Integer type:' + ' '); System.out.println(arr1); Arr arr2 = new Arr(new String[]{'aa', 'bb', 'cc', 'dd'}); System.out.print('Array with String type:' + ' '); System.out.println(arr2); //define array objects using wildcard Arrarr3[] = new Arr[5]; arr3[0] = new Arr(new Integer[]{10, 20, 30, 40, 50}); System.out.println('Integer array: ' + arr3[0]); arr3[1] = new Arr(new Float[]{1.1f, 2.2f, 3.3f, 4.4f, 5.5f}); System.out.println('Float array: ' + arr3[1]); } }

Resultado:

melhor software para monitorar a temperatura da CPU

demonstração do uso de curingas

No programa acima, temos a primeira instrução no método principal que indica a invariância dos genéricos. Esta declaração mostrará o erro de compilação (mostrado nos comentários). A próxima criação de array segue as regras dos genéricos e, portanto, eles são compilados com sucesso.

perguntas frequentes

Q # 1) O que é um array genérico?

Responda: Arrays que são independentes do tipo de dados e cujo tipo de informação é avaliada em tempo de execução são arrays genéricos. Os genéricos são semelhantes aos modelos em C ++.

Q # 2) Você pode criar um array genérico em Java?

Responda: As matrizes são covariantes em Java, ou seja, qualquer matriz de subclasse pode ser atribuída a uma matriz de supertipo. Genéricos, no entanto, são invariantes, ou seja, você não pode atribuir matriz de tipo de subclasse ao tipo de superclasse.

Em segundo lugar, as informações genéricas são removidas da JVM e, portanto, a matriz cuja alocação de memória é feita em tempo de execução não sabe qual tipo deve ser atribuído à matriz. Portanto, arrays e genéricos não combinam bem em Java.

P # 3) O que é Tipo E em Java?

Responda: atua como um espaço reservado para genéricos e representa qualquer tipo de elemento.

P # 4) O que é Type Erasure em Java?

Responda: Um processo realizado pelo compilador Java pelo qual os tipos parametrizados usados ​​em genéricos são removidos e mapeados para tipos brutos no código de bytes. Como tal, o código de byte não contém nenhuma informação sobre genéricos.

P # 5) O que é um tipo bruto em Java?

Responda: Tipos brutos são tipos genéricos sem usar o parâmetro de tipo. Por exemplo. Lista é um tipo bruto; enquanto List é um tipo parametrizado.

Conclusão

Em Java, a matriz genérica não pode ser definida diretamente, ou seja, você não pode ter um tipo parametrizado atribuído a uma referência de matriz. No entanto, usando matrizes de objetos e recursos de reflexão, você pode simular a criação de matrizes genéricas.

Vimos essas duas abordagens neste tutorial junto com os detalhes do erro de criação de array genérico e as possibilidades de evitar esse erro. Em suma, em Java, você pode dizer que arrays e genéricos não andam de mãos dadas, já que arrays são covariantes enquanto os genéricos são invariantes.

=> Confira o guia de treinamento Java perfeito aqui.

Leitura recomendada

^