Tableaux en Java
Sommaire
- 1- Objectifs
- 2- Qu'est-ce qu'un tableau ?
- 3- Déclaration et Initialisation d'un Tableau
- 3.1- Déclaration d'un Tableau
- 3.2- Initialisation d'un Tableau
- 3.2.1- Initialisation avec une taille spécifiée :
- 3.2.2- Initialisation avec des valeurs spécifiques :
- 3.3- Longueur de tableau en Java
- 4- Accès aux Éléments du Tableau
- 4.1- Parcourir un tableau
- 4.1.1- Boucle for :
- 4.1.2- Boucle for-each :
- 4.2- Taille d'un Tableau
- 4.3- Activités :
- 4.3.1- Activité:01 :
- 5- Tableau de tableaux (ou tableau multidimensionnels)
- 5.1- Déclaration d'un tableau multidimensionnel :
- 5.2- Accès aux éléments d'un tableau multidimensionnel :
- 5.3- Activités :
- 5.3.1- Activité:01 :
- 5.3.2- Activité:02 :
- 5.3.3- Activité:03 :
- 5.3.4- Activité:04 :
- 5.3.5- Activité:05 :
- 6- Méthodes Utiles pour les Tableaux
- 6.1- Trier un Tableau
- 6.2- Rechercher un Élément
- 6.3- Limitations des Tableaux
- 6.4- Somme des éléments d'un tableau
- 7- Tableaux Dynamiques avec ArrayList
- 7.1- Exemples Complets
- 7.1.1- Cours JAVA
Tableaux en Java
-
Objectifs
- Comprendre le Concept de Tableau
- Déclarer et Initialiser des Tableaux
- Manipuler les Éléments d’un Tableau
- Travailler avec des Tableaux Multidimensionnels
-
Qu’est-ce qu’un tableau ?
- Un tableau est une structure de données qui permet de stocker un ensemble d’éléments du même type. Imaginez-le comme une série de cellules numérotées, où chaque cellule peut contenir une valeur spécifique. Ces cellules sont organisées de manière séquentielle, et chaque cellule peut être accédée à l’aide de son numéro, appelé index.
- En Java, un tableau est homogène, ce qui signifie que toutes les cellules du tableau contiennent des éléments du même type. Par exemple :
- Un tableau d’entiers (int[]) ne peut contenir que des valeurs de type int.
- Un tableau de chaînes (String[]) ne peut contenir que des valeurs de type String.
- Un tableau d’objets d’une classe spécifique (par exemple, Dog[] pour une classe Dog) ne peut contenir que des instances de cette classe.
- Cela signifie que Java impose une contrainte de type sur les tableaux : vous ne pouvez pas mélanger différents types de données dans un même tableau. Par exemple, vous ne pouvez pas mettre un entier dans la première cellule, une chaîne dans la seconde, et un objet Dog dans la troisième. Chaque cellule d’un tableau doit contenir un élément du même type que les autres.
-
Déclaration et Initialisation d’un Tableau
-
Déclaration d’un Tableau
- Comme toute variable, un tableau doit être déclaré en Java. Cela peut être fait de deux manières. Ils sont équivalents, mais la première méthode est plus cohérente avec le style Java. La seconde est un héritage du langage C : de nombreux programmeurs C sont passés à Java, et une méthode alternative a été conservée pour leur commodité. Le tableau montre les deux manières de déclarer un tableau en Java:
- Pour déclarer un tableau en Java, vous spécifiez le type des éléments qu’il contiendra suivi de
[]
, puis le nom du tableau. Par exemple : -
Initialisation d’un Tableau
- Une fois le tableau déclaré, vous pouvez l’initialiser en spécifiant sa taille (nombre d’éléments qu’il contiendra) ou en fournissant directement les éléments.
-
Initialisation avec une taille spécifiée :
-
Initialisation avec des valeurs spécifiques :
-
Longueur de tableau en Java
- La longueur d’un tableau est le nombre d’éléments que le tableau est conçu pour contenir. La longueur d’un tableau ne peut pas être modifiée après sa création. Veuillez noter que les éléments du tableau sont numérotés à partir de zéro en Java. Ainsi, si nous avons un tableau de 10 éléments, alors l’indice du premier élément est 0 et l’indice du dernier est 9.
- Vous pouvez obtenir la longueur du tableau en utilisant la variable de longueur .
- Exemple:
-
Accès aux Éléments du Tableau
- Les éléments d’un tableau sont accessibles en utilisant leur index. L’index du premier élément est 0, et l’index du dernier élément est longueur du tableau – 1.
-
Parcourir un tableau
- Il existe plusieurs manières de parcourir un tableau :
-
Boucle for :
- Pour parcourir un tableau, il est possible d’utiliser l’instruction
for
. Elle existe depuis la version 1.0 de Java. Cefor
doit avoir trois expressions placées entre parenthèses et séparées par des caractères;
. Ensuite le corps de la boucle est placé entre accolades -
Boucle for-each :
-
Taille d'un Tableau
- La taille d'un tableau (le nombre d'éléments qu'il contient) peut être obtenue via l'attribut length.
-
Activités :
-
Activité:01 :
- Écrire un programme Java qui permet de rechercher un élément spécifique dans un tableau et d'afficher sa position (indice).
- Déclarez et initialisez un tableau d'entiers avec des valeurs prédéfinies.
- Demandez à l'utilisateur de saisir un nombre qu'il souhaite rechercher dans le tableau.
- Parcourez le tableau pour vérifier si le nombre saisi est présent.
- Si le nombre est trouvé, affichez l'indice de sa position dans le tableau. Si le nombre n'est pas trouvé, indiquez que le nombre n'est pas présent dans le tableau.
-
Tableau de tableaux (ou tableau multidimensionnels)
- Un tableau de tableaux est appelé un tableau à deux dimensions. C'est comme un tableau qui a un numéro de ligne et un numéro de colonne.
-
Déclaration d'un tableau multidimensionnel :
- Les tableaux en Java peuvent être multidimensionnels, comme les tableaux à deux dimensions (matrices). Ils sont déclarés comme suit :
- Vous pouvez également initialiser directement un tableau multidimensionnel avec des valeurs :
-
Accès aux éléments d'un tableau multidimensionnel :
-
Activités :
-
Activité:01 :
- Créez un tableau 2D de taille 3x3 (3 lignes et 3 colonnes) qui contient des entiers. Initialisez le tableau avec les valeurs de 1 à 9, puis affichez son contenu ligne par ligne.
-
Activité:02 :
- Créez un tableau 2D de taille 4x4 contenant des entiers aléatoires compris entre 1 et 10. Calculez et affichez la somme de tous les éléments de ce tableau.
- Conseils: Utilisez deux boucles imbriquées pour parcourir tous les éléments du tableau et les additionner.
-
Activité:03 :
- Créez un programme Java qui crée un tableau 2D de taille 5x5 contenant des entiers aléatoires compris entre 1 et 20. Le programme demande ensuite à l'utilisateur de saisir un nombre et vérifie si ce nombre est présent dans le tableau. Si le nombre est trouvé, il affiche les coordonnées (indice de ligne et de colonne) du nombre.
-
Activité:04 :
- Créer un programme Java qui crée une matrice carrée de taille 3x3, calcule sa transposée (où les lignes deviennent les colonnes et vice versa), puis affiche la matrice transposée.
-
Activité:05 :
- Créez un programme Java qui demande à l'utilisateur de saisir les dimensions (nombre de lignes et de colonnes) d'un tableau à deux dimensions. Ensuite, le programme demande à l'utilisateur de remplir chaque case du tableau, en affichant les coordonnées correspondantes pour chaque donnée à saisir.
- Si l'utilisateur saisit un caractère autre qu'un nombre, il est invité à ressaisir la valeur jusqu'à ce qu'un nombre valide soit saisi. L'incrémentation de la position dans le tableau ne se réalise pas tant que l'utilisateur n'a pas saisi un nombre valide.
- Une fois que toutes les cases du tableau sont remplies, le programme doit :
- Afficher le tableau complet.
- Calculer et afficher la somme de tous les nombres du tableau.
- Compter et afficher le nombre de valeurs paires et impaires présentes dans le tableau.
-
Méthodes Utiles pour les Tableaux
- Java fournit plusieurs classes et méthodes pour faciliter le travail avec les tableaux.
-
Trier un Tableau
- Vous pouvez trier un tableau en utilisant Arrays.sort() :
-
Rechercher un Élément
- Pour rechercher un élément dans un tableau trié, utilisez
Arrays.binarySearch()
: -
Limitations des Tableaux
- Taille Fixe : Une fois qu'un tableau est initialisé, sa taille ne peut pas être modifiée.
- Homogénéité : Tous les éléments d'un tableau doivent être du même type.
-
Somme des éléments d'un tableau
-
Tableaux Dynamiques avec ArrayList
- En Java, si vous avez besoin d'une structure de tableau qui peut changer de taille, utilisez ArrayList :
-
Exemples Complets
- Exemple 1 : Somme des Éléments d'un Tableau
- Exemple 2 : Tableau à Deux Dimensions
int[] tableauEntiers;
String[] tableauChaines;
Définition de tableau | Explications complémentaires |
---|---|
int [] tb; | Définit un tableau d’entiers non encore initialisé. | int [] tb = new int[10]; | Définit un tableau de dix entiers. Il n’est plus possible de changer la taille de ce tableau. | int [] tb1, tb2; | Comme les crochets sont placés à gauche des noms de variables ils s’appliquent à toutes ces variables. On est donc en train de définir deux tableaux d’entiers, tous deux non initialisés. | int [] tb1 = new int[5], tb2 = new int[10]; | Définit un premier tableau de cinq entiers, puis un second de dix entiers. | int tb[] = new int[10], value = 10; | Définit un tableau de dix entiers ainsi qu’une variable (value) de type entier. Les crochets ne s’appliquent uniquement qu’à tb car ils sont placés à la droite du nom de la variable. | String [] strValues = new String[5]; | Définit un tableau pouvant contenir jusqu’à cinq chaînes de caractères. | String [] strValues = { « toto », « titi », « tata » }; | Définit un tableau de chaînes de caractères contenant les trois valeurs stockées entre les accolades : on parle de liste d’initialisation. |
L’initialisation d’un tableau peut s’effectuer soit via un appel à l’opérateur
new
, soit via une liste d’initialisation.
int[] tableauEntiers = new int[5]; // Tableau pouvant contenir 5 entiers
int[] tableauEntiers = {1, 2, 3, 4, 5}; // Tableau contenant 5 entiers
int[] myArray = new int[10];
System.out.println(myArray.length);
int[] tableau = {10, 20, 30, 40, 50};
int premierElement = tableau[0]; // premierElement = 10
int dernierElement = tableau[4]; // dernierElement = 50
int[] tableau = {10, 20, 30, 40, 50};
for (int i = 0; i < tableau.length; i++) {
System.out.println("Élément à l'index " + i + " : " + tableau[i]);
}
for (int element : tableau) {
System.out.println("Élément : " + element);
}
int taille = tableau.length;
System.out.println("Taille du tableau : " + taille);
Solution
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Affichage du tableau
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
int[][] matrice = new int[3][3]; // Tableau de 3x3
int[][] matrice = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int valeur = matrice[1][2]; // valeur = 6 (deuxième ligne, troisième colonne)
Solution
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Affichage du tableau
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
Solution
import java.util.Random;
public class Main {
public static void main(String[] args) {
// Déclaration et initialisation du tableau 2D de taille 4x4
int[][] matrix = new int[4][4];
int sum = 0;
// Création d'un objet Random pour générer des nombres aléatoires
Random random = new Random();
// Remplir le tableau avec des nombres aléatoires et calculer la somme
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = random.nextInt(10) + 1; // Génère un nombre entre 1 et 10
sum += matrix[i][j];
}
}
// Affichage du tableau 2D
System.out.println("Tableau 2D :");
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
// Affichage de la somme de tous les éléments
System.out.println("\nSomme de tous les éléments : " + sum);
}
}
Solution
Scanner scanner = new Scanner(System.in);
System.out.print("Entrez un nombre à rechercher: ");
int nombre = scanner.nextInt();
// Parcours du tableau pour rechercher le nombre
boolean found = false;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (matrix[i][j] == nombre) {
System.out.println("Nombre trouvé à la position: (" + i + ", " + j + ")");
found = true;
break;
}
}
if (found) break;
}
if (!found) {
System.out.println("Nombre non trouvé.");
}
Solution
package tableaux;
public class transpose {
public static void main(String[] args) {
// Déclaration et initialisation de la matrice 3x3
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Déclaration de la matrice transposée 3x3
int[][] transpose = new int[3][3];
// Calcul de la transposée de la matrice
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
transpose[i][j] = matrix[j][i];
}
}
// Affichage de la matrice transposée
System.out.println("Matrice transposée :");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(transpose[i][j] + " ");
}
System.out.println();
}
}
}
Solution
package tableaux;
import java.util.Scanner;
public class saisie_tableau {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Demander à l'utilisateur de saisir les dimensions du tableau
System.out.print("Entrez le nombre de lignes : ");
int rows = scanner.nextInt();
System.out.print("Entrez le nombre de colonnes : ");
int cols = scanner.nextInt();
// Créer un tableau 2D
int[][] tableau = new int[rows][cols];
// Remplir le tableau avec les valeurs saisies par l'utilisateur
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
boolean validInput = false;
while (!validInput) {
System.out.print("Entrez un nombre pour la case [" + i + "][" + j + "] : ");
if (scanner.hasNextInt()) {
tableau[i][j] = scanner.nextInt();
validInput = true;
} else {
System.out.println("Entrée invalide. Veuillez entrer un nombre.");
scanner.next(); // Effacer l'entrée incorrecte
}
}
}
}
// Afficher le tableau complet
System.out.println("Tableau complet :");
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
System.out.print(tableau[i][j] + "\t");
}
System.out.println();
}
// Calculer la somme de tous les nombres
int sum = 0;
int evenCount = 0;
int oddCount = 0;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
sum += tableau[i][j];
if (tableau[i][j] % 2 == 0) {
evenCount++;
} else {
oddCount++;
}
}
}
// Afficher la somme des nombres
System.out.println("Somme de tous les nombres : " + sum);
// Afficher le nombre de valeurs paires et impaires
System.out.println("Nombre de valeurs paires : " + evenCount);
System.out.println("Nombre de valeurs impaires : " + oddCount);
}
}
import java.util.Arrays;
int[] tableau = {5, 2, 8, 3, 9};
Arrays.sort(tableau); // Tri le tableau
int index = Arrays.binarySearch(tableau, 3); // Renvoie l'index de l'élément 3
public class SommeTableaux
{
public static void main(String[] args)
{
int[] nb = {1,2,3,4,5,6,7,8,9};
int somme = java.util.stream.IntStream.of(nb).sum();
System.out.println(somme); //45
}
}
import java.util.ArrayList;
ArrayList liste = new ArrayList<>();
liste.add(10);
liste.add(20);
public class SommeTableau {
public static void main(String[] args) {
int[] tableau = {1, 2, 3, 4, 5};
int somme = 0;
for (int valeur : tableau) {
somme += valeur;
}
System.out.println("La somme des éléments est : " + somme);
}
}
public class Tableau2D {
public static void main(String[] args) {
int[][] matrice = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
for (int i = 0; i < matrice.length; i++) {
for (int j = 0; j < matrice[i].length; j++) {
System.out.print(matrice[i][j] + " ");
}
System.out.println();
}
}
}