Comment créer des tableaux Java à taille fixe

Introduction

Ce tutoriel explore les techniques essentielles pour créer et utiliser des tableaux de taille fixe en Java. Les tableaux sont des structures de données fondamentales qui vous permettent de stocker plusieurs éléments du même type dans une seule variable. En maîtrisant les tableaux Java, vous acquerrez une compétence de programmation cruciale qui sert de base à des sujets plus avancés.

Dans ce lab, vous apprendrez à déclarer, initialiser et manipuler des tableaux grâce à une pratique concrète. Chaque étape s'appuie sur la précédente, vous offrant une compréhension complète des opérations sur les tableaux en Java.

Créer votre premier tableau Java

Les tableaux en Java sont des objets qui stockent plusieurs variables du même type. Contrairement à d'autres structures de données, une fois qu'un tableau est créé, sa taille ne peut pas être modifiée. Cela rend les tableaux particulièrement efficaces pour stocker un nombre prédéterminé d'éléments.

Déclaration et initialisation de tableaux

Les tableaux peuvent être créés de différentes manières. Explorons les méthodes les plus courantes.

Création d'un tableau d'entiers simple

Tout d'abord, créons un nouveau fichier Java dans le répertoire de notre projet. Dans le WebIDE, cliquez sur le menu "File", sélectionnez "New File" et nommez-le ArrayDemo.java.

Ajoutez le code suivant à votre fichier :

public class ArrayDemo {
    public static void main(String[] args) {
        // Method 1: Declare and initialize an array separately
        int[] numbers;       // Array declaration
        numbers = new int[5]; // Array initialization with size 5

        // Default values are assigned (all zeros for int array)
        System.out.println("Array elements after initialization:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        System.out.println("\nArray length: " + numbers.length);
    }
}

Pour compiler et exécuter votre programme Java, ouvrez un terminal dans le WebIDE (s'il n'est pas déjà ouvert) et exécutez les commandes suivantes :

javac ArrayDemo.java
java ArrayDemo

Vous devriez voir une sortie similaire à celle-ci :

Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0

Array length: 5

Comme vous pouvez le constater, Java initialise automatiquement tous les éléments d'un tableau d'entiers à zéro.

Initialisation de tableau avec des valeurs

Maintenant, modifions notre fichier ArrayDemo.java pour inclure une autre façon de créer des tableaux - l'initialisation avec des valeurs spécifiques :

public class ArrayDemo {
    public static void main(String[] args) {
        // Method 1: Declare and initialize an array separately
        int[] numbers;       // Array declaration
        numbers = new int[5]; // Array initialization with size 5

        // Default values are assigned (all zeros for int array)
        System.out.println("Array elements after initialization:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        System.out.println("\nArray length: " + numbers.length);

        // Method 2: Initialize with specific values
        int[] scores = {85, 90, 75, 88, 92};

        System.out.println("\nScores array elements:");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("scores[" + i + "] = " + scores[i]);
        }
    }
}

Compilez et exécutez le programme mis à jour :

javac ArrayDemo.java
java ArrayDemo

Vous devriez maintenant voir une sortie supplémentaire :

Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0

Array length: 5

Scores array elements:
scores[0] = 85
scores[1] = 90
scores[2] = 75
scores[3] = 88
scores[4] = 92

Création de tableaux de différents types

Créons un nouveau fichier nommé ArrayTypes.java pour démontrer les tableaux de différents types de données. Dans le WebIDE, créez un nouveau fichier et ajoutez le code suivant :

public class ArrayTypes {
    public static void main(String[] args) {
        // String array
        String[] names = new String[3];
        names[0] = "Alice";
        names[1] = "Bob";
        names[2] = "Charlie";

        System.out.println("String array elements:");
        for (int i = 0; i < names.length; i++) {
            System.out.println("names[" + i + "] = " + names[i]);
        }

        // Double array with initialization
        double[] prices = {19.99, 29.99, 15.50, 99.99};

        System.out.println("\nDouble array elements:");
        for (int i = 0; i < prices.length; i++) {
            System.out.println("prices[" + i + "] = " + prices[i]);
        }

        // Boolean array
        boolean[] flags = new boolean[3];
        flags[0] = true;

        System.out.println("\nBoolean array elements:");
        for (int i = 0; i < flags.length; i++) {
            System.out.println("flags[" + i + "] = " + flags[i]);
        }
    }
}

Compilez et exécutez ce programme :

javac ArrayTypes.java
java ArrayTypes

Vous verrez la sortie suivante :

String array elements:
names[0] = Alice
names[1] = Bob
names[2] = Charlie

Double array elements:
prices[0] = 19.99
prices[1] = 29.99
prices[2] = 15.5
prices[3] = 99.99

Boolean array elements:
flags[0] = true
flags[1] = false
flags[2] = false

Notez que différents types de données ont des valeurs par défaut différentes :

• Les types numériques (int, double, etc.) sont par défaut à zéro
• Boolean est par défaut à false
• Les types de référence (String, objets) sont par défaut à null

Cette étape vous a montré les bases de la création de tableaux en Java. Vous avez appris à déclarer des tableaux, à les initialiser avec et sans valeurs, et à créer des tableaux de différents types de données.

Travailler avec les éléments de tableau

Maintenant que nous savons comment créer des tableaux, explorons comment travailler avec les éléments de tableau. Cela inclut la définition de valeurs, l'accès aux éléments et la modification du contenu du tableau.

Accéder et modifier les éléments de tableau

Créez un nouveau fichier nommé ArrayOperations.java dans votre WebIDE avec le code suivant :

public class ArrayOperations {
    public static void main(String[] args) {
        // Create an integer array
        int[] numbers = new int[5];

        // Assign values to array elements
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        // Display the original array
        System.out.println("Original array elements:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // Access specific elements
        int firstElement = numbers[0];
        int thirdElement = numbers[2];

        System.out.println("\nAccessing specific elements:");
        System.out.println("First element: " + firstElement);
        System.out.println("Third element: " + thirdElement);

        // Modify array elements
        numbers[1] = 25;    // Change second element
        numbers[4] = 55;    // Change last element

        // Display the modified array
        System.out.println("\nArray after modification:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }
    }
}

Compilez et exécutez ce programme :

javac ArrayOperations.java
java ArrayOperations

Vous devriez voir cette sortie :

Original array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Accessing specific elements:
First element: 10
Third element: 30

Array after modification:
numbers[0] = 10
numbers[1] = 25
numbers[2] = 30
numbers[3] = 40
numbers[4] = 55

Limites de tableau et gestion des exceptions

Lorsque vous travaillez avec des tableaux, il est crucial de comprendre les limites du tableau. Les tableaux Java ont une taille fixe, et tenter d'accéder à un élément en dehors de ces limites provoquera une exception.

Créez un nouveau fichier nommé ArrayBoundaries.java avec le code suivant :

public class ArrayBoundaries {
    public static void main(String[] args) {
        int[] numbers = new int[3];  // Array with 3 elements (indices 0, 1, 2)

        // Set values within boundaries
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;

        System.out.println("Array elements within boundaries:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // Demonstrating boundary checking with try-catch
        System.out.println("\nAttempting to access elements outside boundaries:");

        try {
            // This is valid
            System.out.println("Accessing numbers[2]: " + numbers[2]);

            // This will cause an ArrayIndexOutOfBoundsException
            System.out.println("Attempting to access numbers[3]: " + numbers[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Cannot access an index outside the array bounds (0 to " + (numbers.length-1) + ")");
        }
    }
}

Compilez et exécutez ce programme :

javac ArrayBoundaries.java
java ArrayBoundaries

Vous devriez voir une sortie comme celle-ci :

Array elements within boundaries:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30

Attempting to access elements outside boundaries:
Accessing numbers[2]: 30
Error: Index 3 out of bounds for length 3
Cannot access an index outside the array bounds (0 to 2)

Cela démontre que Java effectue une vérification des limites sur les tableaux. Tenter d'accéder à numbers[3] lève une exception car le tableau n'a que des éléments aux indices 0, 1 et 2.

Calcul et stockage de valeurs dans des tableaux

Créons un exemple pratique où nous calculons des valeurs et les stockons dans un tableau. Créez un fichier nommé TemperatureConverter.java :

public class TemperatureConverter {
    public static void main(String[] args) {
        // Array to store Celsius temperatures
        double[] celsiusTemps = {0, 10, 20, 30, 40};

        // Array to store converted Fahrenheit temperatures
        double[] fahrenheitTemps = new double[celsiusTemps.length];

        // Convert each Celsius temperature to Fahrenheit
        for (int i = 0; i < celsiusTemps.length; i++) {
            // Formula: F = C * 9/5 + 32
            fahrenheitTemps[i] = celsiusTemps[i] * 9/5 + 32;
        }

        // Display the conversion table
        System.out.println("Temperature Conversion Table:");
        System.out.println("---------------------------");
        System.out.println("Celsius    |    Fahrenheit");
        System.out.println("---------------------------");

        for (int i = 0; i < celsiusTemps.length; i++) {
            System.out.printf("%-10.1f |    %-10.1f\n",
                             celsiusTemps[i],
                             fahrenheitTemps[i]);
        }
    }
}

Compilez et exécutez ce programme :

javac TemperatureConverter.java
java TemperatureConverter

La sortie sera un tableau de conversion de température :

Temperature Conversion Table:
---------------------------
Celsius    |    Fahrenheit
---------------------------
0.0        |    32.0
10.0       |    50.0
20.0       |    68.0
30.0       |    86.0
40.0       |    104.0

Cet exemple montre comment les tableaux peuvent être utilisés pour stocker des données connexes et effectuer des calculs sur plusieurs valeurs de manière efficace.

Dans cette étape, vous avez appris à accéder et à modifier les éléments de tableau, à gérer les limites de tableau et à utiliser les tableaux pour des calculs pratiques. Ces compétences constituent la base d'opérations de tableau plus complexes.

Opérations avancées sur les tableaux

Maintenant que vous comprenez les bases des tableaux, explorons des opérations plus sophistiquées, notamment l'itération de tableaux, la recherche et l'utilisation de tableaux avec des méthodes.

Techniques d'itération de tableaux

Java propose plusieurs façons d'itérer sur les éléments d'un tableau. Créez un nouveau fichier nommé ArrayIteration.java avec le code suivant :

public class ArrayIteration {
    public static void main(String[] args) {
        // Create a sample array
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};

        System.out.println("Array Iteration Methods:");

        // Method 1: Standard for loop
        System.out.println("\n1. Using standard for loop:");
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("fruits[" + i + "] = " + fruits[i]);
        }

        // Method 2: Enhanced for loop (foreach)
        System.out.println("\n2. Using enhanced for loop (foreach):");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // Method 3: While loop
        System.out.println("\n3. Using while loop:");
        int index = 0;
        while (index < fruits.length) {
            System.out.println("fruits[" + index + "] = " + fruits[index]);
            index++;
        }
    }
}

Compilez et exécutez ce programme :

javac ArrayIteration.java
java ArrayIteration

Vous devriez voir cette sortie :

Array Iteration Methods:

1. Using standard for loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry

2. Using enhanced for loop (foreach):
Apple
Banana
Cherry
Date
Elderberry

3. Using while loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry

Chaque méthode d'itération a ses avantages :

• Boucle for standard : Fournit l'accès aux indices et aux éléments du tableau
• Boucle for améliorée : Syntaxe plus propre lorsque vous n'avez besoin que des éléments
• Boucle while : Utile lorsque la condition d'itération est plus complexe

Recherche d'éléments dans un tableau

Créons un programme qui recherche des éléments dans un tableau. Créez un fichier nommé ArraySearch.java :

public class ArraySearch {
    public static void main(String[] args) {
        // Create an array of numbers
        int[] numbers = {10, 25, 33, 47, 52, 68, 79};

        // Values to search for
        int[] searchValues = {33, 50, 79};

        for (int valueToFind : searchValues) {
            boolean found = false;
            int position = -1;

            // Search through the array
            for (int i = 0; i < numbers.length; i++) {
                if (numbers[i] == valueToFind) {
                    found = true;
                    position = i;
                    break;  // Exit the loop once found
                }
            }

            // Display result
            if (found) {
                System.out.println(valueToFind + " found at position " + position);
            } else {
                System.out.println(valueToFind + " not found in the array");
            }
        }
    }
}

Compilez et exécutez ce programme :

javac ArraySearch.java
java ArraySearch

Vous devriez voir une sortie comme celle-ci :

33 found at position 2
50 not found in the array
79 found at position 6

Cela démontre un algorithme de recherche linéaire de base, vérifiant chaque élément jusqu'à ce que la valeur cible soit trouvée ou que le tableau soit épuisé.

Passage de tableaux aux méthodes

Les tableaux peuvent être passés aux méthodes comme n'importe quelle autre variable. Créez un fichier nommé ArrayMethods.java :

public class ArrayMethods {
    public static void main(String[] args) {
        // Create an array
        int[] values = {5, 10, 15, 20, 25};

        // Display the original array
        System.out.println("Original array:");
        displayArray(values);

        // Calculate and display the sum
        int sum = calculateSum(values);
        System.out.println("\nSum of all elements: " + sum);

        // Calculate and display the average
        double average = calculateAverage(values);
        System.out.println("Average of all elements: " + average);

        // Double all values in the array
        doubleValues(values);

        // Display the modified array
        System.out.println("\nArray after doubling all values:");
        displayArray(values);
    }

    // Method to display an array
    public static void displayArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // Method to calculate the sum of array elements
    public static int calculateSum(int[] arr) {
        int sum = 0;
        for (int value : arr) {
            sum += value;
        }
        return sum;
    }

    // Method to calculate the average of array elements
    public static double calculateAverage(int[] arr) {
        int sum = calculateSum(arr);
        return (double) sum / arr.length;
    }

    // Method to double all values in the array
    public static void doubleValues(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }
}

Compilez et exécutez ce programme :

javac ArrayMethods.java
java ArrayMethods

Vous devriez voir une sortie comme celle-ci :

Original array:
5 10 15 20 25

Sum of all elements: 75
Average of all elements: 15.0

Array after doubling all values:
10 20 30 40 50

Cet exemple démontre plusieurs concepts importants :

1. Les tableaux peuvent être passés aux méthodes en tant que paramètres
2. Les méthodes peuvent renvoyer des valeurs calculées à partir de tableaux
3. Les modifications apportées aux éléments du tableau à l'intérieur d'une méthode se reflètent à l'extérieur de la méthode (les tableaux sont passés par référence)

Recherche des valeurs maximales et minimales

Créons un programme pour trouver les valeurs maximales et minimales dans un tableau. Créez un fichier nommé ArrayMinMax.java :

public class ArrayMinMax {
    public static void main(String[] args) {
        // Create an array of numbers
        int[] numbers = {42, 17, 88, 23, 56, 9, 71, 33};

        // Find minimum and maximum values
        int min = findMinimum(numbers);
        int max = findMaximum(numbers);

        // Display the array
        System.out.print("Array values: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();

        // Display results
        System.out.println("Minimum value: " + min);
        System.out.println("Maximum value: " + max);
    }

    // Method to find the minimum value in an array
    public static int findMinimum(int[] arr) {
        // Start with the first element as the minimum
        int min = arr[0];

        // Compare with other elements
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        return min;
    }

    // Method to find the maximum value in an array
    public static int findMaximum(int[] arr) {
        // Start with the first element as the maximum
        int max = arr[0];

        // Compare with other elements
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        return max;
    }
}

Compilez et exécutez ce programme :

javac ArrayMinMax.java
java ArrayMinMax

Vous devriez voir une sortie comme celle-ci :

Array values: 42 17 88 23 56 9 71 33
Minimum value: 9
Maximum value: 88

Dans cette étape, vous avez appris plusieurs opérations avancées sur les tableaux, notamment différentes techniques d'itération, la recherche d'éléments, le passage de tableaux aux méthodes et la recherche des valeurs minimales et maximales. Ces compétences vous aideront à travailler plus efficacement avec les tableaux dans vos programmes Java.

Applications pratiques des tableaux

Dans cette dernière étape, nous allons explorer les applications pratiques des tableaux à travers un exemple complet. Nous allons créer un système simple de gestion des notes qui démontre comment les tableaux peuvent être utilisés dans des scénarios de programmation réels.

Création d'un suivi des notes des étudiants

Construisons un programme qui gère les notes des étudiants. Ce programme va :

1. Stocker les noms des étudiants et leurs notes
2. Calculer la moyenne des notes
3. Trouver les notes les plus hautes et les plus basses
4. Déterminer combien d'étudiants ont obtenu une note supérieure à la moyenne

Créez un nouveau fichier nommé GradeTracker.java dans votre WebIDE :

public class GradeTracker {
    public static void main(String[] args) {
        // Arrays to store student information
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Display all student records
        System.out.println("Student Grade Records:");
        System.out.println("---------------------");
        System.out.println("Name\t\tGrade");
        System.out.println("---------------------");

        for (int i = 0; i < studentNames.length; i++) {
            // Add extra tab for short names to align columns
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i]);
        }

        // Calculate statistics
        int sum = 0;
        int highest = studentGrades[0];
        int lowest = studentGrades[0];
        String highestStudent = studentNames[0];
        String lowestStudent = studentNames[0];

        for (int i = 0; i < studentGrades.length; i++) {
            // Add to sum for average calculation
            sum += studentGrades[i];

            // Check for highest grade
            if (studentGrades[i] > highest) {
                highest = studentGrades[i];
                highestStudent = studentNames[i];
            }

            // Check for lowest grade
            if (studentGrades[i] < lowest) {
                lowest = studentGrades[i];
                lowestStudent = studentNames[i];
            }
        }

        // Calculate average
        double average = (double) sum / studentGrades.length;

        // Count students above average
        int aboveAverageCount = 0;
        for (int grade : studentGrades) {
            if (grade > average) {
                aboveAverageCount++;
            }
        }

        // Display statistics
        System.out.println("\nClass Statistics:");
        System.out.println("----------------");
        System.out.printf("Class Average: %.2f\n", average);
        System.out.println("Highest Grade: " + highest + " (" + highestStudent + ")");
        System.out.println("Lowest Grade: " + lowest + " (" + lowestStudent + ")");
        System.out.println("Number of students above average: " + aboveAverageCount);
    }
}

Compilez et exécutez ce programme :

javac GradeTracker.java
java GradeTracker

Vous devriez voir une sortie comme celle-ci :

Student Grade Records:
---------------------
Name		Grade
---------------------
Alice		85
Bob		92
Charlie	78
David		65
Emma		88
Frank		72
Grace		95
Hannah		83
Ian		79
Julia		91

Class Statistics:
----------------
Class Average: 82.80
Highest Grade: 95 (Grace)
Lowest Grade: 65 (David)
Number of students above average: 5

Ce programme démontre comment les tableaux peuvent être utilisés pour gérer des données connexes (noms et notes des étudiants) et effectuer des calculs sur ces données.

Ajout de catégories de notes

Maintenant, améliorons notre suivi des notes en ajoutant des catégories de notes. Créez un nouveau fichier nommé EnhancedGradeTracker.java :

public class EnhancedGradeTracker {
    public static void main(String[] args) {
        // Arrays to store student information
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Create arrays to count grades in each category
        int[] gradeCounts = new int[5]; // A, B, C, D, F

        // Display all student records with grade categories
        System.out.println("Student Grade Records:");
        System.out.println("------------------------------");
        System.out.println("Name\t\tScore\tGrade");
        System.out.println("------------------------------");

        for (int i = 0; i < studentNames.length; i++) {
            // Calculate letter grade
            char letterGrade = calculateGrade(studentGrades[i]);

            // Count grades by category
            switch (letterGrade) {
                case 'A': gradeCounts[0]++; break;
                case 'B': gradeCounts[1]++; break;
                case 'C': gradeCounts[2]++; break;
                case 'D': gradeCounts[3]++; break;
                case 'F': gradeCounts[4]++; break;
            }

            // Add extra tab for short names to align columns
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + letterGrade);
        }

        // Calculate statistics
        double average = calculateAverage(studentGrades);

        // Display statistics
        System.out.println("\nClass Statistics:");
        System.out.println("----------------");
        System.out.printf("Class Average: %.2f\n", average);

        // Display grade distribution
        System.out.println("\nGrade Distribution:");
        System.out.println("------------------");
        System.out.println("A: " + displayStars(gradeCounts[0]));
        System.out.println("B: " + displayStars(gradeCounts[1]));
        System.out.println("C: " + displayStars(gradeCounts[2]));
        System.out.println("D: " + displayStars(gradeCounts[3]));
        System.out.println("F: " + displayStars(gradeCounts[4]));
    }

    // Method to calculate the letter grade from a numeric score
    public static char calculateGrade(int score) {
        if (score >= 90) {
            return 'A';
        } else if (score >= 80) {
            return 'B';
        } else if (score >= 70) {
            return 'C';
        } else if (score >= 60) {
            return 'D';
        } else {
            return 'F';
        }
    }

    // Method to calculate the average of an integer array
    public static double calculateAverage(int[] arr) {
        int sum = 0;
        for (int value : arr) {
            sum += value;
        }
        return (double) sum / arr.length;
    }

    // Method to create a string of stars representing a count
    public static String displayStars(int count) {
        StringBuilder stars = new StringBuilder();
        for (int i = 0; i < count; i++) {
            stars.append("*");
        }
        return stars.toString() + " (" + count + ")";
    }
}

Compilez et exécutez ce programme :

javac EnhancedGradeTracker.java
java EnhancedGradeTracker

Vous devriez voir une sortie comme celle-ci :

Student Grade Records:
------------------------------
Name		Score	Grade
------------------------------
Alice		85	B
Bob		92	A
Charlie	78	C
David		65	D
Emma		88	B
Frank		72	C
Grace		95	A
Hannah		83	B
Ian		79	C
Julia		91	A

Class Statistics:
----------------
Class Average: 82.80

Grade Distribution:
------------------
A: *** (3)
B: *** (3)
C: *** (3)
D: * (1)
F:  (0)

Cet exemple amélioré démontre :

1. L'utilisation de plusieurs tableaux pour stocker des données connexes
2. La création de méthodes utilitaires pour les calculs et le formatage
3. Le comptage et la catégorisation des données
4. La création d'une représentation visuelle des données du tableau

Traitement des données de tableau en fonction de conditions

Pour notre dernier exemple, créons un programme qui traite les données de tableau en fonction de conditions. Créez un fichier nommé FilteredGrades.java :

public class FilteredGrades {
    public static void main(String[] args) {
        // Arrays to store student information
        String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
                                "Frank", "Grace", "Hannah", "Ian", "Julia"};

        int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};

        // Create a threshold for passing
        int passingGrade = 75;

        // Display all student records with pass/fail status
        System.out.println("Student Grade Records:");
        System.out.println("------------------------------");
        System.out.println("Name\t\tScore\tStatus");
        System.out.println("------------------------------");

        // Count passing and failing students
        int passingCount = 0;

        for (int i = 0; i < studentNames.length; i++) {
            String status = (studentGrades[i] >= passingGrade) ? "PASS" : "FAIL";

            // Count passing students
            if (studentGrades[i] >= passingGrade) {
                passingCount++;
            }

            // Add extra tab for short names to align columns
            String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + status);
        }

        // Create arrays to store only passing students
        String[] passingStudents = new String[passingCount];
        int[] passingScores = new int[passingCount];

        // Fill the passing student arrays
        int index = 0;
        for (int i = 0; i < studentNames.length; i++) {
            if (studentGrades[i] >= passingGrade) {
                passingStudents[index] = studentNames[i];
                passingScores[index] = studentGrades[i];
                index++;
            }
        }

        // Display only passing students
        System.out.println("\nPassing Students (Score >= 75):");
        System.out.println("------------------------------");
        System.out.println("Name\t\tScore");
        System.out.println("------------------------------");

        for (int i = 0; i < passingStudents.length; i++) {
            // Add extra tab for short names to align columns
            String tab = passingStudents[i].length() <= 5 ? "\t\t" : "\t";
            System.out.println(passingStudents[i] + tab + passingScores[i]);
        }

        // Calculate and display statistics
        System.out.println("\nClass Statistics:");
        System.out.println("----------------");
        System.out.println("Total Students: " + studentNames.length);
        System.out.println("Passing: " + passingCount);
        System.out.println("Failing: " + (studentNames.length - passingCount));
        System.out.printf("Pass Rate: %.1f%%\n",
                         (double) passingCount / studentNames.length * 100);
    }
}

Compilez et exécutez ce programme :

javac FilteredGrades.java
java FilteredGrades

Vous devriez voir une sortie comme celle-ci :

Student Grade Records:
------------------------------
Name		Score	Status
------------------------------
Alice		85	PASS
Bob		92	PASS
Charlie	78	PASS
David		65	FAIL
Emma		88	PASS
Frank		72	FAIL
Grace		95	PASS
Hannah		83	PASS
Ian		79	PASS
Julia		91	PASS

Passing Students (Score >= 75):
------------------------------
Name		Score
------------------------------
Alice		85
Bob		92
Charlie	78
Emma		88
Grace		95
Hannah		83
Ian		79
Julia		91

Class Statistics:
----------------
Total Students: 10
Passing: 8
Failing: 2
Pass Rate: 80.0%

Cet exemple démontre :

1. L'utilisation de la logique conditionnelle avec les tableaux
2. La création de tableaux filtrés en fonction de conditions
3. Le calcul de statistiques à partir des données du tableau
4. La présentation des informations de manière formatée

Dans cette étape, vous avez vu comment les tableaux peuvent être appliqués pour résoudre des problèmes pratiques. Vous avez appris à gérer des données connexes, à effectuer des calculs et à créer des vues filtrées des données de tableau en fonction de conditions. Ces compétences vous serviront de base solide pour travailler avec les tableaux dans les applications Java du monde réel.

Résumé

Dans ce lab, vous avez exploré les techniques essentielles pour créer et travailler avec des tableaux de taille fixe en Java. Vous avez appris à :

• Déclarer et initialiser des tableaux de différents types de données
• Accéder et modifier les éléments du tableau tout en respectant les limites du tableau
• Itérer sur les tableaux en utilisant différentes techniques de boucles
• Passer des tableaux aux méthodes et traiter les données du tableau
• Trouver les valeurs minimales et maximales dans les tableaux
• Appliquer les tableaux à des problèmes pratiques comme le suivi des notes

Les tableaux constituent la base de nombreuses structures de données en Java et sont essentiels pour le stockage et la manipulation efficaces des données. Les compétences que vous avez développées dans ce lab serviront d'éléments constitutifs pour des concepts de programmation plus avancés, tels que les structures de données dynamiques, les algorithmes et la programmation orientée objet.

Continuez à vous entraîner avec les tableaux en modifiant les exemples fournis, en créant vos propres applications basées sur les tableaux et en explorant la documentation Java pour des utilitaires de tableaux supplémentaires dans la classe java.util.Arrays.