Les tableaux en Java

Tableaux en Java

  Prérequis

Maîtriser les variables, les types de données primitifs et les références. Comprendre les boucles for et for-each. Connaître les bases de la déclaration de méthodes.

  Objectifs

Comprendre la notion de tableau comme structure de données homogène. Maîtriser la déclaration, la création, l'initialisation et l'accès aux tableaux à une et deux dimensions. Savoir parcourir, passer et retourner des tableaux dans des méthodes. Connaître les particularités des tableaux irréguliers (ragged arrays).

1. Qu'est-ce qu'un tableau ?

2. Tableaux à une dimension (1D)

2.1 Déclaration d'un tableau

Vous déclarez un tableau de la même manière qu'une variable simple, mais vous insérez une paire de crochets après le type de données (style recommandé).

typeDonnee[] nomTableau;   // style recommandé
// ou
typeDonnee nomTableau[];   // style C (déconseillé)

  Exemple 1 — Déclaration

double[] tarifs;
String[] noms;
Etudiant[] listeEtudiants;   // tableau d'objets

2.2 Création d'un tableau (réservation mémoire)

Déclarer un tableau et lui réserver de la mémoire sont deux processus distincts. La déclaration crée une référence null ; la création avec new alloue la mémoire.

nomTableau = new typeDonnee[taille];
// ou en une seule instruction
typeDonnee[] nomTableau = new typeDonnee[taille];

  Exemple 2 — Création en deux étapes

Etudiant[] listeEtudiants;           // déclaration (null)
listeEtudiants = new Etudiant[20];   // création (20 références null)

  Exemple 3 — Déclaration et création en une instruction

int[] notes = new int[30];
String[] villes = new String[10];
double[] coefficients = new double[5];

2.3 Indices (index)

  Exemple 4 — Accès aux éléments

int[] notes = new int[5];
notes[0] = 15;    // premier élément (indice 0)
notes[1] = 12;    // deuxième élément
notes[4] = 18;    // dernier élément (indice 4)

System.out.println("Longueur : " + notes.length);  // 5

2.4 Initialisation des tableaux

Lors de la création, les éléments reçoivent des valeurs par défaut :

L'initialisation explicite avec une liste de valeurs :

typeDonnee[] nomTableau = {valeur1, valeur2, ..., valeurN};

  Exemple 5 — Initialisation à la déclaration

int[] nombres = {2, 5, 3, 7, 6, 8, 9, 10, 13};
String[] jours = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi"};
char[] voyelles = {'A', 'E', 'I', 'O', 'U', 'Y'};

2.5 Parcours des tableaux

  Exemple 6 — Boucle for classique

public class TestFor {
    public static void main(String[] args) {
        int[] nombres = {3, 5, 6, 8, 6, 7, 18, 19};

        for (int i = 0; i < nombres.length; i++) {
            System.out.println("Élément " + i + " : " + nombres[i]);
        }
    }
}

Élément 0 : 3
Élément 1 : 5
Élément 2 : 6
Élément 3 : 8
Élément 4 : 6
Élément 5 : 7
Élément 6 : 18
Élément 7 : 19

  Exemple 7 — Boucle for-each (améliorée)

public class TestForeach {
    public static void main(String[] args) {
        double[] valeurs = {3.6, 5.0, 6, 8, 6, 7.76, 18, 19.5};

        // for-each : plus lisible, mais sans accès à l'indice
        for (double val : valeurs) {
            System.out.println(val);
        }
    }
}

3.6
5.0
6.0
8.0
6.0
7.76
18.0
19.5

2.6 Passage de tableaux à une méthode

Les tableaux étant des objets, leur référence est passée par valeur (copie de la référence). La méthode peut donc modifier les éléments du tableau.

  Exemple 8 — Passage de tableau

public class Test {
    public void afficher(int[] tab) {
        for (int elem : tab) {
            System.out.print(elem + " ");
        }
        System.out.println();
    }

    public void doubler(int[] tab) {
        for (int i = 0; i < tab.length; i++) {
            tab[i] *= 2;   // modification des éléments
        }
    }

    public static void main(String[] args) {
        int[] nombres = {3, 5, 6, 8};

        Test t = new Test();
        t.afficher(nombres);   // 3 5 6 8
        t.doubler(nombres);
        t.afficher(nombres);   // 6 10 12 16
    }
}

2.7 Retourner un tableau depuis une méthode

Une méthode peut renvoyer une référence à un tableau. Le type de retour inclut les crochets.

  Exemple 9 — Retour d'un tableau

public class Test {
    public int[] inverser(int[] tab) {
        int taille = tab.length;
        int[] resultat = new int[taille];

        for (int i = 0; i < taille; i++) {
            resultat[i] = tab[taille - 1 - i];
        }
        return resultat;
    }

    public static void main(String[] args) {
        int[] nombres = {3, 5, 6, 8, 6, 7, 18};
        Test t = new Test();
        int[] inverse = t.inverser(nombres);

        for (int val : inverse) {
            System.out.print(val + " ");
        }
        // Sortie : 18 7 6 8 6 5 3
    }
}

3. Tableaux à deux dimensions (2D)

3.1 Déclaration et création

typeDonnee[][] nomTableau = new typeDonnee[nbLignes][nbColonnes];

  Exemple 10 — Création d'une matrice

int[][] matrice = new int[3][4];        // 3 lignes × 4 colonnes
String[][] grille = new String[8][8];   // grille 8×8
double[][] notes = new double[10][5];   // 10 étudiants, 5 matières

3.2 Initialisation d'un tableau 2D

  Exemple 11 — Initialisation explicite

int[][] matrice = {
    {0, 1, 2, 3},
    {4, 5, 6, 7},
    {8, 9, 10, 11}
};

// Accès aux éléments
matrice[0][0] = 14;   // première ligne, première colonne
matrice[1][2] = 99;   // deuxième ligne, troisième colonne

3.3 Parcours d'un tableau 2D

  Exemple 12 — Parcours avec boucles imbriquées

public class Test {
    public void afficher(int[][] tab) {
        for (int i = 0; i < tab.length; i++) {           // parcours des lignes
            for (int j = 0; j < tab[i].length; j++) {    // parcours des colonnes
                System.out.print(tab[i][j] + " ");
            }
            System.out.println();  // nouvelle ligne
        }
    }

    public static void main(String[] args) {
        int[][] matrice = {
            {0, 1, 2, 3},
            {4, 5, 6, 7},
            {8, 9, 10, 11}
        };

        Test t = new Test();
        t.afficher(matrice);
    }
}

0 1 2 3
4 5 6 7
8 9 10 11

3.4 Passage d'un tableau 2D à une méthode

  Exemple 13 — Méthode recevant un tableau 2D

public class Test {
    public void afficher(int[][] tab) {
        for (int i = 0; i < tab.length; i++) {
            for (int j = 0; j < tab[i].length; j++) {
                System.out.println("tab[" + i + "][" + j + "] = " + tab[i][j]);
            }
        }
    }

    public static void main(String[] args) {
        int[][] nums = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}};
        new Test().afficher(nums);
    }
}

4. Tableaux irréguliers (Ragged Arrays)

  Exemple 14 — Création d'un tableau irrégulier

// Étape 1 : déclarer le nombre de lignes (colonnes non définies)
int[][] triangle = new int[5][];

// Étape 2 : créer chaque ligne avec sa propre longueur
triangle[0] = new int[1];   // ligne 0 : 1 élément
triangle[1] = new int[2];   // ligne 1 : 2 éléments
triangle[2] = new int[3];   // ligne 2 : 3 éléments
triangle[3] = new int[4];   // ligne 3 : 4 éléments
triangle[4] = new int[5];   // ligne 4 : 5 éléments

// Remplir le triangle
for (int i = 0; i < triangle.length; i++) {
    for (int j = 0; j < triangle[i].length; j++) {
        triangle[i][j] = i + j;
    }
}

  Exemple 15 — Initialisation directe d'un tableau irrégulier

int[][] triangle = {
    {0},
    {0, 1},
    {0, 1, 2},
    {0, 1, 2, 3},
    {0, 1, 2, 3, 4}
};

for (int i = 0; i < triangle.length; i++) {
    for (int j = 0; j < triangle[i].length; j++) {
        System.out.print(triangle[i][j] + " ");
    }
    System.out.println();
}

0
0 1
0 1 2
0 1 2 3
0 1 2 3 4

5. Tableaux d'objets

Un tableau peut contenir des références vers des objets. Chaque élément est initialisé à null.

  Exemple 16 — Tableau d'étudiants

class Etudiant {
    private String nom;
    private double moyenne;

    public Etudiant(String nom, double moyenne) {
        this.nom = nom;
        this.moyenne = moyenne;
    }

    public void afficher() {
        System.out.println(nom + " : " + moyenne);
    }
}

public class Test {
    public static void main(String[] args) {
        // Déclaration et création du tableau (tous null)
        Etudiant[] promo = new Etudiant[3];

        // Création des objets individuels
        promo[0] = new Etudiant("Mostafa", 16.5);
        promo[1] = new Etudiant("Amal", 18.0);
        promo[2] = new Etudiant("Youssef", 14.5);

        // Parcours
        for (Etudiant e : promo) {
            e.afficher();
        }
    }
}

6. Tableau comparatif des types de tableaux

7. Exercice

import java.util.Arrays;
import java.util.Random;

public class AnalyseTableau {

    public static int somme(int[] tab) {
        int somme = 0;
        for (int val : tab) {
            somme += val;
        }
        return somme;
    }

    public static double moyenne(int[] tab) {
        if (tab.length == 0) return 0;
        return (double) somme(tab) / tab.length;
    }

    public static int max(int[] tab) {
        if (tab.length == 0) throw new IllegalArgumentException("Tableau vide");
        int max = tab[0];
        for (int val : tab) {
            if (val > max) max = val;
        }
        return max;
    }

    public static int min(int[] tab) {
        if (tab.length == 0) throw new IllegalArgumentException("Tableau vide");
        int min = tab[0];
        for (int val : tab) {
            if (val < min) min = val;
        }
        return min;
    }

    public static int[] compterFrequences(int[] tab, int maxValeur) {
        int[] frequences = new int[maxValeur + 1];
        for (int val : tab) {
            if (val >= 0 && val <= maxValeur) {
                frequences[val]++;
            }
        }
        return frequences;
    }

    public static void afficherFrequences(int[] frequences) {
        System.out.println("\n--- Fréquences ---");
        for (int i = 0; i < frequences.length; i++) {
            if (frequences[i] > 0) {
                System.out.printf("Valeur %2d : %d fois%n", i, frequences[i]);
            }
        }
    }

    public static void main(String[] args) {
        Random rand = new Random();
        int[] tableau = new int[20];

        // Remplissage avec valeurs aléatoires entre 1 et 100
        for (int i = 0; i < tableau.length; i++) {
            tableau[i] = rand.nextInt(100) + 1;
        }

        System.out.println("Tableau généré :");
        System.out.println(Arrays.toString(tableau));

        System.out.println("\n--- Statistiques ---");
        System.out.println("Somme     : " + somme(tableau));
        System.out.printf("Moyenne   : %.2f%n", moyenne(tableau));
        System.out.println("Maximum   : " + max(tableau));
        System.out.println("Minimum   : " + min(tableau));

        // Comptage des fréquences (valeurs entre 1 et 100)
        int[] frequences = compterFrequences(tableau, 100);
        afficherFrequences(frequences);
    }
}

Tableau généré :
[45, 23, 78, 12, 89, 34, 56, 91, 23, 45, 67, 45, 89, 12, 34, 56, 78, 90, 23, 45]

--- Statistiques ---
Somme     : 1092
Moyenne   : 54,60
Maximum   : 91
Minimum   : 12

--- Fréquences ---
Valeur 12 : 2 fois
Valeur 23 : 3 fois
Valeur 34 : 2 fois
Valeur 45 : 4 fois
Valeur 56 : 2 fois
Valeur 67 : 1 fois
Valeur 78 : 2 fois
Valeur 89 : 2 fois
Valeur 90 : 1 fois
Valeur 91 : 1 fois

  L'essentiel en bref