fin des tp

DEV3.2/Genericite/exo1.java

@@ -0,0 +1,44 @@
+import java.util.ArrayList; // Importation de la classe ArrayList
+
+public class exo1 {
+    public static void main(String[] args) {
+        // Création des listes pour stocker différents types
+        ArrayList<Integer> listeInteger = new ArrayList<>(); // Liste pour les Integer
+        ArrayList<Float> listeFloat = new ArrayList<>();     // Liste pour les Float
+        ArrayList<Number> listeNumber = new ArrayList<>();   // Liste pour les Number (peut contenir Integer, Float, etc.)
+
+        // Ajout d'éléments à la liste Integer
+        listeInteger.add(1);
+        listeInteger.add(2);
+        listeInteger.add(3);
+
+        // Ajout d'éléments à la liste Float
+        listeFloat.add(1.0f);
+        listeFloat.add(2.0f);
+        listeFloat.add(3.0f);
+
+        // Affichage des listes pour vérifier leur contenu
+        System.out.println("Liste Integer: " + listeInteger);
+        System.out.println("Liste Float: " + listeFloat);
+        
+        // Transvaser les éléments de listeInteger et listeFloat vers listeNumber
+        listeNumber.addAll(listeInteger); // Ajoute tous les Integer à listeNumber
+        listeNumber.addAll(listeFloat);   // Ajoute tous les Float à listeNumber
+
+        // Affichage de la liste Number après les ajouts
+        System.out.println("Liste Number après ajout: " + listeNumber);
+
+        // Test de l'ajout direct de listeInteger à listeFloat (commenté car cela provoquerait une erreur)
+        // listeFloat.addAll(listeInteger); // Cela provoquerait une erreur de compilation, car Integer n'est pas un Float
+    }
+}
+
+
+/*
+Imports : Expliquent l'importation de la classe ArrayList.
+Création de listes : Indiquent les types des listes créées.
+Ajouts d'éléments : Spécifient ce que l'on ajoute à chaque liste.
+Affichage : Indiquent l'affichage des listes pour vérifier le contenu.
+Transfert des éléments : Expliquent ce qui se passe lors de l'utilisation de addAll.
+Commentaire sur l'ajout direct : Clarifie pourquoi l'ajout d'une liste à une autre pourrait provoquer une erreur.
+*/

DEV3.2/Genericite/exo2.java

@@ -0,0 +1,30 @@
+import java.util.Arrays; // Importation de la classe Arrays
+import java.util.Comparator; // Importation de l'interface Comparator
+
+public class exo2 {
+    public static void main(String[] args) {
+        // Affichage de tous les arguments de la ligne de commande
+        System.out.println("Arguments de la ligne de commande : " + Arrays.toString(args));
+
+        // Affichage des cinq premiers arguments (ou moins s'il n'y en a pas)
+        String[] premiersArguments = Arrays.copyOf(args, Math.min(args.length, 5));
+        System.out.println("Cinq premiers arguments : " + Arrays.toString(premiersArguments));
+
+        // Tri des arguments dans l'ordre du dictionnaire
+        Arrays.sort(args); // Tri des arguments
+
+        // Affichage des arguments triés
+        System.out.println("Arguments triés : " + Arrays.toString(args));
+
+        // Exemple d'utilisation d'un Comparator pour trier par longueur
+        Arrays.sort(args, Comparator.comparingInt(String::length)); // Tri par longueur
+        System.out.println("Arguments triés par longueur : " + Arrays.toString(args));
+    }
+}
+
+/*
+Affichage des arguments : Utilise Arrays.toString(args) pour afficher tous les arguments passés en ligne de commande.
+Affichage des cinq premiers arguments : Utilise Arrays.copyOf pour copier les cinq premiers arguments ou moins.
+Tri des arguments : Utilise Arrays.sort(args) pour trier les arguments par ordre lexicographique.
+Tri par longueur : Utilise un Comparator pour trier les arguments selon leur longueur.
+*/

DEV3.2/Genericite/exo3.java

@@ -0,0 +1,55 @@
+import java.util.HashMap; // Importation de HashMap
+import java.util.Map; // Importation de Map
+
+public class exo3 {
+    public static void main(String[] args) {
+        // Exemple de tableau d'objets
+        Object[] tableau = {1, "apple", 2, "banana", "apple", 3, 2, "banana", "banana"};
+        
+        // Appel de la méthode pour trouver l'élément le plus fréquent
+        Object elementFrequent = trouverElementFrequent(tableau);
+        
+        // Affichage du résultat
+        System.out.println("L'élément le plus fréquent est : " + elementFrequent);
+    }
+
+    public static Object trouverElementFrequent(Object[] tableau) {
+        Map<Object, Integer> compte = new HashMap<>(); // Dictionnaire pour compter les occurrences
+        int maxCount = 0; // Compteur maximal
+        Object elementFrequent = null; // Élément le plus fréquent
+
+        for (int i = 0; i < tableau.length; i++) {
+            Object element = tableau[i];
+            // Incrémenter le compteur pour l'élément actuel
+            compte.put(element, compte.getOrDefault(element, 0) + 1);
+
+            // Vérifier si cet élément a une fréquence plus élevée ou est le premier en cas d'égalité
+            if (compte.get(element) > maxCount || (compte.get(element) == maxCount && elementFrequent == null)) {
+                maxCount = compte.get(element);
+                elementFrequent = element;
+            }
+        }
+
+        return elementFrequent; // Retourner l'élément le plus fréquent
+    }
+}
+
+/*
+mportations :
+
+    HashMap pour stocker les occurrences des éléments.
+    Map pour la déclaration de la variable.
+
+Méthode principale :
+
+    Un tableau d'exemple tableau est créé contenant différents types d'objets.
+    La méthode trouverElementFrequent est appelée pour obtenir l'élément le plus fréquent.
+
+Méthode trouverElementFrequent :
+
+    Crée un HashMap pour compter les occurrences de chaque élément.
+    Utilise une boucle pour parcourir le tableau, mettre à jour les compteurs et vérifier si l'élément actuel est le plus fréquent.
+    En cas d'égalité, le premier élément rencontré avec cette fréquence est privilégié.
+
+Retourne l'élément le plus fréquent : La méthode renvoie l'élément qui apparaît le plus souvent dans le tableau.
+*/

DEV3.2/Genericite/exo4.java

@@ -0,0 +1,54 @@
+public class exo4<E> {
+    private E element;
+    private int frequence;
+
+    // Constructeur
+    public exo4(E element, int frequence) {
+        this.element = element;
+        this.frequence = frequence;
+    }
+
+    // Accesseur pour 'element'
+    public E getElement() {
+        return element;
+    }
+
+    // Modificateur pour 'element'
+    public void setElement(E element) {
+        this.element = element;
+    }
+
+    // Accesseur pour 'frequence'
+    public int getFrequence() {
+        return frequence;
+    }
+
+    // Modificateur pour 'frequence'
+    public void setFrequence(int frequence) {
+        this.frequence = frequence;
+    }
+
+    // Surcharge de la méthode toString()
+    @Override
+    public String toString() {
+        return "Element: " + element + ", Frequency: " + frequence;
+    }
+
+    // Méthode main pour tester la classe
+    public static void main(String[] args) {
+        // Exemple d'utilisation avec un type String
+        exo4<String> association1 = new exo4<>("Test", 5);
+        System.out.println(association1);  // Affichera : Element: Test, Frequency: 5
+
+        // Exemple d'utilisation avec un type Integer
+        exo4<Integer> association2 = new exo4<>(10, 2);
+        System.out.println(association2);  // Affichera : Element: 10, Frequency: 2
+
+        // Modification des valeurs
+        association1.setElement("Updated");
+        association1.setFrequence(10);
+
+        // Vérification de la modification
+        System.out.println(association1);  // Affichera : Element: Updated, Frequency: 10
+    }
+}