Crea un array dinamico in Java

Un array è una struttura di dati a dimensione fissa la cui dimensione non può essere modificata una volta dichiarata. Un array dinamico ci fornisce la possibilità di creare array di dimensioni dinamiche. Possiamo aumentare e diminuire queste dimensioni di conseguenza e discuteremo su come creare un array dinamico Java in questo articolo.

Crea un array dinamico utilizzando la logica personalizzata in Java

Nell’esempio, usiamo la logica personalizzata che include metodi per aggiungere un elemento alla fine dell’array o in qualsiasi indice. Quando l’array è pieno, la dimensione dell’array aumenta di due volte. Rimuoviamo e riduciamo anche l’array nel processo.

Usiamo due classi per testare la logica dell’array dinamico; la prima è la classe DynamicClass e la seconda è la classe DynamicArrayTest. Nel DynamicArrayTest, creiamo un array di tipo int intArray e due variabili int denominate size e capacity. La dimensione dell’array è il numero di elementi in esso contenuti e la capacità di un array è lo spazio totale al suo interno.

Creiamo un costruttore della classe DynamicArrayTest e inizializziamo intArray con un array int della dimensione 2. Quindi, inizializziamo la size con 0 e capacity come 2. Infine, per aggiungere un elemento nell’ultima posizione dell’array, creiamo il metodo addElementToArray() che accetta un elemento int come parametro. In questa funzione, controlliamo prima se la size e la capacity dell’array sono le stesse.

Se è vero, chiamiamo la funzione increaseArraySize() perché l’array è pieno. Nel metodo increaseArraySize(), creiamo un array int vuoto tempArray per memorizzare temporaneamente gli elementi dell’array e confrontiamo size e capacity. Inizializziamo tempArray con un array e impostiamo la sua dimensione al doppio della capacità attuale dell’array.

In increaseArraySize(), controlliamo se la capacity è maggiore o uguale a 0. Quindi chiamiamo il metodo System.arraycopy() che copia gli elementi di un array in un altro array. Lì, specifichiamo l’array da copiare, l’indice iniziale da copiare, l’array in cui vogliamo copiare gli elementi, la posizione di destinazione e la dimensione del nuovo array che vogliamo. Dopo tutto ciò, reinizializziamo intArray con gli elementi di tempArray e aumentiamo la dimensione di capacity.

Ora creiamo un metodo per rimuovere l’elemento e lo chiamiamo removeElement(). In questa funzione, controlliamo la size dell’array se è maggiore di zero. Quindi, sostituiamo l’ultimo elemento dell’array con uno zero e riduciamo la dimensione di uno. Si noti che questo metodo rimuove solo l’ultimo elemento dell’array.

Quando l’array è pieno, la capacità di quell’array viene aumentata e gli spazi vuoti vengono riempiti. Questi spazi vuoti e inutilizzati possono aumentare l’utilizzo della memoria e i rifiuti di memoria. Per risolvere questo problema, rimuoviamo gli indici vuoti utilizzando la funzione shrinkSize(). Qui creiamo un array temporaneo e copiamo tutti gli elementi di intArray nella funzione, la cui dimensione è la stessa dei suoi elementi, quindi ricopiamo gli elementi dell’array in 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);
  }
}

Produzione:

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