Em Java, um array é uma importante estrutura de dados linear que nos permite armazenar vários valores do mesmo tipo.

• Matrizes em Java são objetos como todos os outros objetos em matrizes Java que herdam implicitamente da classe java.lang.Object. Isso permite invocar métodos definidos em Object (como toString() equals() e hashCode()).
• Matrizes têm uma propriedade de comprimento integrada que fornece o número de elementos na matriz

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // initializing array      int  []     arr     =     {  40       55       63       17       22  };      // size of array      int     n     =     arr  .  length  ;      // traversing array      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }   }   

40 55 63 17 22  

Principais recursos de matrizes

• Armazenar primitivos e objetos: Matrizes Java podem conter tipos primitivos (como int char boolean etc.) e objetos (como String Integer etc.)
• Alocação de memória contígua Quando usamos arrays de tipos primitivos, os elementos são armazenados em locais contíguos. Para tipos não primitivos, as referências de itens são armazenadas em locais contíguos.
• Indexação baseada em zero: O primeiro elemento da matriz está no índice 0.
• Comprimento Fixo: Depois de criar um array, seu tamanho é fixo; não podemos mudar isso.

Operação básica em arrays em Java

1. Declarando um array

A forma geral de declaração de array é 

// Método 1:
int arr[];

// Método 2:
int[] arr;

O tipo de elemento determina o tipo de dados de cada elemento que compõe a matriz. Como um array de inteiros, também podemos criar um array de outros tipos de dados primitivos, como char float double etc. ou tipos de dados definidos pelo usuário (objetos de uma classe).

Observação: É assim que podemos criar uma variável de array, nenhum array real existe. Apenas informa ao compilador que esta variável (int Array) conterá um array do tipo inteiro.

2. Inicialização de um array em Java

Quando um array é declarado, apenas uma referência de um array é criada. Usamos new para alocar um array de determinado tamanho.

int arr[] = new int[tamanho];

• A declaração do array geralmente é estática, mas se o tamanho não for definido, o array será dimensionado dinamicamente.
• A memória para arrays é sempre alocada dinamicamente (no segmento heap) em Java. Isso é diferente de C/C++, onde a memória pode ser alocada estaticamente ou dinamicamente.
• Os elementos do array alocados por new serão automaticamente inicializados com zero (para tipos numéricos), false (para booleanos) ou null (para tipos de referência).

Matriz Literal em Java

Em uma situação em que o tamanho do array e as variáveis ​​do array já são conhecidos, literais de array podem ser usados. 

//Declarando literal do array
int[] arr = new int[]{ 12345678910 };

• O comprimento desta matriz determina o comprimento da matriz criada.
• Não há necessidade de escrever a nova parte int[] nas versões mais recentes do Java.

3. Altere um elemento do array

Para alterar um elemento, atribua um novo valor a um índice específico. O índice começa com 0 e termina em (tamanho total da matriz)-1.

//Alterando o primeiro elemento para 90
arr[0] = 90;

4. Comprimento da matriz

Podemos obter o comprimento de um array usando a propriedade length:

// Obtendo o comprimento do array
int n = arr.comprimento;

5. Acessando e atualizando todos os elementos do array

• Todos os elementos do array podem ser acessados ​​usando Java for Loop.
• Cada elemento do array é acessado por meio de seu índice.

O programa Java para ilustrar a criação de um array de inteiros coloca alguns valores no array e imprime cada valor na saída padrão

   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // declares an Array of integers.      int  []     arr  ;      // allocating memory for 5 integers.      arr     =     new     int  [  5  ]  ;      // initialize the elements of the array      // first to last(fifth) element      arr  [  0  ]     =     2  ;      arr  [  1  ]     =     4  ;      arr  [  2  ]     =     8  ;      arr  [  3  ]     =     12  ;      arr  [  4  ]     =     16  ;      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at index '     +      i     +     ' : '     +     arr  [  i  ]  );      }   }   

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16  

Matrizes de objetos em Java

Uma matriz de objetos é criada como uma matriz de itens de dados de tipo primitivo

Exemplo : Aqui estamos pegando uma classe de aluno e criando um array de Student com cinco objetos Student armazenados no array. Os objetos Student devem ser instanciados usando o construtor da classe Student e suas referências devem ser atribuídas aos elementos do array.

   class   Student     {      public     int     roll_no  ;      public     String     name  ;          Student  (  int     roll_no       String     name  ){      this  .  roll_no     =     roll_no  ;      this  .  name     =     name  ;      }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  ){          // declares an Array of Student      Student  []     arr  ;      // allocating memory for 5 objects of type Student.      arr     =     new     Student  [  5  ]  ;      // initialize the elements of the array      arr  [  0  ]     =     new     Student  (  1       'aman'  );      arr  [  1  ]     =     new     Student  (  2       'vaibhav'  );      arr  [  2  ]     =     new     Student  (  3       'shikar'  );      arr  [  3  ]     =     new     Student  (  4       'dharmesh'  );      arr  [  4  ]     =     new     Student  (  5       'mohit'  );      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at '     +     i     +     ' : { '      +     arr  [  i  ]  .  roll_no     +     ' '      +     arr  [  i  ]  .  name  +  ' }'  );      }   }   

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit }  

O que acontece se tentarmos acessar elementos fora do tamanho do array?

A JVM lança ArrayIndexOutOfBoundsException para indicar que o array foi acessado com um índice ilegal. O índice é negativo ou maior ou igual ao tamanho de uma matriz.

O código abaixo mostra o que acontece se tentarmos acessar elementos fora do tamanho do array:

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int  []     arr     =     new     int  [  4  ]  ;      arr  [  0  ]     =     10  ;      arr  [  1  ]     =     20  ;      arr  [  2  ]     =     30  ;      arr  [  3  ]     =     40  ;      System  .  out  .  println  (      'Trying to access element outside the size of array'  );      System  .  out  .  println  (  arr  [  5  ]  );      }   }   

Saída:

Passando arrays para métodos

Assim como as variáveis, também podemos passar arrays para métodos. Por exemplo, o programa abaixo passa o array para o método sum para calcular a soma dos valores do array.

Exemplo:

   public     class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     {     3       1       2       5       4     };      // passing array to method m1      sum  (  arr  );      }      public     static     void     sum  (  int  []     arr  )      {      // getting sum of array values      int     sum     =     0  ;      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      sum     +=     arr  [  i  ]  ;      System  .  out  .  println  (  'sum of array values : '     +     sum  );      }   }   

sum of array values : 15  

Explicação

• Este programa Java demonstra como passar um array para um método.
• Um array inteiro arr é declarado e inicializado no método principal.
• O método sum() é chamado com arr como argumento.
• Dentro do método sum() todos os elementos do array são adicionados usando um loop for.
• A soma final é então impressa no console.

Retornando arrays de métodos

Como sempre, um método também pode retornar um array. Por exemplo, o programa abaixo retorna um array do método m1. 

Exemplo:

   class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     m1  ();      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }      public     static     int  []     m1  ()      {      // returning array      return     new     int  []     {     1       2       3     };      }   }   

1 2 3  

Vantagens dos arrays Java

• Acesso eficiente: Acessar um elemento pelo seu índice é rápido e possui complexidade de tempo constante O(1).
• Gerenciamento de memória: Os arrays têm tamanho fixo, o que torna o gerenciamento de memória simples e previsível.
• Organização de dados: As matrizes ajudam a organizar os dados de maneira estruturada, facilitando o gerenciamento de elementos relacionados.

Desvantagens dos arrays Java

• Tamanho fixo: Depois que um array é criado, seu tamanho não pode ser alterado, o que pode levar ao desperdício de memória se o tamanho for superestimado ou ao armazenamento insuficiente se for subestimado.
• Homogeneidade de tipo: As matrizes só podem armazenar elementos do mesmo tipo de dados, o que pode exigir tratamento adicional para tipos mistos de dados.
• Inserção e exclusão: Inserir ou excluir elementos, especialmente no meio de uma matriz, pode ser caro, pois pode exigir a mudança de elementos.

Postagens relacionadas

• Matriz irregular em Java
• Para cada loop em Java
• Classe de matrizes em Java