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 :
- Les tableaux peuvent être passés aux méthodes en tant que paramètres
- Les méthodes peuvent renvoyer des valeurs calculées à partir de tableaux
- 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 :
- Stocker les noms des étudiants et leurs notes
- Calculer la moyenne des notes
- Trouver les notes les plus hautes et les plus basses
- 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 :
- L'utilisation de plusieurs tableaux pour stocker des données connexes
- La création de méthodes utilitaires pour les calculs et le formatage
- Le comptage et la catégorisation des données
- 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 :
- L'utilisation de la logique conditionnelle avec les tableaux
- La création de tableaux filtrés en fonction de conditions
- Le calcul de statistiques à partir des données du tableau
- 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.
