Les Manipulations d'un ArrayList

Version imprimable

Bonjour,

Dans un premier temps, j'espère que je fais bien mon post :)

J'ai un travail à faire avec l'utilisation des arraylist, notion héritage...etc

Ma classe principale :

Code:

1
2
3
4
5
6
 
public class PrincipaleARN {
    public static void main() {
           AcideRibonucleique arn1 = new AcideRibonucleique( Arrays.asList(Nucleotide.A, Nucleotide.U, Nucleotide.G));
           }
}

Ma classe AcideRibonucleique qui hérité de Nucleotide sous forme de tableau dynamique si j'ai bien compris...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class AcideRibonucleique extends ArrayList<Nucleotide>{
 
public AcideRibonucleique( Collection <Nucleotide> c ) {
        super(c);
        }
 
/* 
public boolean estValide() // cette méthode sert à valider si mon arraylist ARN est valide sous différentes conditions. Je dois comparer plusieurs positions de mon arraylist si ces positions sont bon...
 
Donc comment faire ?
 
*/
 
    }

Ma classe enum :

Code:

1
2
3
4
 
public enum Nucleotide {
	A, B, C, D, G, H, K, M, N, R, S, U, V, W, Y;
}

Un gros merci d'avance

Salut,

Pour permettre à d'autres méthodes d'une classe de manipuler des valeurs ou objets passés en arguments du constructeur, il te faut stocker ces valeurs ou objets en attributs de la classe, s'il s'agit de données existantes pendant la durée de vie de la classe. S'ils s'agit de méthodes à appeler lors de la construction de l'objet, on peut passer aussi la donnée en argument de ces autres méthodes

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Exemple {
 
    private Collection<String> collection; // un attribut pour stocker la collection
 
    public Exemple(Collection<String> collection) {
        this.collection=collection; // initialisation de l'attribut avec la valeur passée en argument
    }
 
    public int size() {
        return collection.size(); // utilisation de l'objet qu'on avait passé en argument
    }
 
 
 
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Exemple {
 
   private Collection<String> collection;
 
   public Exemple(Collection<String> collection) {
        collection = copie( collection ); // on veut faire une copie avec quelques nettoyages avant de stocker ce qui est passé en argument
        this.collection=collection; // initialisation de l'attribut avec la copiée de la valeur passée en argument
   }
 
   private Collection<String> copie(Collection<String> collection) {
        if ( collection==null ) return Collections.emptyList(); // si collection est nulle, on stocke une liste vide
        List<String> list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie
        for(String string : collection) { // on parcourt la liste passée en argument
           if ( string!=null ) { // on ne garde que les valeurs non null
             list.add(string); 
           }
        }
        return list;
   }
 
   public int size() {
        return collection.size(); // utilisation de l'objet qu'on avait passé en argument
   }
 
}

Attention, si une ArrayList est bien une Collection, en revanche, une Collection n'est pas forcément une ArrayList.

05/10/2016, 21h16
benoit256255

Merci, je suis entrain d'étudier votre réponse pour l'incorporer à mon travail...

Je ne suis suis pas trop familier avec la boucle for (String string : collection)

Je suis plus habituer d'utiliser for (int i = 0; i < tableau.size(); i++)

Par contre, j'ai une contraire que le prof nous a donné soit d'avoir un seul return par méthode...

Citation:

Envoyé par benoit256255

Par contre, j'ai une contraire que le prof nous a donné soit d'avoir un seul return par méthode...

Ce sont les puristes de la programmation structurée qui tienne à un seul point de sortie. Dans beaucoup de cas, c'est un bon moyen d'éviter certaines erreurs lors de la modification du code. Maintenant, parfois ça complique inutilement le code.
Sinon on peut avoir plusieurs return dans une méthode si ceux-ci on une éxecution exclusive (si l'un s'exécute, l'autre ne peut pas, et dans mon exemple, c'est la condition sur le null qui fait que c'est exclusif). Si tu veux l'équivalent de ce que j'ai écris avec un seul point de sortie :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 private Collection<String> copie(Collection<String> collection) { List<String> list; if ( collection==null ) { list = Collections.emptyList(); // si collection est nulle, on stocke une liste vide } else { list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie for(String string : collection) { // on parcourt la liste passée en argument if ( string!=null ) { // on ne garde que les valeurs non null list.add(string); } } } return list; }
Citation:

Envoyé par benoit256255

Je ne suis suis pas trop familier avec la boucle for (String string : collection)

Je suis plus habituer d'utiliser for (int i = 0; i < tableau.size(); i++)

Sauf que tu ne peux pas utiliser cette méthode pour parcourir une Collection : seule l'interface List permet l'accès à un élement par son index ! Il te faut donc changer le type de l'argument en List et le type de l'attribut aussi.

05/10/2016, 21h38
benoit256255

Désolé si je pose beaucoup de question, ma logique n'est pas très automatique :)

Le type <String> peut être remplacer par n'importe qu'elle type je suppose ?

private Collection<String> copie(Collection<String> collection)
05/10/2016, 21h40
joel.drigo

Citation:

Envoyé par benoit256255

Le type <String> peut être remplacer par n'importe qu'elle type je suppose ?

Oui, tant que c'est une classe (on ne peut pas paramétrer une classe avec un type primitif (comme int, double...)).
05/10/2016, 21h49
benoit256255

Citation:

Envoyé par joel.drigo

Oui, tant que c'est une classe (on ne peut pas paramétrer une classe avec un type primitif (comme int, double...)).

Au moins ça c'était déjà acquis pour les type primitif qu'on ne peut pas utiliser...

Dernière question je pense :)

private Collection<String> copie(Collection<String> collection)

Si je comprend bien cette méthode, elle retourne (la copie) une liste de type collection d'un type String...

Pouvons nous retourner une liste de type ArrayList ?
05/10/2016, 21h58
benoit256255

Erreur de compilation...

list = Collections.emptyList();

Me donne comme erreur : cannot find symbol...method emptyList()

Même si j'inscris

list = Collection.emptyList();

ça ne marche pas...

Citation:

Envoyé par benoit256255

Pouvons nous retourner une liste de type ArrayList ?

Bien sûr, d'autant plus que l'implémentation concrète est bien une ArrayList, sauf pour Collections.emptyList(), qui n'est pas une ArrayList.

Il est toujours préférable de typer avec le type le plus "haut" dans la hiérarchie, tel qu'il permette la manipulation qu'on désire.

On peut écrire (en faisant suivre le type de l'attribut) :

Code:

private Iterable<String> copie(Collection<String> collection)

,
si on sait qu'on aura juste besoin d'itérer.

Mais si on a besoin de connaitre le nombre d'éléments

Code:

private Collection<String> copie(Collection<String> collection)

,

Et si on a besoin d'accèder directement à un élément (par son index)

Code:

private List<String> copie(Collection<String> collection)

,
Etc.

L'intérêt c'est qu'en gardant le type le plus générique par rapport à ce qu'on veut faire, c'est qu'on peut modifier facilement l'implémentation concrète sans avoir besoin de modifier tout le reste.
Si tu déclares ton attribut avec le type ArrayList, et que, plus tard tu as besoin de passer à une LinkedList, il te faudra changer toutes tes méthodes qui font références à ArrayList. Pour peu que tu aies une méthode qui est appelée depuis d'autres classes, il faudra aussi modifier ces autres classes, et aiinsi de suite.

Tu peux facilement remplacer juste le type de retour comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 private List<String> copie(Collection<String> collection) { List<String> list; if ( collection==null ) { list = Collections.emptyList(); // si collection est nulle, on stocke une liste vide } else { list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie for(String string : collection) { // on parcourt la liste passée en argument if ( string!=null ) { // on ne garde que les valeurs non null list.add(string); } } } return list; }
Mais si tu veux retourner de l'ArrayList, il faudra aussi changer le code pour l'emptyList :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 private ArrayList<String> copie(Collection<String> collection) { ArrayList<String> list; if ( collection==null ) { list = new ArrayList<>(0); // si collection est nulle, on stocke une liste vide } else { list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie for(String string : collection) { // on parcourt la liste passée en argument if ( string!=null ) { // on ne garde que les valeurs non null list.add(string); } } } return list; }
De préférence, les types concrêts ne sont utilisés que lors du new, en particulier lorsqu'une interface est disponible.

On peut aussi utiliser localement le type ArrayList. Par exemple, on pourrait écrire (regarde la ligne que j'ai mis en jaune)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 private List<String> copie(Collection<String> collection) { // on retourne le type générique ArrayList<String> list; // on manipule la liste par la classe concrête if ( collection==null ) { list = new ArrayList<>(0); // si collection est nulle, on stocke une liste vide } else { list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie for(String string : collection) { // on parcourt la liste passée en argument if ( string!=null ) { // on ne garde que les valeurs non null list.add(string); } } list.trimToSize(); // on permet de réduire la taille mémoire comme ça, cette méthode n'existant pas sur List, on ne peut l'appeler que sur ArrayList } return list; }

05/10/2016, 22h03
joel.drigo

Citation:

Envoyé par benoit256255

list = Collections.emptyList();

Me donne comme erreur : cannot find symbol...method emptyList()

Même si j'inscris

list = Collection.emptyList();

ça ne marche pas...

La méthode existe dans la classe Collections, pas la classe Collection (donc c'est bien la première écriture, celle que je t'ai donnée). Mais tu importes bien java.util.Collections ?

A noter que je t'ai donné juste un exemple d'appel de méthode dans le constructeur en passant l'argument du constructeur en paramètre de cette méthode : il n'est pas absolument nécessaire que tu aies besoin de le faire dans ton exercice, encore moins que tu aies besoin de faire cette copie avec suppression des valeurs null... (c'est pour ça que j'ai mis cet exemple en seconde position, après l'exemple le plus simple, qui ne fait qu'utilser un attribut).
05/10/2016, 22h49
benoit256255

Je vais regarder ca demain car là mon cerveau ne répond plus....

merci pour laide malgre tout

Citation:

Envoyé par joel.drigo

Mais si tu veux retourner de l'ArrayList, il faudra aussi changer le code pour l'emptyList :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
private ArrayList<String> copie(Collection<String> collection) {
        ArrayList<String> list;
        if ( collection==null ) {
              list = new ArrayList<>(0); // si collection est nulle, on stocke une liste vide
        }
        else {
           list = new ArrayList<>(collection.size()); // on utilise indirectement la collection passée en argument du constructeur parce qu'elle a été passée en argument de la méthode copie
           for(String string : collection) { // on parcourt la liste passée en argument
              if ( string!=null ) { // on ne garde que les valeurs non null
                list.add(string); 
              }
           } 
        }
        return list;
}

Un grand merci Joel car ça fonctionne et j'ai même tester avec ceci :

Voici mon début de class :

Code:

1
2
3
4
5
 
public class AcideRibonucleique extends ArrayList<Nucleotide> {
    public Collection <Nucleotide> collection;
    public ArrayList <Nucleotide> list;
    ...

Voici mon constructeur:

Code:

1
2
3
4
5
 
public AcideRibonucleique( Collection <Nucleotide> collection ) {
        this.collection = collection;      
        this.list = copie(collection);          
    }

Voici la création de mon object Arraylist venant de la copie du array passé en paramètre de type Collection :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public ArrayList<Nucleotide> copie(Collection<Nucleotide> collection) {
        if (collection == null) {
            list = new ArrayList<>(0); // 
        }
        else {
            list = new ArrayList<>(collection.size()); 
            for(Nucleotide string : collection) {
                if ( string!=null ) { 
                    list.add(string); 
                }
            } 
        }
        return list;
    }

La preuve que la copie du type collection en ArrayList fonctionne :

Code:

1
2
3
4
5
6
7
 
public void afficheEtat(){
        for (int i = 0; i < list.size();i++){
            System.out.print(list.get(i));        
        }
        System.out.println();
    }

En gros merci...Je vais poursuivre maintenant la grandissement de ma méthode :

Code:

1
2
3
4
5
6
7
8
 
public boolean estValide(){
        boolean resultat = false; 
        if (list.size() % 3 == 0){             
            resultat = true;
        }
        return resultat;        
}

En conclusion merci mais je suis triste de ne pas avoir été capable d'arriver à se résultat par moi même.
Je comprend maintenant comment ré-utiliser des objets instancié avec le new de type ArrayList venant d'une Collection de liste.

A noter que :
si tu voulais copier une collection vers une ArrayList sans filtrer les valeurs, tu pourrais faire simplement : list = new ArrayList<>(collection);
qu'il existe en Java 8 une autre solution pour faire la copie en filtrant, sans écrire de boucle :
Code:

1 2 3 list = collection.stream() .filter(item-> item!=null) .collect(Collectors.toCollection(ArrayList::new));
En revanche, il y a une chose que je n'avais pas bien vu dans ta question initiale :

Code:

public class AcideRibonucleique extends ArrayList<Nucleotide>{

Ta classe AcideRibonucleique est déjà une ArrayList : il n'y a donc rien à faire de spécial pour utiliser la collection passée en argument de son constructeur. C'est une ArrayList, tu utilises les méthodes de ArrayList. Si tu as besoin d'ajouter des méthodes, elles doivent elle-même utiliser les méthodes de ArrayList pour manipuler les données contenues dans cette classe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class AcideRibonucleique extends extends ArrayList<Nucleotide> { public AcideRibonucleique(Collection<Nucleotide> c) { super(c); } public boolean estValide(){ boolean resultat = false; if (size() % 3 == 0){ resultat = true; } return resultat; } }
Et il ne faut surtout pas restocker la collection passée en argument à part : sinon la classe ne fonctionne pas du tout (si on appelle la méthode add() ça ne va pas ajouter des Nucleotide dans la collection ou la list stockée ).
D'ailleurs à ce sujet :
Code:

1 2 3 public class AcideRibonucleique extends ArrayList<Nucleotide> { public Collection <Nucleotide> collection; public ArrayList <Nucleotide> list;
Il faut éviter de de mettre les attributs en public : on peut les modifier sans aicun contrôle possible dans la class AcideRibonucleique
Stocker 2 variables va imposer de penser à bien à mettre à jour les 2 : cela peut être fastidieux et souce d'oublis/erreurs

Et ceci

Citation:

Envoyé par benoit256255

Ma classe AcideRibonucleique qui hérité de Nucleotide sous forme de tableau dynamique si j'ai bien compris...

n'est pas vrai : la classe AcideRibonuclique hérite de ArrayList.

06/10/2016, 16h16
benoit256255

Je suis entrains de regarder sur le site :

https://docs.oracle.com/javase/7/doc...ArrayList.html

Je n'arrive pas à saisir la notion du «comment lire» la dernière valeur de mon ArrayList et les deux précédentes..

Exemple :

ArrayList contient les valeurs : 3,5,6,7,8 au position 0,1,2,3,4

Comment faire afficher ou faire une comparaison de tout ça ?

Encore merci

Pour afficher, sur la sortie standard, une ArrayList, il suffit de faire :
Code:

1 2 System.out.println( unArrayList ); // unArrayList est une variable de type ArrayList
Cela affiche avec un format par défaut genre (1,2,3,4,5).
Si tu veux afficher différemment, il faut parcourir les éléments, soit en itérant, soit avec une boucle sur les index et en utilisant la méthode get(index) de List (donc de ArrayList) qui te permet d'obtenir la valeur située à la position index. Ensuite, à coup de System.out.print() tu peux choisir la manière d'afficher.
On peut utiliser un joining aussi pour changer l'affichage :

Par exemple :
Code:

1 2 3 4 5 6 public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4,5); System.out.println(list.stream().map(String::valueOf).collect(Collectors.joining("]-[", "[", "]"))); }
affichera :
[1]-[2]-[3]-[4]-[5]
Sinon, c'est quoi la "une comparaison de tout ça " ? La comparaison entre quoi et quoi ?

Merci pour la réponse rapide, en effet je me suis mal exprimé :)

Je me reprend :

Si ma liste contient 5 valeurs, je dois comparer les trois dernière séparément pour m'assurer que les valeurs saisient dans ma liste son valide.

Exemple : J'ai réussi sans problème à établir mes comparaisons sur le début de ma liste :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public boolean estValide(){
        boolean resultat = false;        
 
        if (copyObjListeArn.size() % 3 == 0){ // si ma liste contient des séquence de 3 éléments         
            if (copyObjListeArn.get(0) != Nucleotide.C){ // ma liste ne doit pas commencer par C
                if (copyObjListeArn.get(1) == Nucleotide.U && copyObjListeArn.get(2) == Nucleotide.G){ //mes positions 1 et 2 doivent absolument être égal à U et G
                    resultat = true; 
                    //Ici il me manque la validation pour l'indice avant avant dernier, avant dernier et dernier
                }
            }
        }
 
        return resultat; 
    }

Ok, donc si je comprends bien, en français, ce que tu cherches à faire c'est :
Code:

1 2 3 4 5 6 7 8 si taille de ma liste est égale à 5 alors si la valeur située à la derniere position est ... et si la valeur située à l'avant-dernière position est ... et si l'antépénultiemme valeur est ... alors la liste est valide sinon la liste ne l'est pas fin si fin si
C'est toujours pareil :
Pour accèder à une valeur dans la liste, à une position donnée, on utilise la méthode get()
Pour accèder à la dernière valeur d'une liste de taille 5, on fait get(4) (les éléments vont de 0 taille-1)
Si on veut accèder à la dernière position, alors que la taille n'est pas connue d'avance, on va déterminer la taille de la liste en appelant la méthode size(), et on va calculer la position relativement à cette taille :
Code:

1 2 3 4 int size = list.size(); //le nombre d'élément dans la list ... list.get(size-1); // le dernier ... list.get(size-2); // l'avant-dernier ... list.get(size-3); // l'antépénultiemme
Il y a plein d'autres techniques après :
on peut retourner la liste (et tester le premier, le deuxième et le troisième) par exemple
on peut extraire la fin de la liste (les trois derniers élémens) et faire une comparaison directe avec une liste de référence :
Code:

1 2 3 4 5 List<Integer> list = Arrays.asList(1,2,3,4,5); List<Integer> ref = Arrays.asList(3,4,5); System.out.println(list.subList(list.size()-3, list.size()).equals(ref));
Dans le cas général, il faudra bien faire attention de ne pas extraitre 3 éléments d'une liste qui en contient moins.
Avec une liste de référence, on peut aussi faire également une boucle et une comparaison 2 à 2.
...

06/10/2016, 17h13
benoit256255

Deux mots :

Wow et Merci !

Je n'ai plus de questions, votre honneur !

Expression québécoise qu'on applique lorsqu'un avocat débat avec un juge.