Como adicionar um novo elemento a uma matriz em Java

Ah, matrizes Java. Eles são objeto de intenso amor e ódio de centenas de desenvolvedores de software iniciantes. Adicionar elementos a um array que já foi inicializado é impossível, eles disseram... Na verdade, é possível, mas não no sentido clássico... e não é muito conveniente. Adicionar novos elementos a um array que já foi inicializado é uma espécie de truque. No entanto, esses truques podem ser úteis em uma entrevista ... e às vezes no trabalho de um programador. Para garantir que você goste de usar o tipo de dados e saiba como fazê-lo com eficiência, escrevemos um guia sobre como adicionar um novo elemento a um array Java. Além de examinar cuidadosamente a teoria e os exemplos de código, certifique-se de verificar e concluir os problemas práticos apresentados na postagem.

O que é um Array em Java

Vamos relembrar o que é um Array e como criá-lo em Java. Se você se lembra disso, sinta-se à vontade para pular para o próximo subtítulo "5 maneiras de adicionar novos elementos a arrays Java". A documentação Java oficial da Oracle diz que arrays são uma série de valores pertencentes ao mesmo tipo de dados. Um conjunto de inteiros é um exemplo perfeito de array em Java . Todos os valores que você define têm uma posição específica dentro da matriz chamada de índice . Aqui estão as maneiras de declarar e inicializar arrays:

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}

No primeiro caso, definimos um array myArray e fizemos o Java alocar espaço para um array de 10 elementos, no segundo myArray1 , imediatamente inserimos 10 valores nele. Em ambos os casos, o elemento 11 não pode ser simplesmente inserido no array. Para realizar operações com arrays, os desenvolvedores manipulam os índices de valores que um array contém. O que deveríamos fazer? Vamos dar uma olhada nas formas mais comuns de adicionar à matriz.

5 maneiras de adicionar novos elementos a matrizes Java

Bem, aqui estão nossos truques para fazer o imutável parecer mutável.

• Converter uma matriz em uma lista
• Crie um novo array com maior capacidade e adicione um novo elemento ao array
• Implementando System.arraycopy()
• Copiando matrizes usando o Apache Commons
• Aplicando o método ArrayCopyOf()

Vamos dar uma olhada mais de perto nessas maneiras de adicionar um elemento a um array.

1. Convertendo um Array em uma Lista

Como não podemos adicionar um novo elemento a um array diretamente, a próxima melhor coisa a fazer é convertê-los em listas, adicionar novos elementos e reconverter os valores de volta para arrays. A primeira maneira de converter um array em uma lista é usar asList() para criar um novo ArrayList. Depois que o intervalo de valores for transformado com sucesso, use ListAdd() para inserir o valor. Assim que você não precisar mais editar um array, converta de volta para o tipo de dados original com a ajuda do método toArray() . Com todos os métodos e conversões, isso pode parecer confuso no começo. Vamos dar uma olhada no exemplo de uso de asList() para esclarecer as coisas.

// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;
 
class ArrayDemo{
   //Let’s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x) {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));
 
       // adding a new element to the array
       arrList.add(x);
 
       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args) {
       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};
 
       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));
 
       //element to be added
       int x = 28;
 
       // call the method to add x in myArray
       myArray = addX(myArray, x);
 
       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}

A saída é: Portanto, no programa, criamos com sucesso um array myArray de 7 valores, preenchemos e imprimimos. Então decidimos que dez valores não eram suficientes para nós. Bem, convertemos myArray em um ArrayList arrList usando o método Arrays.asList . Aqui está 28, o elemento a ser adicionado. Nós o adicionamos ao ArrayList arrList e, em seguida, o convertemos de volta em um array usando o método toArray() e imprimimos o novo array.

2. Crie um novo array com uma capacidade maior

Uma das maneiras mais comuns de adicionar mais elementos a um array é criando um novo array maior a partir do zero, colocando os elementos dos antigos e adicionando novos elementos. Aqui está um passo a passo do processo:

• Crie um novo array com a capacidade a+n (a — a capacidade original do array, n — o número de elementos que você deseja adicionar).
• Adicione todos os elementos do intervalo de dados anterior ao novo, bem como os novos valores.
• Imprima a matriz resultante.

Tente criar tal array por conta própria e compare seu código com o do exemplo abaixo:

// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {
   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}

A saída é: Bem, esta maneira de adicionar um novo elemento em uma matriz é a mais fácil.

3. Aplicando System.arrayCopy()

System.arrayCopy() é um método amplamente usado para alocar uma matriz maior no destino de uma matriz de origem. Um desenvolvedor pode especificar a sequência que deseja copiar para um novo array entre colchetes do método. Para ver como o método funciona e tentar usá-lo você mesmo, dê uma olhada e tente rodar o exemplo abaixo:

import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
       //we create a new Object here, an array of bigger capacity 
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

A saída é: Aqui criamos um array myArray , imprimimos e adicionamos um novo elemento usando nosso método addElement , que é construído em System.arrayCopy() .

4. Usando o Apache Commons para copiar arrays

Vamos usar uma maneira não padrão. Ou seja, uma biblioteca de terceiros Apache Commons lang. É uma parte do projeto Apache Commons focado em todos os aspectos de componentes Java reutilizáveis. Conhecimento sobre o projeto não será supérfluo. A linguagem Apache Commons tem um método add() projetado especificamente para permitir a expansão de arrays, economizando muito tempo e esforço dos codificadores. Vale a pena ter em mente que este método add() do Apache Commons é baseado na chamada do método System.arraycopy() no caso de você ter que responder a um exame complicado ou a uma pergunta de entrevista. Para adicionar as bibliotecas ao seu projeto, acesse o site Apache Commons e baixe as bibliotecas. Em seguida, vá para Arquivo → Estrutura do projeto → Bibliotecas > + e selecione os arquivos jar baixados.

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {
       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}

A saída é:

5. Implementando ArrayCopyOf()

ArrayCopyOf() é mais um método para adicionar um novo elemento a um array. Tal como Apache Commons lang add() ele chama internamente System.arraycopy() para fazer esta operação. No entanto, a maioria dos desenvolvedores prefere ArrayCopyOf() , pois permite manter o código conciso e legível. Aqui está um exemplo de uso de ArrayCopyOf() para adicionar novos elementos a um array:

import java.util.Arrays;
class ArrayDemo {
   private static <X> X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

A saída é:

Conclusão

Saber como adicionar elementos a um array ajuda os desenvolvedores a atualizar o código antigo rapidamente sem sacrificar sua funcionalidade e legibilidade… Ou apenas para passar na entrevista. Como existem diferentes maneiras de adicionar elementos a arrays Java, sinta-se à vontade para escolher o método com o qual se sinta confortável.