106 lines
3.7 KiB
Java
106 lines
3.7 KiB
Java
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();
|
|
}
|
|
} |