Créer un tableau dynamique en Java

Un tableau est une structure de données de taille fixe dont la taille ne peut pas être modifiée une fois déclarée. Un tableau dynamique nous permet de créer des tableaux de tailles dynamiques. Nous pouvons augmenter et diminuer ces tailles en conséquence avec, et nous allons discuter de la façon de créer un tableau dynamique Java dans cet article.

Créer un tableau dynamique à l’aide de la logique personnalisée en Java

Dans l’exemple, nous utilisons une logique personnalisée qui inclut des méthodes pour ajouter un élément à la fin du tableau ou à n’importe quel index. Lorsque le tableau est plein, la taille du tableau augmente deux fois. Nous supprimons et réduisons également le tableau dans le processus.

Nous utilisons deux classes pour tester la logique du tableau dynamique ; la première est la classe DynamicClass et la seconde est la classe DynamicArrayTest. Dans le DynamicArrayTest, nous créons un tableau de type int intArray et deux variables int nommées size et capacity. La taille du tableau correspond au nombre d’éléments qu’il contient et la capacité d’un tableau correspond à l’espace total qu’il contient.

Nous créons un constructeur de la classe DynamicArrayTest et initialisons intArray avec un tableau int de taille 2. Ensuite, nous initialisons la size avec 0 et la capacity avec 2. Enfin, pour ajouter un élément à la dernière position du tableau, nous créons la méthode addElementToArray() qui accepte un élément int en paramètre. Dans cette fonction, nous vérifions d’abord si la size et la capacity du tableau sont les mêmes.

Si c’est vrai, nous appelons la fonction increaseArraySize() car le tableau est plein. Dans la méthode increaseArraySize(), on crée un tableau int vide tempArray pour stocker temporairement les éléments du tableau et on compare la size et la capacity. Nous initialisons tempArray avec un tableau et définissons sa taille au double de la capacité actuelle du tableau.

Dans increaseArraySize(), on vérifie si la capacity est supérieure ou égale à 0. Ensuite, nous appelons la méthode System.arraycopy() qui copie les éléments d’un tableau dans un autre tableau. Là, nous spécifions le tableau à copier, l’index de départ à copier, le tableau où nous voulons copier les éléments, la position de destination et la taille du nouveau tableau que nous voulons. Après tout cela, nous réinitialisons intArray avec les éléments de tempArray et augmentons la taille de capacity.

Maintenant, nous créons une méthode pour supprimer l’élément et le nommons removeElement(). Dans cette fonction, on vérifie la size du tableau si elle est supérieure à zéro. Ensuite, nous remplaçons le dernier élément du tableau par un zéro, et nous diminuons la taille d’un. Notez que cette méthode supprime uniquement le dernier élément du tableau.

Lorsque la baie est pleine, la capacité de cette baie est augmentée et les espaces vides sont remplis. Ces espaces vides et inutilisés peuvent augmenter l’utilisation de la mémoire et les déchets de mémoire. Pour résoudre ce problème, nous supprimons les index vides à l’aide de la fonction shrinkSize(). Ici, nous créons un tableau temporaire et copions tous les éléments de intArray dans la fonction, dont la taille est la même que ses éléments, puis copions les éléments du tableau dans 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);
  }
}

Production:

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