Fondamentaux des Tableaux en Java
Un tableau est une structure de données fondamentale permettant de stocker une collection d'éléments de même type. Chaque élément est identifié par un index numérique débutant à zéro. En Java, la taille d'un tableau est fixée lors de sa création et ne peut plus être modifiée.
Pourquoi utiliser des tableaux ?
- Organisation des données : Évite la déclaration de multiples variables individuelles pour des ensembles de données volumineux.
- Traitements par lots : Facilite l'itération et la manipulation uniforme des éléments via des boucles.
- Optimisation mémoire : Les données sont stockées de manière contiguë en mémoire, offrant un accès rapide (complexité O(1)) et réduisant la surcharge de gestion.
Caractéristiques clés : Typage fort, taille immuable, accès par index constant, et allocation mémoire séquentielle.
- Tableaux Unidimensionnels
Déclaration et Initialisation
Initialisation statique : Les valeurs sont fournies directement lors de la création.
int[] scores = {85, 90, 78, 92};
// ou
int[] scores = new int[]{85, 90, 78, 92};
Initialisation dynamique : On spécifie uniquement le type et la capacité. Les éléments prennent des valeurs par défaut (0 pour les numériques, null pour les objets, false pour les booléens).
int[] scores = new int[4];
Accès, Modification et Longueur
L'accès se fait via l'index. Attention aux dépassements de capacité (ArrayIndexOutOfBoundsException). La propriété length (sans parenthèses) retourne la taille du tableau.
int[] notes = {15, 12, 18};
notes[1] = 14; // Modification
int taille = notes.length; // Récupération de la taille (3)
Itération
Deux approches principales existent pour parcourir un tableau :
int[] valeurs = {10, 20, 30, 40};
// Boucle classique (accès à l'index)
for (int i = 0; i < valeurs.length; i++) {
System.out.println("Index " + i + " : " + valeurs[i]);
}
// Boucle améliorée (foreach)
for (int val : valeurs) {
System.out.println(val);
}
// Note : la boucle améliorée ne permet pas de modifier les éléments originaux via la variable de boucle.
Exercices Pratiques 1D
Exemple 1 : Recherche de la valeur maximale
public class MaxFinder {
public static void main(String[] args) {
int[] dataset = {45, 12, 89, 33, 76};
System.out.println("Maximum : " + findMaximum(dataset));
}
public static int findMaximum(int[] data) {
int highest = data[0];
for (int i = 1; i < data.length; i++) {
if (data[i] > highest) {
highest = data[i];
}
}
return highest;
}
}
Exemple 2 : Génération et mélange d'un jeu de cartes
import java.util.Random;
public class CardShuffler {
public static void main(String[] args) {
String[] deck = new String[54];
String[] suits = {"Pique", "Coeur", "Carreau", "Trèfle"};
String[] ranks = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "V", "D", "R"};
int pos = 0;
for (String rank : ranks) {
for (String suit : suits) {
deck[pos++] = rank + " de " + suit;
}
}
deck[pos++] = "Joker Noir";
deck[pos] = "Joker Rouge";
System.out.println("Avant mélange :");
printDeck(deck);
shuffleDeck(deck);
System.out.println("\nAprès mélange :");
printDeck(deck);
}
private static void shuffleDeck(String[] cards) {
Random rng = new Random();
for (int i = 0; i < cards.length; i++) {
int target = rng.nextInt(cards.length);
String temp = cards[i];
cards[i] = cards[target];
cards[target] = temp;
}
}
private static void printDeck(String[] cards) {
for (String card : cards) {
System.out.print(card + " | ");
}
System.out.println();
}
}
// Note : java.util.Random est préféré à Math.random() pour de meilleures performances et un contrôle accru.
- Tableaux Bidimensionnels
Un tableau 2D est essentiellement un tableau de tableaux, formant une structure en grille (lignes et colonnes).
Déclaration et Initialisation
// Statique
int[][] grid1 = {{1, 2}, {3, 4}};
int[][] grid2 = new int[][]{{1, 2}, {3, 4}};
// Dynamique
int[][] grid3 = new int[3][4]; // 3 lignes, 4 colonnes
int[][] grid4 = new int[3][]; // Tableau irrégulier (jagged array)
Accès, Itération et Dimensions
L'accès nécessite deux index : matrix[ligne][colonne]. La propriété length sur le tableau principal donne le nombre de lignes, tandis que matrix[i].length donne le nombre de colonnes pour la ligne i.
public class MatrixTraversal {
public static void main(String[] args) {
int[][] matrix = {
{10, 20, 30},
{40, 50, 60}
};
System.out.println("Lignes : " + matrix.length);
System.out.println("Colonnes (ligne 0) : " + matrix[0].length);
for (int r = 0; r < matrix.length; r++) {
for (int c = 0; c < matrix[r].length; c++) {
System.out.print(matrix[r][c] + "\t");
}
System.out.println();
}
}
}
Exercice Pratique 2D : Matrice NxN avec permutation
import java.util.Random;
public class MatrixScrambler {
public static void main(String[] args) {
scrambleMatrix(4);
}
public static void scrambleMatrix(int size) {
int[][] board = new int[size][size];
int counter = 1;
// Remplissage séquentiel
for (int r = 0; r < size; r++) {
for (int c = 0; c < size; c++) {
board[r][c] = counter++;
}
}
displayMatrix(board, "Matrice initiale");
// Permutation aléatoire des éléments
Random rand = new Random();
for (int r = 0; r < size; r++) {
for (int c = 0; c < size; c++) {
int randR = rand.nextInt(size);
int randC = rand.nextInt(size);
int temp = board[r][c];
board[r][c] = board[randR][randC];
board[randR][randC] = temp;
}
}
displayMatrix(board, "Matrice mélangée");
}
private static void displayMatrix(int[][] mat, String title) {
System.out.println(title + " :");
for (int[] row : mat) {
for (int val : row) {
System.out.printf("%4d", val);
}
System.out.println();
}
System.out.println();
}
}
Note sur la mémoire et les références
En Java, les variables de type tableau ne contiennent pas les données elles-mêmes, mais une référence (un pointeur) vers l'objet tableau alloué dans le tas (heap memory). Cela signifie que passer un tableau à une méthode ou l'assigner à une autre variable partage la même instance mémoire.