Augmenter la taille d'un tableau en Java

1. Augmenter la taille d’un tableau en créant un autre nouveau tableau en Java
2. Augmenter la taille du tableau à l’aide de la méthode Arrays.copyOf() en Java
3. Augmenter la taille du tableau à l’aide du tableau ArrayList en Java
4. Augmenter la taille du tableau en Java

Ce tutoriel présente comment augmenter la taille d’un tableau en Java. Vous avez également quelques exemples de codes pour vous aider à comprendre le sujet.

Un tableau en Java est une collection finie de données du même type. Les tableaux sont de taille fixe, et leur longueur ne peut pas être modifiée après leur création. C’est parce que les tableaux sont stockés en mémoire sous forme de blocs de données contigus.

L’utilisateur doit prédéfinir leur taille pour s’assurer que la quantité de mémoire requise est disponible de manière contiguë. Dans ce guide, vous connaîtrez les différentes manières de résoudre le problème de la longueur fixe des tableaux.

Voyons d’abord ce qui se passe lorsque nous essayons d’ajouter des éléments à un tableau sans espace supplémentaire. Nous ajoutons généralement des éléments à un tableau en accédant à son index. Si nous essayons d’ajouter un élément à un tableau déjà plein en utilisant l’index suivant, Java renverra une ArrayIndexOutOfBoundsException.

Le code suivant est un exemple d’un tel scénario.

public class Main {
  public static void main(String[] args) {
    int[] arr = new int[3];
    arr[0] = 5;
    arr[1] = 10;
    arr[2] = 15;
    arr[3] = 20; // Index 3 is out of bounds
  }
}

Production:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
    at abc.Demo.main(Demo.java:13)

Essayons maintenant de comprendre comment surmonter ce problème.

Augmenter la taille d’un tableau en créant un autre nouveau tableau en Java

Une solution simple à la taille fixe du tableau consiste à créer un autre tableau avec une taille plus grande.

Nous pouvons utiliser une variable compteur pour garder une trace du nombre d’éléments insérés dans le tableau. Chaque fois que ce nombre devient égal à la longueur du tableau (indiquant que le tableau est plein), nous pouvons créer un nouveau tableau d’une taille plus grande que le tableau d’origine.

Ensuite, nous transférerons tous les éléments du tableau d’origine vers le nouveau tableau et nous aurons toujours un espace supplémentaire pour un nouvel élément. Nous pouvons répéter ce processus si nous recevons un nouvel élément et que nous n’avons pas assez d’espace pour cela.

Considérons le code suivant où nous créons un tableau de longueur 5 et essayons d’y insérer des éléments 7. Chaque fois que le tableau est plein, nous augmentons sa taille en utilisant notre méthode increaseSize().

public class Main {
  public static int[] increaseSize(int[] arr) {
    int[] newArr = new int[arr.length + 1]; // Creating a new array with space for an extra element
    for (int i = 0; i < arr.length; i++) {
      newArr[i] = arr[i]; // Copying the elements to the new array
    }
    return newArr;
  }
  public static void main(String[] args) {
    int[] arr = new int[5];
    int counter = 0;
    for (int i = 0; i <= 6; i++) {
      if (counter == arr.length) {
        arr = increaseSize(arr);
      }
      arr[i] = i * 2;
      counter += 1;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
  }
}

Production:

0 2 4 6 8 10 12

Augmenter la taille du tableau à l’aide de la méthode Arrays.copyOf() en Java

Java a une méthode copyOf() intégrée qui peut créer un nouveau tableau de plus grande taille et copier nos anciens éléments de tableau dans le nouveau.

La fonction copyOf() appartient à la classe Arrays. La syntaxe de cette méthode est indiquée ci-dessous. Il renvoie un tableau de la longueur mentionnée qui contient tous les éléments du tableau d’origine.

copyOf(originalArray, newLength)

Le code suivant est similaire à celui mentionné ci-dessus. La seule différence est que nous utilisons la méthode copyOf au lieu de la méthode increaseSize().

import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    int[] arr = new int[5];
    int counter = 0;
    for (int i = 0; i <= 6; i++) {
      if (counter == arr.length) {
        int[] newArr = Arrays.copyOf(arr, arr.length + 1);
        arr = newArr;
      }
      arr[i] = i * 2;
      counter += 1;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
  }
}

Production:

0 2 4 6 8 10 12

Augmenter la taille du tableau à l’aide du tableau ArrayList en Java

Un ArrayList est un tableau dynamique présent dans le package java.util et implémente l’interface List. Contrairement à un tableau normal, un ArrayList a une longueur variable.

Java gère automatiquement la taille de ce tableau dynamique et nous n’avons pas à nous soucier de manquer d’espace dans le tableau. Sa taille par défaut est 10 éléments, mais sa taille augmentera si d’autres éléments sont ajoutés.

Le tableau ci-dessous explique certaines des principales différences entre un tableau et une ArrayList.

Le code suivant explique comment utiliser ArrayLists et effectuer des opérations de base telles que l’ajout d’un élément, la modification d’un élément et l’impression des valeurs de la liste.

import java.util.ArrayList;
public class Main {
  public static void main(String[] args) { // Creating a new ArrayList to hold Integer values
    ArrayList<Integer> arrList = new ArrayList<Integer>();
    // Adding elements 5, 10, 15 and 20 to the ArrayList
    arrList.add(5);
    arrList.add(10);
    arrList.add(15);
    arrList.add(20);
    // Printing the ArrayList
    System.out.println(arrList);
    // Adding an element 7 at index 2. This will shift the rest of the elements one place to the
    // right
    arrList.add(2, 7);
    System.out.println(arrList);
    // Fetching the element at index 3
    System.out.println(arrList.get(3));
    // Changing the element present at index 1 to 17
    arrList.set(1, 17);
    System.out.println(arrList);
  }
}

Production:

[5, 10, 15, 20]
[5, 10, 7, 15, 20]
15
[5, 17, 7, 15, 20]

Le scénario où nous essayions d’ajouter 7 éléments à un tableau de longueur 5 peut facilement être résolu en utilisant ArrayLists. Rappelez-vous que nous ne pouvons pas utiliser de types de données primitifs comme int dans ArrayLists, nous utilisons donc la classe wrapper, Integer.

import java.util.ArrayList;
public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> arrList = new ArrayList<Integer>();
    for (int i = 0; i <= 6; i++) {
      arrList.add(i * 2);
    }
    for (int i = 0; i < arrList.size(); i++) {
      System.out.print(arrList.get(i) + " ");
    }
  }
}

Production:

0 2 4 6 8 10 12

Augmenter la taille du tableau en Java

Un tableau est une structure de données basique mais extrêmement importante et utile. Une limitation des tableaux est qu’ils sont de taille fixe et que leur taille ne peut pas augmenter dynamiquement.

Dans ce tutoriel, nous avons appris à augmenter la taille d’un tableau. Nous pouvons créer un nouveau tableau de plus grande taille et copier le contenu de l’ancien tableau dans le nouveau. La solution la meilleure et la plus simple consiste à utiliser des ArrayLists car elles peuvent augmenter dynamiquement leur taille.

Nous espérons que ce guide vous a été très utile et que vous avez appris quelque chose de nouveau en Java.