Tableau
Un tableau est un objet spécial qui peut stocker plusieurs valeurs. Un tableau une une “boîte” divisée en section. Chqaue section du tableau a son numéro qui commence à zéro.
La valeur initial des cellules du tableau est 0, null (pour les cellules stockant des adresses), et false pour des boolean.
Après la création du tableau, il n’est plus possible de changer le type de ses éléments ou leur nombre.
Création d’un tableau
La taille du conteneur du tableau ne peut pas être modifiée après sa création.
// =====================================
// création d'un tableau de 100 entier
// =====================================
int[] myArray = new int[100];
// =====================================
// création d'un tableau de 20 double
// =====================================
double[] myTableau = new double[20];
// =====================================
// création en deux temps
// =====================================
type[] = name; // création du tableau
name = new type[count]; // initialisation du tableau Initialisation rapide de tableau
// initialisaiton rapide
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
// initialisation encore plus rapide
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };Tableau de String
Remplir le tableau avec des saisies user
// ===============================
// tableau de String qui récupère des saisie user
// ===============================
String[] array = new String[10]; // Créer un tableau-objet de 10 éléments
for (int i = 0; i < 10; i++) // Boucle de 0 à 9
{
array[i] = console.nextLine(); // Lire une ligne au clavier et la stocker dans la case du tableau
}
for (int i = 9; i >= 0; i--) // Boucle de 9 à 0
{
System.out.println(array[i]); // Afficher la case suivante du tableau
}Tableau de null
null est une constante spéciale qui indique une référence vide. Lorsqu’une variable type-objet est créer, sa valeur initial est null.
Il est impossible d’appeler des méthodes sur un objet si sa valeur est null. Le programme lance une erreur dans ce cas NullPointerException.
int[] numbers = new int[10]; // contient des 0
String[] strings = new String[10]; // contient des ""
User[] users = new User[10]; // contient des nullDépassement et limite de tableau
En cas de tentative d’accès à une cellule d’un tableau via l’indice qui n’existe pas dans le tableau, cela provoque une erreur ArrayIndexOutOfBoundsException.
Manipulation du tableau
Pour manipuler les cellules du tableau, on viens indiquer son index. La numérotation commence toujours à zéro.
int[] a = new int[10]; // Nous créons un tableau de 10 éléments de type int.
a[2] = 4; // Nous écrivons la valeur 4 dans la cellule d’indice 2.
a[7] = 9; // Nous écrivons la valeur 9 dans la cellule d’indice 7.
a[9] = a[2] + a[5]; // Nous écrivons dans la cellule d’indice 9 la somme des valeurs stockées dans les cellules 2
// (4) et 5 (0).
// ================================
// utilisaton de variables et expression
// ================================
int n = 100;
int[] a = new int[n]; // Création d’un tableau de n éléments
int n = 100;
int[] a = new int[n * 2 + 3]; // Création d’un tableau de 203 éléments
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2] // a[20] = a[99] + a[98];Longueur de tableau - array.length
Retourne la longeur du tableau.
int[] array; // Nous créons une variable‑tableau de type int[]
if (a < 10) // Si la variable a est inférieure à 10,
array = new int[10]; // alors créer un tableau de 10 éléments.
else // Sinon
array = new int[20]; // créer un tableau de 20 éléments
for (int i = 0; i < array.length; i++) // Boucle sur tous les éléments du tableau : de 0 à array.length — 1
{
System.out.println(array[i]);
}Parcourir un tableau
for-each
Boucle spécial permettant de simplifier l’itération de tableau.
La boucle itère sur chaque élément du tableau. Une variable locale est créer, et contient la valeur en cours d’itération.
// ==============================
// parcourir un tableau de int
// ==============================
for (int score : scores)
{
System.out.println("Points: " + score);
}
// =================================
// somme des éléments du tableau
// =================================
int sum = 0;
for (int score : scores)
{
sum += score;
}
System.out.println("Somme de tous les points: " + sum);Itération et modification
La boucle ne permet pas de modifier les éléments du tableau, pour cela, il est nécessaire d’utiliser une boucle for et d’utiliser l’index de l’élément pour le modifier.
for (int i = 0; i < scores.length; i++)
{
int score = scores[i];
System.out.println("Points: " + score);
}Pattern de tableau
Somme des élémens du tableau
int sum = 0;
for (int i = 0; i < grades.length; i++) {
sum += grades[i]; // équivaut à sum = sum + grades[i];
}
System.out.println("Somme des notes: " + sum);Rechercher une valeur max
int max = grades[0]; // commençons par le premier élément
for (int i = 1; i < grades.length; i++) {
if (grades[i] > max) {
max = grades[i];
}
}
System.out.println("Note maximale: " + max);Recherche de la valeur min
int min = grades[0]; // commençons par le premier élément
for (int i = 1; i < grades.length; i++) {
if (grades[i] < min) {
min = grades[i];
}
}
System.out.println("Note minimale: " + min);Calcul de la moyenne
int sum = 0;
for (int i = 0; i < grades.length; i++) {
sum += grades[i];
}
double average = (double) sum / grades.length; // il faut absolument convertir en double !
System.out.println("Note moyenne: " + average);Saisie d’une tableau au clavier
Scanner console = new Scanner(System.in);
int n = 5; // taille du tableau
int[] numbers = new int[n];
System.out.println("Saisissez " + n + " nombres:");
for (int i = 0; i < n; i++) {
numbers[i] = console.nextInt();
}
System.out.println("Vous avez saisi:");
for (int i = 0; i < n; i++) {
System.out.println(numbers[i]);
}Affichage du tableau en sens inverse
for (int i = grades.length - 1; i >= 0; i--) {
System.out.println("Note n°" + (i + 1) + ": " + grades[i]);
}Tableau à deux dimensions
Un tableau à deux dimensions peut être appelé une matrice.
Ce sont des tableaux qui contiennent un tableau.
Création
On utilise deux paires de crochets.
Le premier crochet correspond aux lignes, et le second au colonnes.
// ========================
// syntaxe
// ========================
int[][] matrix;
matrix = new int[3][4]; // 3 lignes, 4 colonnes
// ==========================
// initisation rapide
// ==========================
int[][] matrix = new int[3][4];
// ==========================
// initialisation très rapide
// ==========================
int[][] example = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};Accès aux éléments
Dans un tableau 2D, on accède au élément en indiquant la ligne, puis la colonne.
int[][] data = new int[5][2];
data[1][1] = 5; // écriture
int value = data[1][1]; // lectureRemplir un tableau 2D
int[][] matrix = new int[3][4];
int value = 1;
for (int row = 0; row < 3; row++)
{
for (int col = 0; col < 4; col++)
{
matrix[row][col] = value;
value++;
}
}
/* sortie
┌────┬────┬────┬────┐
│ 1 │ 2 │ 3 │ 4 │
├────┼────┼────┼────┤
│ 5 │ 6 │ 7 │ 8 │
├────┼────┼────┼────┤
│ 9 │ 10 │ 11 │ 12 │
└────┴────┴────┴────┘
*/Affichage de tableau 2D
Pour itérer sur des tableau 2D, on utilise une double boucle.
for (int row = 0; row < matrix.length; row++)
{
for (int col = 0; col < matrix[row].length; col++)
{
System.out.print(matrix[row][col] + "\t");
}
System.out.println(); // saut de ligne
}Pattern
Echange de ligne
// Matrice importante avec des données
int[][] matrix = {
{1, 2, 3, 4, 5},
{5, 4, 3, 2, 1}
};
int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;Jagged Arrays
Les tableaux irréguliers permettent d’avoir des lignes de longueurs différentes. Chaque élément est lui même un tableau, et ses sous-tableaux peuvent avoir une longueurs différentes.
Création
// 1. création du tableau externe
int[][] jaggedArray = new int[3][];
// 2. Création et initialisation des sous tableaux
jaggedArray[0] = new int[2]; // 2 éléments dans la première ligne
jaggedArray[1] = new int[4]; // 4 éléments dans la deuxième ligne
jaggedArray[2] = new int[3]; // 3 éléments dans la troisième ligne
// 3. Remplissage avec valeurs
jaggedArray[0][0] = 1;
jaggedArray[0][1] = 2;
jaggedArray[1][0] = 3;
jaggedArray[1][1] = 4;
jaggedArray[1][2] = 5;
jaggedArray[1][3] = 6;
jaggedArray[2][0] = 7;
jaggedArray[2][1] = 8;
jaggedArray[2][2] = 9;
// =============================
// syntaxe courte
// =============================
int[][] jaggedArray = new int[][]
{
new int[] { 1, 2 },
new int[] { 3, 4, 5, 6 },
new int[] { 7, 8, 9 }
};
// ==============================
// syntaxe encore plus courte
// ==============================
int[][] jaggedArray =
{
{ 1, 2 },
{ 3, 4, 5, 6 },
{ 7, 8, 9 }
};Parcourir
// =============================
// itération avec for
// =============================
for (int i = 0; i < jaggedArray.length; i++)
{
System.out.println("Ligne " + i + ":");
for (int j = 0; j < jaggedArray[i].length; j++)
{
System.out.print(jaggedArray[i][j] + " ");
}
System.out.println();
}
// ================================
// itération avec for-each
// ================================
for (int[] row : jaggedArray)
{
for (int value : row)
{
System.out.print(value + " ");
}
System.out.println();
}Tableau multidimensions
Création
Le nombre de crochets permet de définir le nombre de dimensions
int[][][] cube = new int[2][3][4]; // 2 couches, 3 lignes, 4 colonnes
cube[0][1][2] = 99;Parcourir
for (int i = 0; i < cube.length; i++)
{
for (int j = 0; j < cube[i].length; j++)
{
for (int k = 0; k < cube[i][j].length; k++)
{
System.out.print(cube[i][j][k] + " ");
}
System.out.println();
}
System.out.println("---");
}Classe Arrays
La classe java.util.Arrays fournit un ensemble de méthode statique permettant de simplifier le travail avec les tableaux.
La classe doit ètre importée avant de pouvoir être utilisée.
import java.util.Arrays;Arrays.sort - trie du tableau
Cette méthode trie sur place le tableau. Elle vient modifier le tableau d’origine.
Pour conserver le tableau original, venir créer une copie avant de travailler sur le tableau.
Arrays.sort(array);
Arrays.sort(array, startIndex, endIndex);Trie d’un tableau d’entiers
Les entiers sont triée dans l’ordre croissant.
int[] scores = {5, 2, 9, 1, 7};
Arrays.sort(scores); // Tri croissant
System.out.println("Tableau trié: " + Arrays.toString(scores));
// Affichera: [1, 2, 5, 7, 9]Trie d’un tableau de String
Les String sont triée par ordre alphabétique.
String[] names = {"Alice", "Bob", "Charlie", "David"};
Arrays.sort(names);
System.out.println(Arrays.toString(names));
// [Charlie, David, Bob, Alice]Trie d’une partie du tableau
int[] arr = {7, 5, 3, 1, 9, 8};
Arrays.sort(arr, 1, 4); // trie les éléments d’indice 1 à 3 inclus (4 exclu)
System.out.println(Arrays.toString(arr));
// [7, 1, 3, 5, 9, 8]Arrays.fill - remplissage de tableau
La méthode remplit tous les éléments du tableau, ou la partie indiquée avec la même valeur
Arrays.fill(array, value);
Arrays.fill(array, startIndex, endIndex, value);Remplir tout le tableau
int[] marks = new int[5];
Arrays.fill(marks, 3); // Tous les éléments valent désormais 3
System.out.println(Arrays.toString(marks)); // [3, 3, 3, 3, 3]Remplir une partie du tableau
int[] arr = new int[10];
Arrays.fill(arr, 2, 5, 7); // Remplit les éléments d’indice 2 à 4 inclus (5 exclu)
System.out.println(Arrays.toString(arr));
// [0, 0, 7, 7, 7, 0, 0, 0, 0, 0]Remplir un tableau de String
String[] guests = new String[4];
Arrays.fill(guests, "Vide");
System.out.println(Arrays.toString(guests)); // [Vide, Vide, Vide, Vide]Arrays.copyOf - copie des éléments d’un tableau
Cette méthode créer un nouveau tableau et copie les éléments depuis l’original. Si la nouvelle longueur est supérieur à l’originale, la “queue” est remplie par des valeurs par défaut.
Arrays.copyOf(originalArray, newLength);Copie de tableau
int[] original = {1, 2, 3};
int[] copy = Arrays.copyOf(original, 5);
System.out.println(Arrays.toString(copy)); // [1, 2, 3, 0, 0]Réduction de tableau
int[] shortCopy = Arrays.copyOf(original, 2);
System.out.println(Arrays.toString(shortCopy)); // [1, 2]Arrays.copyOfRange()
Arrays.copyOfRange(originalArray, startIndex, endIndex);int[] arr = {10, 20, 30, 40, 50};
int[] mid = Arrays.copyOfRange(arr, 1, 4); // Copiera les éléments d’indice 1 à 3
System.out.println(Arrays.toString(mid)); // [20, 30, 40]Arrays.equals() - comparaison de tableau 1D
Arrays.equals(array1, array2);
System.out.println(Arrays.equals(a, b)); // trueArrays.deepEquals() - comparaison tableau 2D
Arrays.deepEquals(matrix1, matrix2);
int[][] matrix2 = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepEquals(matrix1, matrix2)); // trueArrays.toString() - affichage du tableau 1D en String
Arrays.toString(array);
System.out.println(Arrays.toString(arr)); // [1, 2, 3]Arrays.deepToString() - affichage du tableau 2D en String
int[][] matrix = {{1, 2}, {3, 4}};
System.out.println(Arrays.deepToString(matrix)); // [[1, 2], [3, 4]]ArrayList<T> - Tableau infini
Tableau qui peut grandir et rétrécir automatiquement
Création
Le type des éléments doit être placer entre < >, et prends tous les types sauf les primitifs. Les types primitifs devront être remplacer par leur enveloppe.
// ======================================
// création de tableau infini de String
// ======================================
ArrayList<String> array = new ArrayList<String>()
// ===============================
// création tableau infinie avec enveloppe
// ===============================
ArrayList<Integer> numbers = new ArrayList<Integer>(); // int
ArrayList<Double> fees = new ArrayList<Double>(); // double
ArrayList<Boolean> yesList = new ArrayList<Boolean>(); // boolean
ArrayList<Character> chars = new ArrayList<Character>(); // charMéthode
add() - ajout d’élément au tableau
La méthode permet d’ajouter un élément en fin de tableau. La taille grandit au fur et à mesure des ajouts.
ArrayList<String> todo = new ArrayList<>(); // liste des tâches
todo.add("Apprendre ArrayList");
todo.add("Préparer du thé");
todo.add("Se promener");get() - accès par indice
Chaque élément possède son indice. Cette méthode permet d’obtenir l’élément en passant l’indice souhaité.
String task = todo.get(1);
System.out.println("Deuxième tâche : " + task);set(index, element) - remplacement d’élément
Cette méthode permet de remplacer un élément du tableau
todo.set(1, "Préparer du café");
System.out.println("Désormais, la deuxième tâche : " + todo.get(1));remove(index) - supprime un élément
Permet de supprimer l’élément. La suppression d’un élément entraine un décalage (1 devient 0, etc)
todo.remove(0);
System.out.println("La première tâche maintenant : " + todo.get(0));size() - taille de la liste
La méthode retourne le nombre d’éléments du tableau.
System.out.println("Nombre total de tâches : " + todo.size());contains(element) - vérification de présence
Permet de savoir si un élément est présent dans le tableau. Elle retourne un boolean
System.out.println(todo.contains("Se promener"));
System.out.println(todo.contains("Préparer du thé"));Parcourir la liste
Boucle par indice
for (int i = 0; i < todo.size(); i++)
{
System.out.println(i + ": " + todo.get(i));
}Boucle for-each
for (String task : todo)
{
System.out.println("Tâche : " + task);
}Exemple d’utilisation
import java.util.ArrayList;
import java.util.Scanner;
public class TodoApp
{
public static void main(String[] args)
{
ArrayList<String> todo = new ArrayList<>();
Scanner console = new Scanner(System.in);
while (true)
{
System.out.print("Saisissez une tâche (ou une ligne vide pour quitter) : ");
String task = console.nextLine();
if (task.isEmpty()) break;
todo.add(task);
}
System.out.println("Votre liste de tâches :");
for (int i = 0; i < todo.size(); i++)
{
System.out.println((i + 1) + ". " + todo.get(i));
}
}
}HashMap<K,V> - Dictionnaire
Liste trier par clé valeur.
Création
Pour créer un dictionnaire, on indique le premier type pour la clé, et le second pour la valeur.
import java.util.HashMap;
HashMap<String, String> phonebook = new HashMap<String, String>();
HashMap<String, Integer> grades = new HashMap<String, Integer>(); // nom → note
HashMap<Integer, String> users = new HashMap<Integer, String>(); // id → nom
HashMap<String, Boolean> flags = new HashMap<String, Boolean>(); // clé → valeur booléenneMéthode
put(key, value) - ajout d’élément
Les clé sont unique, et si on ajoute une nouvelle valeur avec une clé existante, l’ancienne valeur est écrasé.
phonebook.put("Alice", "+380501112233");
phonebook.put("Bob", "+380671234567");get(key) - obtenir une valeur
Si la clé n’existe pas, on obtient une valeur null.
System.out.println(phonebook.get("Alice"));containsKey(key) - vérifier la présence
System.out.println(phonebook.containsKey("Charlie"));
// utilisation avec un ajout
if (phonebook.containsKey("Alice"))
{
System.out.println("Alice a déjà un numéro!");
}
else
{
phonebook.put("Alice", "+10111111111");
}remove(key) - supprimer une entrée
phonebook.remove("Bob");
System.out.println(phonebook.get("Bob"));entrySet() - Parcourir les paires
Permet d’afficher les clé valeurs du dictionnaire
for (var entry : phonebook.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}Utilisation dans un compteur de mot
String text = "java java core java";
HashMap<String, Integer> freq = new HashMap<String, Integer>();
// on sépare chaque mot de la chaine
for (String w : text.split(" "))
{
Integer old = freq.get(w); // verifie si le mot est present
freq.put(w, (old == null) ? 1 : old + 1); // si null on passe la valeur a 1, puis on increment
}
System.out.println(freq);
// sortie: {core=1, java=3}Utilisation dans un annuaire
import java.util.HashMap;
import java.util.Scanner;
public class PhonebookApp {
public static void main(String[] args)
{
HashMap<String, String> phonebook = new HashMap<String, String>();
Scanner console = new Scanner(System.in);
while (true)
{
System.out.print("Saisissez un nom (ou une ligne vide pour quitter): ");
String name = console.nextLine();
if (name.isEmpty()) break;
System.out.print("Saisissez le numéro: ");
String phone = console.nextLine();
phonebook.put(name, phone);
}
System.out.println("Annuaire téléphonique:");
for (var entry : phonebook.entrySet())
{
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
}
}