Module 4

Tableaux et Chaînes de Caractères

1. Tableaux Unidimensionnels : Stocker des Listes de Données

Pourquoi Utiliser des Tableaux ?

Imaginez que vous deviez stocker les notes de 30 étudiants. Devriez-vous créer 30 variables (note1, note2, note3...) ? Ce serait un cauchemar. Un tableau est la solution : c'est une structure qui peut contenir plusieurs valeurs du même type sous un seul nom de variable.

Anatomie d'un Tableau

La création d'un tableau se fait en trois étapes :

1. Déclaration

On déclare une variable qui pourra contenir un tableau.

int[] notes;

Crée une "télécommande" capable de piloter un tableau d'entiers.

2. Instantiation

On alloue de la mémoire pour le tableau avec une taille fixe.

notes = new int[30];

Crée un espace en mémoire pour 30 entiers.

3. Initialisation

On assigne des valeurs à chaque case du tableau.

Important : Taille Fixe

Un tableau en Java a une taille fixe. Une fois créé avec une taille de 30, il ne pourra jamais en contenir 31.

Exemple 1 : Déclaration, Instantiation et Initialisation

public class ArrayExample {
    public static void main(String[] args) {
        // Déclaration et instantiation en une seule ligne
        int[] numbers = new int[5];

        // L'accès aux éléments se fait par un "indice", qui commence TOUJOURS à 0
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        // numbers[5] = 60; // ERREUR ! ArrayIndexOutOfBoundsException

        // La propriété .length donne la taille totale du tableau
        System.out.println("La taille du tableau est : " + numbers.length);

        // Parcourir le tableau avec une boucle for classique
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Élément à l'indice " + i + ": " + numbers[i]);
        }
    }
}
            

Analogie : Les indices d'un tableau fonctionnent comme les étages d'un immeuble. Le rez-de-chaussée correspond à l'indice 0, le 1er étage à l'indice 1, etc.

Exemple 2 : Initialisation Directe et Boucle for-each

Vous pouvez initialiser un tableau directement avec ses valeurs si vous les connaissez à l'avance. Pour parcourir un tableau sans avoir besoin de l'indice, la boucle for-each est plus simple et plus lisible.

public class ArrayInitialization {
    public static void main(String[] args) {
        // Initialisation directe d'un tableau avec des valeurs
        String[] fruits = {"Pomme", "Banane", "Orange", "Fraise"};

        System.out.println("Liste des fruits :");
        // Boucle for-each : "Pour chaque String 'fruit' dans le tableau 'fruits'..."
        for (String fruit : fruits) {
            System.out.println("- " + fruit);
        }
    }
}
            

Résultat :

Liste des fruits :
- Pomme
- Banane
- Orange
- Fraise
            

Pour aller plus loin :

Source: EvoluNoob

2. Tableaux Multidimensionnels : Grilles et Matrices

Un tableau multidimensionnel est un tableau qui contient d'autres tableaux. Le plus courant est le tableau à deux dimensions (2D), que l'on peut voir comme une grille ou une matrice avec des lignes et des colonnes.

Concept Clé

Un tableau 2D en Java est un tableau de tableaux.

matrix.length = nombre de lignes (le nombre de tableaux internes)
matrix[0].length = nombre de colonnes de la première ligne

Exemple 3 : Créer et Parcourir une Matrice

public class TwoDimensionalArray {
    public static void main(String[] args) {
        // Déclaration et initialisation d'un tableau 2D
        int[][] matrix = {
            {1, 2, 3}, // Ligne à l'indice 0
            {4, 5, 6}, // Ligne à l'indice 1
            {7, 8, 9}  // Ligne à l'indice 2
        };

        System.out.println("Accès à un élément : " + matrix[1][2]);

        // Affichage de la matrice avec des boucles imbriquées
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
            

Résultat :

Accès à un élément : 6
 2   3
 5   6
 8   9
            

Analogie : Un tableau 2D est comme une grille de parking. matrix[1][2] signifie "rangée 1, place 2".

3. La Classe String : Plus qu'un Simple Texte

En Java, les chaînes de caractères ne sont pas des types primitifs. Ce sont des objets de la classe String, ce qui leur confère des propriétés et des méthodes très puissantes.

Le Concept d'Immuabilité

C'est la caractéristique la plus importante des String en Java : une chaîne est immuable (immutable). Une fois qu'un objet String est créé, sa valeur ne peut plus jamais être modifiée.

Analogie : Un String est comme un message gravé dans la pierre. Si vous voulez le "modifier" (par exemple, le mettre en majuscules), vous ne modifiez pas la pierre originale. Java crée une nouvelle pierre avec le message modifié.

String greeting = "Bonjour";
greeting.toUpperCase(); // Crée un NOUVEL objet "BONJOUR"
System.out.println(greeting); // Affiche toujours "Bonjour"

// Pour garder le changement, réassignez la référence :
greeting = greeting.toUpperCase();
System.out.println(greeting); // Affiche "BONJOUR"
            

Comparer des String : == vs .equals()

Erreur de Débutant la Plus Fréquente !

N'utilisez JAMAIS == pour comparer le contenu de deux chaînes.

→ == compare les références

Est-ce que les deux "télécommandes" pointent vers le même objet ?

→ .equals() compare le contenu

Est-ce que les séquences de caractères sont identiques ?

public class StringComparison {
    public static void main(String[] args) {
        String s1 = new String("Java");
        String s2 = new String("Java");

        System.out.println("Avec == : " + (s1 == s2));        // false !
        System.out.println("Avec .equals() : " + (s1.equals(s2))); // true
    }
}
            

Exemple 4 : Méthodes Utiles de la Classe String

public class StringExample {
    public static void main(String[] args) {
        String message = "  Java est un langage puissant !  ";

        // Inspection
        System.out.println("Longueur: " + message.length());
        System.out.println("Caractère à l'indice 3: " + message.charAt(3));

        // Manipulation (crée de nouvelles chaînes)
        System.out.println("En majuscules: " + message.toUpperCase());
        System.out.println("Sans espaces: '" + message.trim() + "'");
        System.out.println("Remplacement: " + message.replace("puissant", "versatile"));

        // Recherche
        System.out.println("Contient 'langage' ? " + message.contains("langage"));
        System.out.println("Index de 'est': " + message.indexOf("est"));
    }
}
            

Tableau des Principales Méthodes String

Méthode	Utilité	Exemple
length()	Longueur de la chaîne	"Java".length() → 4
charAt(i)	Caractère à l'indice i	"Java".charAt(0) → 'J'
toUpperCase()	Convertir en majuscules	"Java".toUpperCase() → "JAVA"
toLowerCase()	Convertir en minuscules	"Java".toLowerCase() → "java"
trim()	Supprimer espaces début/fin	" Java ".trim() → "Java"
contains()	Vérifie si contient sous-chaîne	"Java".contains("av") → true
indexOf()	Position de la sous-chaîne	"Java".indexOf("v") → 2

StringBuilder : Construire des Chaînes Efficacement

Puisque les String sont immuables, les modifier de manière répétée dans une boucle (par exemple, en concaténant avec +) est très inefficace, car cela crée des milliers d'objets intermédiaires.

Pour construire des chaînes de manière performante, utilisez la classe StringBuilder.

Analogie : StringBuilder est un "tableau blanc" sur lequel vous pouvez écrire, effacer et ajouter du texte facilement, avant de prendre une "photo" finale pour créer votre String.

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();

        builder.append("Bonjour");
        builder.append(" le monde");
        builder.append(" !");

        // Convertir le StringBuilder en String final
        String finalString = builder.toString();

        System.out.println(finalString);
    }
}
            

Résultat :

Bonjour le monde !

Pour aller plus loin :

Source: EvoluNoob

À Retenir

Utilisez StringBuilder quand :

Vous construisez une chaîne dans une boucle
Vous concaténez beaucoup de chaînes
Vous avez besoin de performance

Utilisez String quand :

Vous travaillez avec du texte fixe
Vous n'avez besoin de la modifier que quelques fois

Exercices Pratiques : Manipuler des Collections de Données

Ces exercices vous permettront de mettre en pratique la manipulation de tableaux et de chaînes de caractères, deux compétences fondamentales en programmation.

Exercice 1 : Somme et Moyenne d'un Tableau

Écrivez un programme qui déclare un tableau d'entiers (par exemple, les notes d'un étudiant -> 15, 12, 18, 9, 14). Le programme doit ensuite calculer et afficher la somme de tous les éléments du tableau, ainsi que leur moyenne.

Indice : Utilisez une boucle for-each pour parcourir le tableau et additionner chaque élément à une variable somme. La moyenne est simplement la somme divisée par le nombre d'éléments (tableau.length).

Voir la solution

public class CalculMoyenne {
    public static void main(String[] args) {
        int[] notes = {15, 12, 18, 9, 14};
        int somme = 0;

        // On parcourt chaque note dans le tableau
        for (int note : notes) {
            somme += note; // Équivalent à : somme = somme + note;
        }

        // On doit faire un cast en double pour avoir un résultat décimal
        double moyenne = (double) somme / notes.length;

        System.out.println("Les notes sont : 15, 12, 18, 9, 14");
        System.out.println("La somme des notes est : " + somme);
        System.out.println("La moyenne est : " + moyenne);
    }
}

Exercice 2 : Vérificateur de Palindrome

Un palindrome est un mot qui se lit de la même manière dans les deux sens (ex: "radar", "kayak"). Créez un programme qui demande à l'utilisateur de saisir un mot, puis qui vérifie s'il s'agit d'un palindrome.

Indice : La méthode la plus simple est de créer une nouvelle chaîne qui est l'inverse de la chaîne originale, puis de les comparer. Vous pouvez utiliser une boucle for qui parcourt la chaîne de la fin vers le début et un StringBuilder pour construire la chaîne inversée.

Voir la solution

import java.util.Scanner;

public class PalindromeChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Veuillez entrer un mot : ");
        String original = scanner.nextLine();

        // On utilise un StringBuilder pour construire la version inversée
        StringBuilder reverseBuilder = new StringBuilder();

        // Boucle qui parcourt le mot de la fin vers le début
        for (int i = original.length() - 1; i >= 0; i--) {
            reverseBuilder.append(original.charAt(i));
        }

        String reversed = reverseBuilder.toString();

        // On compare l'original et l'inversé (en ignorant la casse)
        if (original.equalsIgnoreCase(reversed)) {
            System.out.println("Le mot '" + original + "' est un palindrome !");
        } else {
            System.out.println("Le mot '" + original + "' n'est pas un palindrome.");
        }

        scanner.close();
    }
}

Exercice 3 : Trouver le Mot le Plus Long

Écrivez un programme qui prend une phrase (une String) et trouve le mot le plus long dans cette phrase. S'il y a plusieurs mots de la même longueur maximale, le premier trouvé suffit.

Indice : Utilisez la méthode split(" ") de la classe String pour transformer la phrase en un tableau de mots. Ensuite, parcourez ce tableau avec une boucle et gardez en mémoire le mot le plus long que vous avez trouvé jusqu'à présent.

Voir la solution

public class LongestWord {
    public static void main(String[] args) {
        String phrase = "Java est un langage de programmation puissant";

        // On sépare la phrase en un tableau de mots
        String[] mots = phrase.split(" ");

        String motLePlusLong = ""; // On initialise avec une chaîne vide

        // On parcourt chaque mot du tableau
        for (String mot : mots) {
            // Si la longueur du mot actuel est plus grande que celle du plus long mot trouvé jusqu'à présent
            if (mot.length() > motLePlusLong.length()) {
                motLePlusLong = mot; // On met à jour le mot le plus long
            }
        }

        System.out.println("La phrase est : \"" + phrase + "\"");
        System.out.println("Le mot le plus long est : '" + motLePlusLong + "'");
    }
}