Crie um array dinâmico em Java

Um array é uma estrutura de dados de tamanho fixo cujo tamanho não pode ser alterado depois de declarado. Um array dinâmico nos fornece a facilidade de criar arrays de tamanhos dinâmicos. Podemos aumentar e diminuir esses tamanhos de acordo com, e vamos discutir como fazer um array dinâmico Java neste artigo.

Crie um array dinâmica usando lógica personalizada em Java

No exemplo, usamos a lógica personalizada que inclui métodos para adicionar um elemento no final do array ou em qualquer índice. Quando a matriz está cheia, o tamanho do array aumenta duas vezes. Também removemos e reduzimos a matriz no processo.

Usamos duas classes para testar a lógica de array dinâmica; a primeira é a DynamicClass e a segunda é a classe DynamicArrayTest. No DynamicArrayTest, criamos um array do tipo int intArray e duas variáveis ​​int denominadas size e capacity. O tamanho do array é o número de itens nele, e a capacidade de um array é o espaço total nele.

Criamos um construtor da classe DynamicArrayTest e inicializamos intArray com um array int de tamanho 2. Em seguida, inicializamos o size com 0 e capacity como 2. Finalmente, para adicionar um elemento na última posição do array, criamos o método addElementToArray() que aceita um elemento int como parâmetro. Nesta função, primeiro verificamos se o size e capacity do array são iguais.

Se for verdade, chamamos a função boostArraySize() porque o array está cheio. No método boostArraySize(), criamos um array int vazio tempArray para armazenar temporariamente os elementos do array e comparamos o size e a capacity. Inicializamos tempArray com um array e definimos seu tamanho duas vezes a capacidade atual do array.

Em aumentarArraySize(), verificamos se a capacity é maior ou igual a 0. Então chamamos o método System.arraycopy() que copia os elementos de um array para outro array. Lá, especificamos o array a ser copiado, o índice inicial a ser copiado, o array onde queremos copiar os elementos, a posição de destino e o tamanho do novo array que queremos. Depois de tudo isso, reinicializamos intArray com os elementos de tempArray e aumentamos o tamanho de capacity.

Agora, criamos um método para remover o elemento e o nomeamos removeElement(). Nesta função, verificamos o size do array se for maior que zero. Em seguida, substituímos o último elemento do array por um zero e diminuímos o tamanho em um. Observe que este método remove apenas o último elemento do array.

Quando a matriz está cheia, a capacidade dessa matriz é aumentada e os espaços vazios são preenchidos. Esses espaços vazios e não utilizados podem aumentar o uso e o lixo de memória. Para corrigir isso, removemos os índices vazios usando a função shrinkSize(). Aqui, criamos um array temporário e copiamos todos os elementos de intArray na função, cujo tamanho é igual ao de seus elementos, e então copiamos os elementos do array de volta para intArray.

class DynamicArrayTest {
  int[] intArray;
  int size;
  int capacity;

  public DynamicArrayTest() {
    intArray = new int[2];
    size = 0;
    capacity = 2;
  }

  public void addElementToArray(int a) {
    if (size == capacity) {
      increaseArraySize();
    }
    intArray[size] = a;
    size++;
  }

  public void increaseArraySize() {
    int[] tempArray = null;
    if (size == capacity) {
      tempArray = new int[capacity * 2];
      {
        if (capacity >= 0) {
          System.arraycopy(intArray, 0, tempArray, 0, capacity);
        }
      }
    }
    intArray = tempArray;
    capacity = capacity * 2;
  }

  public void shrinkSize() {
    int[] temp;
    if (size > 0) {
      temp = new int[size];
      System.arraycopy(intArray, 0, temp, 0, size);
      capacity = size;
      intArray = temp;
    }
  }

  public void removeElement() {
    if (size > 0) {
      intArray[size - 1] = 0;
      size--;
    }
  }
}

public class DynamicArray {
  public static void main(String[] args) {
    DynamicArrayTest dynamicArrayTest = new DynamicArrayTest();

    dynamicArrayTest.addElementToArray(10);
    dynamicArrayTest.addElementToArray(20);
    dynamicArrayTest.addElementToArray(30);
    dynamicArrayTest.addElementToArray(40);
    dynamicArrayTest.addElementToArray(50);

    System.out.println("items of intArray:");

    for (int i = 0; i < dynamicArrayTest.capacity; i++) {
      System.out.print(dynamicArrayTest.intArray[i] + " ");
    }

    System.out.println();

    System.out.println("Capacity of the intArray: " + dynamicArrayTest.capacity);
    System.out.println("Size of the intArray: " + dynamicArrayTest.size);

    dynamicArrayTest.removeElement();

    System.out.println("\nItems after removing the last element");

    for (int i = 0; i < dynamicArrayTest.capacity; i++) {
      System.out.print(dynamicArrayTest.intArray[i] + " ");
    }

    System.out.println("\nCapacity of the intArray: " + dynamicArrayTest.capacity);
    System.out.println("Size of the intArray: " + dynamicArrayTest.size);

    dynamicArrayTest.shrinkSize();

    System.out.println("\nItems after removing unused space");

    for (int i = 0; i < dynamicArrayTest.capacity; i++) {
      System.out.print(dynamicArrayTest.intArray[i] + " ");
    }

    System.out.println("\nCapacity of the intArray: " + dynamicArrayTest.capacity);
    System.out.println("Size of the intArray: " + dynamicArrayTest.size);
  }
}

Resultado:

items of intArray:
10 20 30 40 50 0 0 0 
Capacity of the intArray: 8
Size of the intArray: 5

Items after removing the last element
10 20 30 40 0 0 0 0 
Capacity of the intArray: 8
Size of the intArray: 4

Items after removing unused space
10 20 30 
Capacity of the intArray: 3
Size of the intArray: 3