tout marche sauf le dernier

TP4/stub/3IteratorDifferentInnerStructure/Base.java

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

TP4/stub/3IteratorDifferentInnerStructure/Exemple.java

@@ -0,0 +1,58 @@
+// 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
+        // codon CAT code Histidine
+        // codon CGT code Arginine
+        // codon GCC code Analine
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+        
+        System.out.println("construction du brin CGT CAT CGT GCC CAT GCT TAG");
+        MonBrin l = new MonBrin(Base.G);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.T,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.G,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.G,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.G,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.G,l);
+        l = new MonBrin(Base.C,l);
+        //
+
+        System.out.println("l'affichage par défaut ne va toujours pas vous plaire");
+        System.out.println(l.toString());
+
+        System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)");
+        l.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.");
+        l.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: l){
+            System.out.println(b);
+        }
+    }
+
+}

TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java

@@ -0,0 +1,106 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Arrays;
+
+/** 
+MonBrin code un brin d'ADN sous forme de tableaux. Dynamiquement, la taille du tableau est augmentée en cas de besoin (la taille est initialement 3*4 elle est multipliée ensuite pour être toujours de la forme 3*2^n). 
+On utilise System.arraycopy et java.util.Arrays.copyOfRange pour faire ça efficacement.
+voir 
+https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#arraycopy-java.lang.Object-int-java.lang.Object-int-int-
+https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#copyOfRange-T:A-int-int-
+
+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> {
+    private Base[] bases;       // Tableau pour stocker les bases
+    private int length;         // Nombre d'éléments dans le tableau
+    private int currentIndex;   // Indice actuel pour la navigation
+
+    private static final int INITIAL_CAPACITY = 12;  // Capacité initiale
+
+    // Constructeur pour initialiser le brin avec une seule base
+    public MonBrin(Base b) {
+        this.bases = new Base[INITIAL_CAPACITY];
+        this.bases[0] = b;
+        this.length = 1;
+        this.currentIndex = 0; // Initialiser l'indice de navigation
+    }
+
+    // Constructeur pour ajouter une base devant un autre brin
+    public MonBrin(Base b, MonBrin l) {
+        this.bases = Arrays.copyOf(l.getBases(), l.capacity());
+        this.bases[0] = b;
+        this.length = l.length + 1;
+        this.currentIndex = 0; // Initialiser l'indice de navigation
+    }
+
+    // Méthode pour garantir que le tableau a suffisamment d'espace
+    private void ensureCapacity() {
+        if (length >= bases.length) {
+            bases = Arrays.copyOf(bases, bases.length * 2); // Double la capacité
+        }
+    }
+
+    // Méthode pour ajouter une base
+    public void addBase(Base b) {
+        ensureCapacity(); // Vérifie que le tableau a assez de place
+        bases[length] = b; // Ajoute la nouvelle base
+        length++;
+    }
+
+    // Retourne la base à un index donné
+    public Base getBase(int i) {
+        if (i < 0 || i >= length) {
+            throw new IndexOutOfBoundsException("Index hors limites");
+        }
+        return bases[i];
+    }
+
+    // Retourne toutes les bases sous forme de tableau
+    public Base[] getBases() {
+        return Arrays.copyOf(bases, length);
+    }
+
+    // Retourne la capacité actuelle
+    public int capacity() {
+        return bases.length;
+    }
+
+    // Retourne la longueur actuelle (le nombre de bases)
+    public int length() {
+        return length;
+    }
+
+    // Retourne la limite (identique à length ici)
+    public int limit() {
+        return length;
+    }
+
+    // Réinitialise l'indice de navigation (permet de refaire un parcours)
+    public void reset() {
+        this.currentIndex = 0;
+    }
+
+    // Méthode pour obtenir un itérateur sur les bases
+    @Override
+    public Iterator<Base> iterator() {
+        return new MonBrinIterator(this);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        // Parcours des bases jusqu'à la longueur réelle (pas la capacité)
+        for (int i = 0; i < length; i++) {
+            sb.append(bases[i]).append(" ");
+        }
+        return sb.toString().trim();
+    }
+}

TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java

@@ -0,0 +1,33 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** 
+MonBrinIterator 
+
+gère la navigation dans un Brin d'ADN
+
+*/
+
+public class MonBrinIterator implements Iterator<Base> {
+    private final MonBrin brin;
+    private int currentIndex;
+
+    public MonBrinIterator(MonBrin brin) {
+        this.brin = brin;
+        this.currentIndex = 0; // Initialise l'index à 0 pour commencer depuis le début
+    }
+
+    @Override
+    public boolean hasNext() {
+        return currentIndex < brin.length();
+    }
+
+    @Override
+    public Base next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException("Plus de bases dans le brin");
+        }
+        return brin.getBase(currentIndex++);
+    }
+}
+