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()
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 é:
Array inicial: [0, 1, 2, 45, 7, 5, 17] Array com 28 adicionados: [0, 1, 2, 45, 7, 5, 17, 28]
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.
// 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 é:
Array inicial: [0, 1, 2, 45, 7, 5, 17] Array com 28 adicionados:[0, 1, 2, 45, 7, 5, 17, 28]
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 é:
myArray antes de adicionar um novo elemento: [20, 21, 3, 4, 5, 88] myArray antes de adicionar um novo elemento: [20, 21, 3, 4, 5, 88, 12]
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 é:
myArray: [0, 1, 2, 3, 4] novo Array com o número adicionado: [0, 1, 2, 3, 4, 5]
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 é:
myArray antes de adicionar um novo elemento: [20, 21, 3, 4, 5, 88] myArray antes de adicionar um novo elemento: [20, 21, 3, 4, 5, 88, 12]
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.
Mais leitura: |
---|