Erstellen Sie ein dynamisches Array in Java

Ein Array ist eine Datenstruktur mit fester Größe, deren Größe nach der Deklaration nicht mehr geändert werden kann. Ein dynamisches Array bietet uns die Möglichkeit, Arrays dynamischer Größen zu erstellen. Wir können diese Größen entsprechend erhöhen und verringern, und wir werden in diesem Artikel erörtern, wie ein dynamisches Java-Array erstellt wird.

Erstellen Sie ein dynamisches Array mit benutzerdefinierter Logik in Java

Im Beispiel verwenden wir benutzerdefinierte Logik, die Methoden zum Hinzufügen eines Elements am Ende des Arrays oder an einem beliebigen Index enthält. Wenn das Array voll ist, erhöht sich die Array-Größe um das Doppelte. Dabei entfernen und verkleinern wir auch das Array.

Wir verwenden zwei Klassen, um die dynamische Array-Logik zu testen; die erste ist die DynamicClass und die zweite ist die DynamicArrayTest-Klasse. Im DynamicArrayTest erstellen wir ein Array vom Typ int intArray und zwei int-Variablen namens size und capacity. Die Array-Größe ist die Anzahl der darin enthaltenen Elemente, und die Kapazität eines Arrays ist der Gesamtplatz darin.

Wir erstellen einen Konstruktor der Klasse DynamicArrayTest und initialisieren intArray mit einem int-Array der Grösse 2. Dann initialisieren wir size mit 0 und capacity mit 2. Um schließlich ein Element an der letzten Position des Arrays hinzuzufügen, erstellen wir die Methode addElementToArray(), die ein int-Element als Parameter akzeptiert. In dieser Funktion prüfen wir zunächst, ob size und Kapazität des Arrays gleich sind.

Wenn es wahr ist, rufen wir die Funktion increaseArraySize() auf, weil das Array voll ist. In der Methode increaseArraySize() erstellen wir ein leeres int-Array tempArray zum Zwischenspeichern der Array-Elemente und vergleichen size und capacity. Wir initialisieren tempArray mit einem Array und setzen dessen Größe auf das Doppelte der aktuellen Kapazität des Arrays.

In increaseArraySize() prüfen wir, ob die Kapazität grösser oder gleich 0 ist. Dann rufen wir die Methode System.arraycopy() auf, die die Elemente eines Arrays in ein anderes Array kopiert. Dort geben wir das zu kopierende Array, den zu kopierenden Startindex, das Array, in das wir die Elemente kopieren möchten, die Zielposition und die Größe des neuen Arrays an, das wir kopieren möchten. Danach initialisieren wir intArray mit den Elementen von tempArray neu und vergrößern capacity.

Nun erstellen wir eine Methode zum Entfernen des Elements und nennen es removeElement(). In dieser Funktion prüfen wir die size des Arrays, wenn sie grösser als Null ist. Dann ersetzen wir das letzte Element des Arrays durch eine Null und verkleinern die Größe um eins. Beachten Sie, dass diese Methode nur das letzte Element des Arrays entfernt.

Wenn das Array voll ist, wird die Kapazität dieses Arrays erhöht und leere Räume werden gefüllt. Diese leeren, ungenutzten Bereiche können die Speichernutzung und den Speichermüll erhöhen. Um dies zu beheben, entfernen wir die leeren Indizes mit der Funktion shrinkSize(). Hier erstellen wir ein temporäres Array und kopieren alle Elemente von intArray in die Funktion, deren Größe der ihrer Elemente entspricht, und kopieren dann die Array-Elemente zurück nach 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);
  }
}

Ausgabe:

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