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.

linux renomear pasta

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.

tipos de dados sequenciais

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