tout marche sauf le dernier

TP4/stub/2Iterator/Base.java

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

TP4/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);
+        }
+    }
+
+}

TP4/stub/2Iterator/MonBrin.java

@@ -0,0 +1,71 @@
+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 est correcte : la structuration et la navigation sont dans 2 classes séparées.
+La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator.
+
+NB : Notez que j'implémente Iterable<Base> plutôt que Iterable qui n'était pas tout à fait propre
+c'est un peu technique et c'est lié aux types génériques.
+ Il y a des détails ici 
+https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1
+*/
+/*
+public class MonBrin implements Iterable<Base>{
+
+
+    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");
+    }
+           
+    /** Pour naviguer? 
+        On implémente l'interface iterator de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne.
+    **//*
+    @Override
+    public Iterator<Base> iterator() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+}
+*/
+
+public class MonBrin implements Iterable<Base> {
+    private MonMaillon debut;
+
+    // Constructeur pour initialiser le brin avec le premier maillon
+    public MonBrin(MonMaillon p) {
+        this.debut = p;
+    }
+
+    // Retourne le premier maillon du brin
+    public MonMaillon getDebut() {
+        return this.debut;
+    }
+
+    // Fournit un itérateur pour parcourir le brin d'ADN
+    @Override
+    public Iterator<Base> iterator() {
+        return new MonBrinIterator(this.debut); // Navigation déléguée à MonBrinIterator
+    }
+
+    // Méthode toString pour afficher tout le brin d'ADN sous forme de chaîne
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        MonMaillon temp = this.debut;
+        while (temp != null) {
+            sb.append(temp.getBase()).append(" ");
+            temp = temp.getSuiteMaillon();
+        }
+        return sb.toString().trim();
+    }
+}

TP4/stub/2Iterator/MonBrinIterator.java

@@ -0,0 +1,59 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** 
+MonBrinIterator 
+
+gère la navigation dans un Brin d'ADN
+
+*/
+/*
+public class MonBrinIterator implements Iterator<Base> {
+    
+    public MonBrinIterator(MonMaillon m){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+    /** Pour naviguer? 
+        On implémente l'interface iterable de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navogation fonctionne.
+    **//*
+    @Override
+    public boolean hasNext(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    @Override
+    public Base next() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+ 
+}
+*/
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class MonBrinIterator implements Iterator<Base> {
+    private MonMaillon courant;
+
+    // Initialise l'itérateur avec le premier maillon du brin
+    public MonBrinIterator(MonMaillon m) {
+        this.courant = m;
+    }
+
+    // Vérifie s'il y a un élément suivant dans le brin
+    @Override
+    public boolean hasNext() {
+        return courant != null;
+    }
+
+    // Retourne la base actuelle et passe au maillon suivant
+    @Override
+    public Base next() {
+        if (!hasNext()) throw new NoSuchElementException("No more elements in the iterator.");
+        Base baseActuelle = courant.getBase();
+        courant = courant.getSuiteMaillon(); // Passe au maillon suivant
+        return baseActuelle;
+    }
+}

TP4/stub/2Iterator/MonMaillon.java

@@ -0,0 +1,56 @@
+/** 
+    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");
+    }
+    
+}
+*/
+
+public class MonMaillon {
+    private Base base;
+    private MonMaillon suivant;
+
+    // Constructeur pour un maillon unique
+    public MonMaillon(Base b) {
+        this.base = b;
+        this.suivant = null;
+    }
+
+    // Constructeur pour ajouter un maillon à une chaîne existante
+    public MonMaillon(Base b, MonMaillon l) {
+        this.base = b;
+        this.suivant = l;
+    }
+
+    // Retourne la base de ce maillon
+    public Base getBase() {
+        return this.base;
+    }
+
+    // Retourne le maillon suivant dans le brin
+    public MonMaillon getSuiteMaillon() {
+        return this.suivant;
+    }
+}