L’interface List en Java
Sommaire
- 1- Objectifs
- 2- Introduction :
- 3- L'interface
List
- 4- Les classes implémentant List
- 4.1- ArrayList
- 4.1.1- Description:
- 4.1.2- Caractéristiques:
- 4.1.3- Syntaxe de Java ArrayList
- 4.1.4- Exemple:
- 4.1.5- Exercices:
- 4.2- LinkedList
- 4.2.1- Description:
- 4.2.2- Caractéristiques:
- 4.2.3- Syntaxe de Java LinkedList
- 4.2.4- Exemple:
- 4.2.5- Exercice:
- 4.3- Vector
- 4.3.1- Description:
- 4.3.2- Caractéristiques:
- 4.3.3- Syntaxe de Java Vector
- 4.3.4- Exemple:
- 4.4- Stack
- 4.4.1- Description:
- 4.4.2- Caractéristiques:
- 4.4.3- Syntaxe de Java Stack
- 4.4.4- Exemple:
- 5- Les principales différences entre ces collections Java
- 6- Méthodes de l’interface List
- 6.1-
int size()
: Détermine le nombre d'éléments dans une liste. - 6.2-
boolean isEmpty()
: Vérifie si la liste est vide. - 6.3-
boolean contains(Object o)
: Retourne true si l'objet spécifié est présent dans la liste. - 6.4-
add(E element)
: ajoute un élément à la fin de la liste. - 6.5-
add(int index, E element)
: insère un élément à une position donnée dans la liste. - 6.6-
remove(int index)
: supprime l’élément à la position donnée dans la liste. - 6.7-
get(int index)
: récupère l’élément à la position donnée dans la liste. - 6.8-
set(int index, E element)
: remplace l’élément à la position donnée dans la liste par un nouvel élément. - 7- Conclusion
- 8- Exercices d'application
- 8.1- Exercice 1 : Manipulation de ArrayList
- 8.2- Exercice 2 : Recherche et tri
- 8.3- Exercice 3 : Liste de listes (List<List<String>>)
- 8.4- Exercice 4 : Manipulation avec LinkedList
- 8.5- Exercice 5 : Utilisation de List avec des objets
- 8.5.1- Cours JAVA
L’interface List en Java
-
Objectifs
- Comprendre ce qu’est une interface en Java.
- Expliquer le rôle et l’importance de l’interface List dans la Collection Framework.
- Apprendre à déclarer et initialiser des listes à l’aide de différentes implémentations (ArrayList, LinkedList, etc.).
- Comprendre les différences entre les implémentations de List.
-
Introduction :
- Une collection en Java est représentée comme un conteneur qui regroupe tous les éléments en une seule unité. Par exemple , un dossier de courrier (groupe d’e-mails), un annuaire téléphonique (mappage de noms sur des numéros de téléphone).
- L’API Collections propose un ensemble d’interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections, chacune définie par une interface de base :
List
: collection d’éléments ordonnés qui accepte les doublons- Set : collection d’éléments non ordonnés par défaut qui n’accepte pas les doublons
- Map : collection sous la forme d’une association de paires clé/valeur
- Queue et Deque : collections qui stockent des éléments dans un certain ordre avant qu’ils ne soient extraits pour traitement
-
L’interface
List
- L’interface List en Java, qui fait partie de la bibliothèque standard, permet de stocker et de manipuler des éléments dans une liste ordonnée (éléments indexés).
- Pour comprendre cette interface, il est important de connaître quelques informations clés.
- List étend l’interface Collection et propose des méthodes spécifiques pour la manipulation de listes.
- Les éléments d’une liste sont ordonnés en fonction de leur position, et chaque élément peut être identifié par son index, c’est-à-dire sa position dans la liste.
- Les listes peuvent contenir des éléments en double, contrairement aux ensembles qui ne peuvent pas avoir de doublons. Certaines implémentations courantes de List comprennent
ArrayList
,LinkedList
etVector
. -
Les classes implémentant List
- En Java, l’interface
List
fait partie du framework des collections et représente une séquence ordonnée d’éléments. - Une
List
permet de stocker des éléments en conservant leur ordre d’insertion, d’accéder aux éléments par leur index, et de gérer des éléments en doublon. - Il est important de noter que
List
est une interface, ce qui signifie qu’elle ne peut pas être instanciée directement. - Il faut utiliser une implémentation concrète comme
ArrayList
ouLinkedList
pour créer une liste et manipuler ses éléments. - Le framework propose des classes qui implémentent l’interface List :
Vector
,ArrayList
,LinkedList
etCopyOnWriteArrayList
. - Vous pouvez déclarer les différentes instances de la liste de la manière suivante :
- Plusieurs classes dans le JDK implémentent l’interface List, chacune ayant des caractéristiques uniques. Voici les principales classes qui implémentent List :
-
ArrayList
-
Description:
ArrayList
est une implémentation de List basée sur un tableau dynamique. Elle permet un accès rapide (en temps constant) à un élément par son index, mais les opérations d’insertion et de suppression peuvent être lentes si elles nécessitent de déplacer beaucoup d’éléments.-
Caractéristiques:
- Taille dynamique (s’ajuste automatiquement).
- Accès rapide aux éléments par leur index.
- Permet les éléments en doublon.
- Non-synchronisée (non-thread-safe).
-
Syntaxe de Java ArrayList
- Avant la création d’un ArrayList, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util.
import java.util.ArrayList;
- La syntaxe générale est la suivante :
ArrayList<Type> arrayList= new ArrayList<>();
- « Type » correspond au type de données respectif de l’
ArrayList Java
. -
Exemple:
- Avec la classe ArrayList, les opérations telles que l’ajout ou la suppression d’éléments ne sont pas exécutées avec des opérateurs Java, mais avec des méthodes prédéfinies.
-
Exercices:
- Créer un programme Java qui permet de gérer une liste d’étudiants. Le programme doit permettre d’ajouter, de supprimer, de rechercher et d’afficher des étudiants dans une liste.
- Demandez à l’utilisateur de saisir un nombre d’étudiants à ajouter.
- Pour chaque étudiant, demandez à l’utilisateur de saisir le nom, puis ajoutez-le à la liste.
- Affichez tous les étudiants présents dans la liste.
- Demandez à l’utilisateur de saisir le nom d’un étudiant à rechercher dans la liste.
- Si l’étudiant est trouvé, affichez un message indiquant que l’étudiant est présent dans la liste avec sa position (index).
- Si l’étudiant n’est pas trouvé, indiquez qu’il n’est pas présent.
- Demandez à l’utilisateur de saisir le nom d’un étudiant à supprimer de la liste.
- Si l’étudiant est trouvé, supprimez-le de la liste et affichez un message confirmant la suppression.
- Si l’étudiant n’est pas trouvé, indiquez qu’il n’est pas présent dans la liste.
- Après les opérations de recherche et de suppression, affichez la liste finale des étudiants.
List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack
Les ArrayList utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir «
Integer
» et non « int« .
ArrayList <String> arrayList= new ArrayList<>();
ArrayList <Integer> arrayList= new ArrayList<>();
import java.util.ArrayList;
import java.util.List;
public class ExempleArrayList {
public static void main(String[] args) {
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add("Python");
arrayList.add("C++");
System.out.println("ArrayList: " + arrayList);
}
}
Solution
package listes;
import java.util.ArrayList;
import java.util.Scanner;
public class activite_01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList<String> etudiants = new ArrayList<>();
// Demander le nombre d'étudiants à ajouter
System.out.print("Combien d'étudiants voulez-vous ajouter ? ");
int nombreEtudiants = scanner.nextInt();
scanner.nextLine(); // Consommer le retour à la ligne
// Ajouter les étudiants à la liste
for (int i = 0; i < nombreEtudiants; i++) {
System.out.print("Entrez le nom de l'étudiant " + (i + 1) + " : ");
String nom = scanner.nextLine();
etudiants.add(nom);
}
// Afficher la liste des étudiants
System.out.println("\nListe des étudiants : " + etudiants);
// Rechercher un étudiant dans la liste
System.out.print("\nEntrez le nom de l'étudiant à rechercher : ");
String nomRecherche = scanner.nextLine();
if (etudiants.contains(nomRecherche)) {
System.out.println(nomRecherche + " est présent dans la liste à l'index " + etudiants.indexOf(nomRecherche));
} else {
System.out.println(nomRecherche + " n'est pas présent dans la liste.");
}
// Supprimer un étudiant de la liste
System.out.print("\nEntrez le nom de l'étudiant à supprimer : ");
String nomSuppression = scanner.nextLine();
if (etudiants.remove(nomSuppression)) {
System.out.println(nomSuppression + " a été supprimé de la liste.");
} else {
System.out.println(nomSuppression + " n'est pas présent dans la liste.");
}
// Afficher la liste finale des étudiants
System.out.println("\nListe finale des étudiants : " + etudiants);
scanner.close();
}
}
LinkedList
-
Description:
- LinkedList est une implémentation de List basée sur une liste chaînée doubly linked (chaînée dans les deux sens). Cela rend l'insertion et la suppression d'éléments au début ou au milieu de la liste plus efficaces par rapport à ArrayList, mais l'accès par index est plus lent.
-
Caractéristiques:
- Insertion/suppression rapide au début/milieu de la liste.
- Accès par index plus lent que ArrayList.
- Peut être utilisée comme une Deque (double-ended queue) grâce à ses méthodes spécifiques.
- Permet les éléments en doublon.
- Non-synchronisée (non-thread-safe).
-
Syntaxe de Java LinkedList
- Avant la création d’une LinkedList, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util.
import java.util.LinkedList;
- La syntaxe générale est la suivante :
LinkedList<Type> linkedList = new LinkedList<>();
- "Type" correspond au type de données respectif de la
LinkedList
Java. -
Exemple:
-
Exercice:
- Créer un programme Java qui permet de gérer une liste d'étudiants en utilisant une LinkedList. Le programme doit permettre d'ajouter, de supprimer, de rechercher et d'afficher des étudiants dans cette liste.
- Demandez à l'utilisateur de saisir un nombre d'étudiants à ajouter.
- Pour chaque étudiant, demandez à l'utilisateur de saisir le nom, puis ajoutez-le à la LinkedList.
- Affichez tous les étudiants présents dans la LinkedList.
- Demandez à l'utilisateur de saisir le nom d'un étudiant à rechercher dans la LinkedList.
- Si l'étudiant est trouvé, affichez un message indiquant que l'étudiant est présent dans la liste avec sa position (index).
- Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent dans la liste.
- Demandez à l'utilisateur de saisir le nom d'un étudiant à supprimer de la LinkedList.
- Si l'étudiant est trouvé, supprimez-le de la liste et affichez un message confirmant la suppression.
- Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent dans la liste.
- Après les opérations de recherche et de suppression, affichez la liste finale des étudiants.
Les LinkedList utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "
Integer
" et non "int".
LinkedList <String> linkedList = new LinkedList<>();
LinkedList <Integer> linkedList = new LinkedList<>();
import java.util.LinkedList;
import java.util.List;
public class ExempleLinkedList {
public static void main(String[] args) {
List<String> linkedList = new LinkedList<>();
linkedList.add("Java");
linkedList.add("Python");
linkedList.add("C++");
System.out.println("LinkedList: " + linkedList);
}
}
Solution
import java.util.LinkedList;
import java.util.Scanner;
public class GestionEtudiants {
public static void main(String[] args) {
// Création de la LinkedList pour stocker les noms des étudiants
LinkedList<String> etudiants = new LinkedList<>();
Scanner scanner = new Scanner(System.in);
// Demande à l'utilisateur le nombre d'étudiants à ajouter
System.out.print("Combien d'étudiants souhaitez-vous ajouter ? ");
int nombreEtudiants = scanner.nextInt();
scanner.nextLine(); // Consomme la nouvelle ligne après l'entier
// Ajout des étudiants dans la LinkedList
for (int i = 0; i < nombreEtudiants; i++) {
System.out.print("Entrez le nom de l'étudiant " + (i + 1) + " : ");
String nom = scanner.nextLine();
etudiants.add(nom);
}
// Affichage des étudiants dans la LinkedList
System.out.println("Liste des étudiants : " + etudiants);
// Recherche d'un étudiant dans la LinkedList
System.out.print("Entrez le nom de l'étudiant à rechercher : ");
String rechercheNom = scanner.nextLine();
int indexRecherche = etudiants.indexOf(rechercheNom);
if (indexRecherche != -1) {
System.out.println(rechercheNom + " est présent dans la liste à l'indice " + indexRecherche);
} else {
System.out.println(rechercheNom + " n'est pas présent dans la liste.");
}
// Suppression d'un étudiant de la LinkedList
System.out.print("Entrez le nom de l'étudiant à supprimer : ");
String supprimerNom = scanner.nextLine();
if (etudiants.remove(supprimerNom)) {
System.out.println(supprimerNom + " a été supprimé de la liste.");
} else {
System.out.println(supprimerNom + " n'est pas présent dans la liste.");
}
// Affichage de la liste finale des étudiants
System.out.println("Liste finale des étudiants : " + etudiants);
}
}
Vector
-
Description:
- Vector est similaire à ArrayList, mais il est synchronisé, ce qui signifie qu'il est thread-safe (c'est-à-dire qu'il peut être utilisé dans des contextes où plusieurs threads accèdent à la liste simultanément). Cependant, cette synchronisation rend Vector moins performant que ArrayList en termes de vitesse.
-
Caractéristiques:
- Synchronisé (thread-safe).
- Taille dynamique (s'ajuste automatiquement).
- Accès rapide aux éléments par leur index.
- Permet les éléments en doublon.
-
Syntaxe de Java Vector
- Avant la création d’un `Vector`, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util.
import java.util.Vector;
- La syntaxe générale est la suivante :
Vector<Type> vector = new Vector<>();
- "Type" correspond au type de données respectif de l'
Vector Java
. -
Exemple:
Les `Vector` utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "
Integer
" et non "int".Vector<String> vector = new Vector<>();
Vector<Integer> vector = new Vector<>();
import java.util.List;
import java.util.Vector;
public class ExempleVector {
public static void main(String[] args) {
List<String> vector = new Vector<>();
vector.add("Java");
vector.add("Python");
vector.add("C++");
System.out.println("Vector: " + vector);
}
}
Stack
-
Description:
- Stack est une sous-classe de Vector qui représente une pile (LIFO - Last In, First Out). Les éléments sont ajoutés et retirés du haut de la pile.
-
Caractéristiques:
- Hérite de Vector, donc thread-safe.
- Suit le principe LIFO (Last In, First Out).
- Permet les éléments en doublon.
-
Syntaxe de Java Stack
- Avant la création d’une `Stack`, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util.
import java.util.Stack;
- La syntaxe générale est la suivante :
Stack<Type> stack = new Stack<>();
- "Type" correspond au type de données respectif de la
Stack Java
. -
Exemple:
Les `Stack` utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "
Integer
" et non "int".Stack<String> stack = new Stack<>();
Stack<Integer> stack = new Stack<>();
import java.util.Stack;
public class ExempleStack {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
stack.push("Java");
stack.push("Python");
stack.push("C++");
System.out.println("Stack avant pop: " + stack);
stack.pop();
System.out.println("Stack après pop: " + stack);
}
}
Les principales différences entre ces collections Java
Caractéristique | ArrayList | LinkedList | Vector | Stack |
---|---|---|---|---|
Structure interne | Tableau dynamique | Liste doublement chaînée | Tableau dynamique | Hérite de Vector , basé sur un tableau dynamique |
Accès aux éléments | Rapide (O(1)) | Plus lent (O(n)) | Rapide (O(1)) | Accès LIFO (Last In, First Out) |
Insertion/Suppression | Lent au milieu ou au début (O(n)) | Efficace aux extrémités (O(1)) | Lent au milieu ou au début (O(n)) | Utilise push , pop , peek (LIFO) |
Synchronisation | Non synchronisé, pas thread-safe | Non synchronisé, pas thread-safe | Synchronisé, thread-safe | Synchronisé, car hérite de Vector |
Utilisation principale | Accès rapide, opérations de recherche fréquentes | Insertion/suppression fréquentes aux extrémités | Besoin de thread-safety sans synchronisation manuelle | Scénarios nécessitant une structure de pile (LIFO) |
Méthodes de l’interface List
- Voici quelques-unes des méthodes les plus couramment utilisées de l'interface List :
-
int size()
: Détermine le nombre d'éléments dans une liste. -
boolean isEmpty()
: Vérifie si la liste est vide. -
boolean contains(Object o)
: Retourne true si l'objet spécifié est présent dans la liste. -
add(E element)
: ajoute un élément à la fin de la liste. -
add(int index, E element)
: insère un élément à une position donnée dans la liste. -
remove(int index)
: supprime l’élément à la position donnée dans la liste. -
get(int index)
: récupère l’élément à la position donnée dans la liste. -
set(int index, E element)
: remplace l’élément à la position donnée dans la liste par un nouvel élément.
import java.util.ArrayList;
import java.util.List;
public class ExampleSize {
public static void main(String[] args) {
// Créer une liste de chaînes de caractères
List<String> fruits = new ArrayList<>();
// Ajouter des éléments à la liste
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
// Utiliser la méthode size() pour obtenir le nombre d'éléments dans la liste
int numberOfFruits = fruits.size();
// Afficher le nombre d'éléments dans la liste
System.out.println("The number of fruits in the list is: " + numberOfFruits);
}
}
import java.util.ArrayList;
import java.util.List;
public class ExampleIsEmpty {
public static void main(String[] args) {
// Créer une liste de chaînes de caractères
List<String> fruits = new ArrayList<>();
// Vérifier si la liste est vide
if (fruits.isEmpty()) {
System.out.println("The list is empty.");
} else {
System.out.println("The list is not empty.");
}
// Ajouter un élément à la liste
fruits.add("Apple");
// Vérifier à nouveau si la liste est vide
if (fruits.isEmpty()) {
System.out.println("The list is empty.");
} else {
System.out.println("The list is not empty.");
}
}
}
import java.util.ArrayList;
import java.util.List;
public class ExampleContains {
public static void main(String[] args) {
// Créer une liste de chaînes de caractères
List<String> fruits = new ArrayList<>();
// Ajouter des éléments à la liste
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
// Vérifier si la liste contient "Banana"
if (fruits.contains("Banana")) {
System.out.println("The list contains Banana.");
} else {
System.out.println("The list does not contain Banana.");
}
// Vérifier si la liste contient "Grapes"
if (fruits.contains("Grapes")) {
System.out.println("The list contains Grapes.");
} else {
System.out.println("The list does not contain Grapes.");
}
}
}
import java.util.List;
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
System.out.println("Liste après ajout des éléments : " + list);
}
}
import java.util.List;
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Cherry");
list.add(1, "Banana"); // Insère "Banana" à l'indice 1
System.out.println("Liste après insertion d'un élément à l'indice 1 : " + list);
}
}
import java.util.List;
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
list.remove(1); // Supprime l'élément à l'indice 1
System.out.println("Liste après suppression de l'élément à l'indice 1 : " + list);
}
}
import java.util.List;
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
String element = list.get(1); // Récupère l'élément à l'indice 1
System.out.println("Élément à l'indice 1 : " + element);
}
}
import java.util.List;
import java.util.ArrayList;
public class ListExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
list.set(1, "Blueberry"); // Remplace l'élément à l'indice 1 par "Blueberry"
System.out.println("Liste après modification de l'élément à l'indice 1 : " + list);
}
}
Conclusion
- Chacune des classes qui implémentent List a ses propres avantages et inconvénients, en fonction du contexte d'utilisation :
- ArrayList est idéale pour les scénarios où l'accès rapide par index est crucial.
- LinkedList est préférable pour les applications nécessitant des insertions ou suppressions fréquentes.
- Vector et Stack sont utilisés lorsque la synchronisation (thread safety) est nécessaire.
Exercices d'application
-
Exercice 1 : Manipulation de ArrayList
- Créez une ArrayList de chaînes de caractères pour stocker les noms des jours de la semaine. Utilisez différentes méthodes de l'interface List pour manipuler la liste.
- Créez une ArrayList<String>.
- Ajoutez les noms des jours de la semaine ("Lundi", "Mardi", etc.) à la liste.
- Insérez un jour supplémentaire au milieu de la liste.
- Remplacez un jour par un autre.
- Affichez le nombre total de jours dans la liste.
- Supprimez un jour spécifique de la liste.
- Affichez la liste complète.
-
Exercice 2 : Recherche et tri
- Description : Créez une liste d'entiers et effectuez des opérations de recherche et de tri.
- Créez une ArrayList<Integer> et ajoutez plusieurs nombres aléatoires.
- Recherchez un nombre spécifique dans la liste et affichez son index.
- Triez la liste par ordre croissant.
- Affichez la liste triée.
- Recherchez le plus grand et le plus petit nombre de la liste.
-
Exercice 3 : Liste de listes (List<List<String>>)
- Description : Créez une liste qui contient d'autres listes de chaînes de caractères.
- Créez une ArrayList pour représenter chaque classe d'une école (par exemple, "Classe 1", "Classe 2").
- Dans chaque classe, ajoutez des noms d'étudiants.
- Ajoutez chaque liste de classe à une liste principale.
- Parcourez et affichez les étudiants de chaque classe.
-
Exercice 4 : Manipulation avec LinkedList
- Description : Travaillez avec une LinkedList pour manipuler une liste de tâches à faire.
- Créez une LinkedList<String> pour stocker des tâches à faire.
- Ajoutez des tâches à la fin de la liste.
- Ajoutez une tâche au début de la liste.
- Supprimez la première et la dernière tâche de la liste.
- Affichez la liste complète.
-
Exercice 5 : Utilisation de List avec des objets
- Description : Créez une liste pour gérer une collection d'objets personnalisés.
- Créez une classe Produit avec des attributs comme nom et prix.
- Créez une ArrayList<Produit> pour stocker plusieurs objets Produit.
- Ajoutez plusieurs produits à la liste.
- Affichez tous les produits dans la liste.
- Modifiez le prix d'un produit spécifique dans la liste.
- Supprimez un produit de la liste par son nom.
Solution
import java.util.ArrayList;
import java.util.List;
public class Exercice1 {
public static void main(String[] args) {
List<String> jours = new ArrayList<>();
// Ajout des jours de la semaine
jours.add("Lundi");
jours.add("Mardi");
jours.add("Mercredi");
jours.add("Jeudi");
jours.add("Vendredi");
jours.add("Samedi");
jours.add("Dimanche");
// Insertion d'un jour supplémentaire
jours.add(3, "Jour Supplémentaire");
// Remplacement d'un jour
jours.set(1, "Nouveau Mardi");
// Affichage du nombre total de jours
System.out.println("Nombre total de jours : " + jours.size());
// Suppression d'un jour
jours.remove("Vendredi");
// Affichage de la liste complète
System.out.println("Liste des jours : " + jours);
}
}
Solution
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Exercice2 {
public static void main(String[] args) {
List nombres = new ArrayList<>();
// Ajout de nombres aléatoires
nombres.add(42);
nombres.add(15);
nombres.add(89);
nombres.add(3);
nombres.add(58);
// Recherche d'un nombre spécifique
int index = nombres.indexOf(89);
System.out.println("L'index du nombre 89 est : " + index);
// Tri de la liste
Collections.sort(nombres);
// Affichage de la liste triée
System.out.println("Liste triée : " + nombres);
// Recherche du plus grand et du plus petit nombre
int max = Collections.max(nombres);
int min = Collections.min(nombres);
System.out.println("Le plus grand nombre est : " + max);
System.out.println("Le plus petit nombre est : " + min);
}
}
Solution
import java.util.ArrayList;
import java.util.List;
public class Exercice3 {
public static void main(String[] args) {
List<List<String>> ecole = new ArrayList<>();
// Classe 1
List<String> classe1 = new ArrayList<>();
classe1.add("Alice");
classe1.add("Bob");
// Classe 2
List<String> classe2 = new ArrayList<>();
classe2.add("Charlie");
classe2.add("David");
// Ajout des classes à la liste principale
ecole.add(classe1);
ecole.add(classe2);
// Affichage des étudiants par classe
for (int i = 0; i < ecole.size(); i++) {
System.out.println("Classe " + (i + 1) + " : " + ecole.get(i));
}
}
}
Solution
import java.util.LinkedList;
import java.util.List;
public class Exercice4 {
public static void main(String[] args) {
List<String> toDoList = new LinkedList<>();
// Ajout de tâches
toDoList.add("Faire les courses");
toDoList.add("Étudier le Java");
toDoList.add("Faire du sport");
// Ajout d'une tâche au début de la liste
((LinkedList<String>) toDoList).addFirst("Se réveiller tôt");
// Suppression de la première et dernière tâche
((LinkedList<String>) toDoList).removeFirst();
((LinkedList<String>) toDoList).removeLast();
// Affichage de la liste complète
System.out.println("Liste des tâches : " + toDoList);
}
}
Solution
import java.util.ArrayList;
import java.util.List;
class Produit {
String nom;
double prix;
Produit(String nom, double prix) {
this.nom = nom;
this.prix = prix;
}
@Override
public String toString() {
return nom + " - " + prix + " €";
}
}
public class Exercice5 {
public static void main(String[] args) {
List produits = new ArrayList<>();
// Ajout de produits
produits.add(new Produit("Ordinateur", 800.0));
produits.add(new Produit("Téléphone", 500.0));
produits.add(new Produit("Tablette", 300.0));
// Affichage des produits
System.out.println("Produits disponibles : " + produits);
// Modification du prix d'un produit
for (Produit p : produits) {
if (p.nom.equals("Téléphone")) {
p.prix = 450.0;
}
}
// Suppression d'un produit par son nom
produits.removeIf(p -> p.nom.equals("Tablette"));
// Affichage des produits après modification
System.out.println("Produits après modification : " + produits);
}
}
Solution