Criando uma matriz de objects em Java

Eu sou novo em Java e pela época criei uma matriz de objects em Java.

Eu tenho uma class A por exemplo –

A[] arr = new A[4]; 

Mas isso é apenas criar pointers (referências) para A e não 4 objects. Isso está correto? Eu vejo que quando tento acessar funções / variables ​​nos objects criados eu recebo uma exceção de ponteiro nulo. Para poder manipular / acessar os objects eu tive que fazer isso –

 A[] arr = new A[4]; for( int i=0; i<4; i++ ) arr[i] = new A(); 

Isso está correto ou estou fazendo algo errado? Se isso está correto, é realmente estranho.

EDIT: Eu acho isso estranho porque em C ++ você acabou de dizer novo A [4] e cria os quatro objects.

Isto está certo.

 A[] a = new A[4]; 

cria 4 referências A, semelhantes a fazer isso

 A a1; A a2; A a3; A a4; 

agora você não poderia fazer a1.someMethod () sem alocar a1 como

 a1 = new A(); 

da mesma forma, com o array que você precisa fazer

 a[0] = new A(); 

antes de usá-lo.

Isto está certo. Você também pode fazer:

 A[] a = new A[] { new A("args"), new A("other args"), .. }; 

Essa syntax também pode ser usada para criar e inicializar um array em qualquer lugar, como em um argumento de método:

 someMethod( new A[] { new A("args"), new A("other args"), . . } ) 

Sim, cria apenas referências, que são definidas como seu valor padrão null. É por isso que você obtém um NullPointerException. Você precisa criar objects separadamente e atribuir a referência. Existem 3 etapas para criar matrizes em Java –

Declaração – Nesta etapa, especificamos o tipo de dados e as dimensões da matriz que vamos criar. Mas lembre-se, não mencionamos os tamanhos das dimensões ainda. Eles são deixados vazios.

Instanciação – Nesta etapa, criamos a matriz ou alocamos memory para a matriz, usando a nova palavra-chave. É nesta etapa que mencionamos os tamanhos das dimensões da matriz.

Inicialização – A matriz é sempre inicializada para o valor padrão do tipo de dados. Mas podemos fazer nossas próprias inicializações.

Declarando matrizes em Java

É assim que declaramos um array unidimensional em Java –

 int[] array; int array[]; 

A Oracle recomenda que você use a antiga syntax para declarar matrizes. Aqui estão alguns outros exemplos de declarações legais –

 // One Dimensional Arrays int[] intArray; // Good double[] doubleArray; // One Dimensional Arrays byte byteArray[]; // Ugly! long longArray[]; // Two Dimensional Arrays int[][] int2DArray; // Good double[][] double2DArray; // Two Dimensional Arrays byte[] byte2DArray[]; // Ugly long[] long2DArray[]; 

E estes são alguns exemplos de declarações ilegais –

 int[5] intArray; // Don't mention size! double{} doubleArray; // Square Brackets please! 

Instanciação

É assim que “instanciamos” ou alocamos memory para um array –

 int[] array = new int[5]; 

Quando a JVM encontra a new palavra-chave, ela entende que deve alocar memory para algo. E especificando int[5] , queremos dizer que queremos uma matriz de int s, de tamanho 5. Assim, a JVM cria a memory e atribui a referência da memory recém-alocada ao array que uma “referência” do tipo int[]

Inicialização

Usando um loop – Usar um loop for para inicializar elementos de uma matriz é a maneira mais comum de obter o array. Não há necessidade de executar um loop for se você for designar o próprio valor padrão, porque a JVM faz isso por você.

Tudo em um..! – Podemos declarar, instanciar e inicializar nosso array de uma só vez. Aqui está a syntax –

 int[] arr = {1, 2, 3, 4, 5}; 

Aqui, não mencionamos o tamanho, porque a JVM pode ver que estamos dando 5 valores.

Então, até que instanciamos as referências permanecem nulas. Espero que minha resposta tenha te ajudado ..! 🙂

Fonte – Arrays em Java

Aqui está o exemplo claro de criar uma matriz de 10 objects de funcionários, com um construtor que usa o parâmetro:

 public class MainClass { public static void main(String args[]) { System.out.println("Hello, World!"); //step1 : first create array of 10 elements that holds object addresses. Emp[] employees = new Emp[10]; //step2 : now create objects in a loop. for(int i=0; i 

Você está certo. Afora isso, se quisermos criar uma matriz de tamanho específico preenchida com elementos fornecidos por alguma “fábrica”, desde o Java 8 (que introduz a API de stream ), podemos usar essa linha única:

 A[] a = Stream.generate(() -> new A()).limit(4).toArray(A[]::new); 
  • Stream.generate(() -> new A()) é como factory para separar elementos A criados de uma maneira descrita por lambda, () -> new A() que é implementação do Supplier – descreve como cada novo Instâncias devem ser criadas.
  • limit(4) configura a quantidade de elementos que o stream gerará
  • toArray(A[]::new) (também pode ser reescrito como toArray(size -> new A[size]) ) – ele nos permite decidir / descrever o tipo de array que deve ser retornado.

Para alguns tipos primitivos, você pode usar DoubleStream , DoubleStream , IntStream , que adicionalmente fornecem geradores como range rangeClosed e alguns outros.

Sim, está correto em Java, existem várias etapas para criar uma matriz de objects:

  1. Declarando e instanciando (crie memory para armazenar objects ‘4’):

     A[ ] arr = new A[4]; 
  2. Inicializando os Objetos (Neste caso, você pode inicializar 4 objects da class A)

     arr[0] = new A(); arr[1] = new A(); arr[2] = new A(); arr[3] = new A(); 

    ou

     for( int i=0; i<4; i++ ) arr[i] = new A(); 

Agora você pode começar a chamar methods existentes dos objects que acabou de criar, etc.

Por exemplo:

  int x = arr[1].getNumber(); 

ou

  arr[1].setNumber(x); 

Para uma class genérica, é necessário criar uma class wrapper. Por exemplo:

 Set[] sets = new HashSet<>[10] 

resulta em: “Não é possível criar uma matriz genérica”

Use em vez disso:

  class SetOfS{public Set set = new HashSet<>();} SetOfS[] sets = new SetOfS[10];