---

Utilisation de Arrays.copyOf()

copyOf() est une méthode utilitaire de la classe java.util.Arrays qui permet de copier un tableau (ou une partie d’un tableau) dans un nouveau tableau.

• Elle est particulièrement utile pour :

• Créer une copie indépendante d’un tableau existant (pour éviter les modifications involontaires du tableau original).
• Redimensionner un tableau (en augmentant ou en réduisant sa taille).
• Extraire une partie d’un tableau (en spécifiant une nouvelle longueur).

Syntaxe : type[] nouveauTableau = Arrays.copyOf(tableauOriginal, nouvelleLongueur);

• tableauOriginal : votre tableau à copier

• nouvelleLongueur : longueur du nouveau tableau.

• si nouvelleLongueur > longueur originale, les éléments supplémentaires sont initialisés à 0 (pour les types numériques), false (pour les booléens), et null (pour les objets comme les String).
• si nouvelleLongueur < longueur originale, seuls les premiers éléments selon la longueur définie seront copiés.

Comment ça marche ?

Copie complète d’un tableau

Si on souhaite créer une copie exacte d’un tableau (avec la même taille), on utilise la longueur originale du tableau.

Exemple :

int[] original = {10, 20, 30, 40, 50};
int[] copie = Arrays.copyOf(original, original.length);
// copie = [10, 20, 30, 40, 50]

Redimensionner un tableau

Si on veut agrandir ou réduire un tableau, il faut spécifier une nouvelle longueur.

Exemple 1 : Agrandir un tableau

int[] original = {10, 20, 30};
int[] agrandi = Arrays.copyOf(original, 5);
// agrandi = [10, 20, 30, 0, 0]  (les nouveaux éléments sont initialisés à 0)

Exemple 2 : Réduire un tableau

int[] original = {10, 20, 30, 40, 50};
int[] reduit = Arrays.copyOf(original, 3);
// reduit = [10, 20, 30]  (les éléments au-delà de l'index 2 sont ignorés)

Copier une partie d’un tableau

Si on veut copier un sous-ensemble d’un tableau, il faut utiliser Arrays.copyOfRange() (variante de copyOf).

Exemple :

int[] original = {10, 20, 30, 40, 50};
int[] sousTableau = Arrays.copyOfRange(original, 1, 4);
// le sousTableau = [20, 30, 40]  (copie des éléments de l'index 1 à 3)

Pourquoi utiliser Arrays.copyOf() ?

Eviter les modifications involontaires

En Java, les tableaux sont des objets mutables. Si on assigne un tableau à une nouvelle variable, les 2 variables pointentt le même objet en mémoire. Toute modification de l’un affecte l’autre ! Nous en avons parlé cette semaine sur le passage par valeur et par référence.

• Exemple sans copyOf (problème) :

int[] original = {10, 20, 30};
int[] copie = original;  // copie et original pointent vers le même tableau !
copie[0] = 100;
System.out.println(original[0]);  // il affichera la valeur 100 (modifié involontairement)

Solution avec copyOf :

```java
int[] original = {10, 20, 30};
int[] copie = Arrays.copyOf(original, original.length);  // copie indépendante
copie[0] = 100;
System.out.println(original[0]);  // affiche 10 (original non modifié)

Redimensionner dynamiquement votre tableau

Les tableaux ont une taille fixe. Mais grâce à Arrays.copyOf(), vous allez pouvoir créer un nouveau tableau avec une taille différente.

Exemple :

int[] tableau = {1, 2, 3};
tableau = Arrays.copyOf(tableau, tableau.length + 1);  // agrandit le tableau de 1 élément
tableau[3] = 4;  // tableau = [1, 2, 3, 4]

Extraire une sous-partie de votre tableau

Utile pour travailler sur un sous-ensemble de données sans modifier le tableau original. Déjà vu plus haut dans cette page.

Exemple :

int[] notes = {12, 15, 9, 14, 18, 7};
int[] meilleuresNotes = Arrays.copyOfRange(notes, 2, 5);
// meilleuresNotes = [9, 14, 18]  (notes de l'index 2 à 4)

Différence entre Arrays.copyOf() et System.arraycopy()

En java, il y a plusieurs moyens de manipuler des tableaux, voici un exemple avec des méthodes différentes.

Méthode	Description	Exemple
Arrays.copyOf()	Crée un nouveau tableau avec une longueur spécifiée.	int[] copie = Arrays.copyOf(original, nouvelleLongueur);
System.arraycopy()	Copie des éléments d’un tableau source vers un tableau destination (plus performant).	System.arraycopy(original, 0, destination, 0, longueur);

• Exemple avec System.arraycopy() :

int[] original = {10, 20, 30, 40};
int[] destination = new int[4];
System.arraycopy(original, 0, destination, 0, original.length);
// destination = [10, 20, 30, 40]

Récapitulatif des usages courants

• Copier un tableau pour le modifier sans altérer l’original
• Agrandir un tableau dynamiquement
• Créer une copie tronquée
• Initialiser un nouveau tableau avec des valeurs par défaut

Exemple Complet

import java.util.Arrays;

public class ExempleCopyOf {
    public static void main(String[] args) {
        // original
        int[] original = {10, 20, 30, 40, 50};
        System.out.println("tb original : " + Arrays.toString(original));

        // copie complète
        int[] copieComplete = Arrays.copyOf(original, original.length);
        System.out.println("tb avec copie complète : " + Arrays.toString(copieComplete));

        // copie tronquée
        int[] copieTronquee = Arrays.copyOf(original, 3);
        System.out.println("tb avec copie tronquée : " + Arrays.toString(copieTronquee));

        // la copie agrandie
        int[] copieAgrandie = Arrays.copyOf(original, 7);
        System.out.println("tp avec copie agrandie : " + Arrays.toString(copieAgrandie));

        // avec modif de la copie (sans affecter original)
        copieComplete[0] = 100;
        System.out.println("tb original après modification de la copie : " + Arrays.toString(original));
    }
}

Sortie :

tb original : [10, 20, 30, 40, 50]
tb avec copie complète : [10, 20, 30, 40, 50]
tb avec copie tronquée : [10, 20, 30]
tp avec copie agrandie : [10, 20, 30, 40, 50, 0, 0]
tb original après modification de la copie : [10, 20, 30, 40, 50]