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
+    }
+}

DEV3.2/Recursiviote/Appel.java

@@ -0,0 +1,28 @@
+public class Appel{
+    public static int fact(int a, int indentation) {
+        int i;
+        for (i = 0; i < indentation; i++)
+            System.out.print("  ");
+        System.out.println("argument ="+a);
+        if (a == 1) {
+            return 1;
+        } else {
+            int res = a * fact(a-1, indentation+1);
+            for (i = 0; i < indentation; i++)
+                System.out.print("  ");
+            System.out.println("resultat ="+res);
+            return res;
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("manque un nombre pour le calcul");
+        } else {
+            int ind = 0;
+            int n = Integer.parseInt(argv[argv.length-1]);
+            int res = fact(n, ind);
+            System.out.println(n+"! = "+res);
+        }
+    }
+}

DEV3.2/Recursiviote/Fibonacci.java

@@ -0,0 +1,38 @@
+public class Fibonacci{
+    public static int fibonacci(int x0, int x1, int val, int indentation) {
+        int i;
+        for (i = 0; i < indentation; i++)
+            System.out.print("  ");
+        System.out.println("u0 ="+x0+"u1 ="+x1);
+        if (val == -2) {
+            return x0;
+        } else if (val == -1) {
+            return x1;
+        } else if (val == 0) {
+            return x1;
+        }else {
+            int v = x0;
+            x0 = x1;
+            x1 = v + x1;
+            val--;
+            int res = fibonacci(x0, x1, val, indentation+1);
+            for (i = 0; i < indentation; i++)
+                System.out.print("  ");
+            System.out.println("resultat ="+x1);
+            return res;
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("manque un nombre pour le calcul de la suite");
+        } else {
+            int x0 = 0;
+            int x1 = 1;
+            int ind = 0;
+            int val = Integer.parseInt(argv[argv.length-1]) - 2;
+            int res = fibonacci(x0, x1, val, ind);
+            System.out.println("Fibonacci de "+(val+2)+"ième terme = "+res);
+        }
+    }
+}

DEV3.2/Recursiviote/Tableaux.java

@@ -0,0 +1,63 @@
+import java.util.Arrays;
+
+public class Tableaux{
+    public static int[] remplir_tab(int val, String[] argv, int[] tab) {
+        if (argv.length == val) {
+            return tab;
+        } else {
+            tab[val] = Integer.parseInt(argv[val]);
+            val++;
+            return remplir_tab(val, argv, tab);
+        }
+    }
+
+    public static int pair_tab(int val, int pair, int[] tab) {
+        if (tab.length == val) {
+            return pair;
+        } else {
+            if (tab[val] % 2 == 0)
+                pair++;
+            val++;
+            return pair_tab(val, pair, tab);
+        }
+    }
+
+    public static int max_tab(int val, int max, int[] tab) {
+        if (tab.length == val) {
+            return max;
+        } else {
+            if (tab[val] > max)
+                max = tab[val];
+            val++;
+            return max_tab(val, max, tab);
+        }
+    }
+
+    public static int[] inverse_tab(int val, int[] tab, int[] inv_tab) {
+        if (tab.length == val) {
+            return inv_tab;
+        } else {
+            inv_tab[val] = tab[tab.length-1-val];
+            val++;
+            return inverse_tab(val, tab, inv_tab);
+        }
+    }
+
+    public static void main(String[] argv){
+        if (argv.length < 1){
+            System.err.println("il faut un nombre au minimum pour le tableau");
+        } else {
+            int[] tab = new int[argv.length];
+            int[] inv_tab = new int[argv.length];
+            int val = 0;
+            int pair = 0;
+            int max = 0;
+            tab = remplir_tab(val, argv, tab);
+            System.out.println(Arrays.toString(tab));
+            System.out.println("nombre de pair ="+pair_tab(val, pair, tab));
+            System.out.println("nombre le plus grand ="+max_tab(val, max, tab));
+            inv_tab = inverse_tab(val, tab, inv_tab);
+            System.out.println(Arrays.toString(inv_tab));
+        }
+    }
+}