Merge branch 'main' of grond.iut-fbleau.fr:baudrier/BUT2

DEV/DEV3.1/TP_Queue/Exercise2/CustomQueue.java

@@ -0,0 +1,6 @@
+import java.util.AbstractQueue;
+import java.util.Collection;
+
+public class CustomQueue<E> extends AbstractQueue<E> {
+    
+}

DEV/DEV3.2/TP_Tree1/Exercise1/DirectoryList.java

@@ -0,0 +1,32 @@
+import java.io.File;
+
+class DirectoryList {
+
+    public static void main(String[] args) {
+        if(args.length == 0) {
+            System.err.println("Usage: DirectoryList <repository_name>");
+            return; 
+        }
+
+        String repositoryName = args[0];
+
+        File directory = new File(repositoryName);
+
+        if(!directory.exists()) {
+            System.err.println("Repository not found.");
+            return; 
+        }
+
+        System.out.println(directory.getName());
+        listFiles(directory, "\t");
+    }
+
+    private static void listFiles(File directory, String space) {
+        if(!directory.isDirectory() || directory.listFiles().length == 0) return;
+
+        for(File file : directory.listFiles()) {
+            System.out.println(space + file.getName());
+            listFiles(file, space + '\t');
+        }
+    }
+}

DEV/DEV3.2/TP_Tree1/Exercise1/Node.java

@@ -0,0 +1,8 @@
+public class Node {
+    private String name; 
+    private Node[] children; 
+
+    public Node(String name) {
+
+    }
+}

DEV/DEV3.4/TP01/Base.java

@@ -0,0 +1,6 @@
+public enum Base {
+    A,
+    C,
+    G,
+    T
+}

DEV/DEV3.4/TP01/stub/0Bad/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV/DEV3.4/TP01/stub/0Bad/Exemple.java

@@ -0,0 +1,31 @@
+// Fichier Exemple pour le premier exercice sur l'ADN
+
+public class Exemple{
+    public static void main(String[] args) {
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+        
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin b = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(b.toString());
+        
+
+        System.out.println("On peut afficher en avançant");
+        System.out.println("Il faut s'en inspirer pour implémenter l'interface iterator de Java.util");
+        MonMaillon actuel = b.getDebut();//NB: c'est comme l ci-dessus
+        
+        while (actuel != null){
+            System.out.println(actuel.getBase());
+            actuel = actuel.getSuiteMaillon();
+        }
+    }
+}

DEV/DEV3.4/TP01/stub/0Bad/MonBrin.java

@@ -0,0 +1,28 @@
+/** 
+    MonBrin code un brin d'ADN sous forme de liste simplement chaînée.
+
+    Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+
+    On n'utilise pas java.util et on recode tout.
+
+    Cette version a un problème : la navigation n'est pas raisonnable
+*/
+public class MonBrin {
+
+    //Le constructeur fabrique un brin à partir du premier maillon p;
+    public MonBrin(MonMaillon p){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public MonMaillon getDebut(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+    /** et pour naviguer? 
+        On pourrait implémenter l'interface iterator de java.util ici
+    **/
+       
+
+}
+
+

DEV/DEV3.4/TP01/stub/0Bad/MonMaillon.java

@@ -0,0 +1,29 @@
+/** 
+    MonMaillon code un maillon d'un brin d'ADN.
+    plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+    On n'utilise pas java.util et on recode tout.
+
+*/
+public class MonMaillon {
+
+    //Le constructeur de base retourne un brin à une base;
+    public MonMaillon(Base b){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    // Le constructeur évolué ajoute une base à un brin.
+    public MonMaillon(Base b, MonMaillon l){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public Base getBase(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+}
+
+

DEV/DEV3.4/TP01/stub/1Iterable/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV/DEV3.4/TP01/stub/1Iterable/Exemple.java

@@ -0,0 +1,34 @@
+// Fichier Exemple pour le second exercice sur l'ADN
+
+public class Exemple{
+    public static void main(String[] args) {
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin b = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(b.toString());
+        
+        System.out.println("On peut maintenant afficher en itérant avec un while comme ceci");
+
+        while (b.hasNext()){
+            System.out.println(b.next());
+        }
+
+        // ajouter du code ici pour gérer les questions en plus
+        // (simulation de plusieurs navigations successives)
+
+
+        // (simulation de plusieurs navigations simultanées)
+    }
+
+}

DEV/DEV3.4/TP01/stub/1Iterable/MonBrin.java

@@ -0,0 +1,45 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+/** 
+    MonBrin code un brin d'ADN sous forme de liste simplement chaînée.
+
+    Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+
+    On n'utilise pas java.util et on recode tout.
+
+    Cette version a un problème : la structuration et la navigation sont dans la même classe.
+*/
+public class MonBrin implements Iterator<Base> {
+    private MonMaillon premier;
+    private MonMaillon courant;  
+
+    public MonBrin(MonMaillon premier){
+        this.premier = premier;
+        this.courant = premier; 
+    }
+
+    public MonMaillon getDebut(){
+        return this.premier; 
+    }
+    
+
+    // rappel : on met @Override pour dire au compilateur qu'on veut surcharger (en particulier c'est le cas quand on implémente une interface)
+    // ce n'est pas nécessaire dans ce cas mais ça permet d'avoir des messages d'alerte si on se trompe (typo dans le nom de la méthode ...)
+    // voir https://stackoverflow.com/questions/94361/when-do-you-use-javas-override-annotation-and-why
+    @Override
+    public boolean hasNext(){
+        return this.courant != null; 
+    }
+
+    @Override
+    public Base next() {
+        Base base = this.courant.getBase(); 
+        this.courant = this.courant.getSuiteMaillon();
+        return base; 
+    }
+
+}
+
+
+
+

DEV/DEV3.4/TP01/stub/1Iterable/MonMaillon.java

@@ -0,0 +1,36 @@
+import java.util.Iterator;
+
+/** 
+    MonMaillon code un maillon d'un brin d'ADN.
+    plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+    On n'utilise pas java.util et on recode tout.
+
+*/
+public class MonMaillon implements Iterable {
+    private Base b; 
+    private MonMaillon l; 
+
+    public MonMaillon(Base b) {
+        this.b = b; 
+    }
+
+    public MonMaillon(Base b, MonMaillon l){
+        this.b = b; 
+        this.l = l; 
+    }
+
+    public Base getBase(){
+        return this.b; 
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        return l;
+    }
+
+    @Override
+    public Iterator iterator() {
+        return new MonBrin(l);
+    }
+}
+
+

DEV/DEV3.4/TP01/stub/2Iterator/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV/DEV3.4/TP01/stub/2Iterator/Exemple.java

@@ -0,0 +1,35 @@
+// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable)
+
+public class Exemple{
+
+        public static void main(String[] args) {
+        
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+            
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin m = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(m.toString());
+        
+        System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)");
+        m.forEach(b -> System.out.println(b));
+
+        System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort.");
+        m.forEach(b -> System.out.println(b));
+
+        System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque");
+        for(Base b: m){
+            System.out.println(b);
+        }
+    }
+
+}