Discussion :

[benoit256255]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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...

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

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.

[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)

[joel.drigo]

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...)).

[benoit256255]

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 ?

[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...

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

,


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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[joel.drigo]

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).

[benoit256255]

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

merci pour laide malgre tout

[benoit256255]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Voici mon constructeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[joel.drigo]

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 :

  Sélectionner tout - Visualiser dans une fenêtre à part

  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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

1. Il faut éviter de de mettre les attributs en public : on peut les modifier sans aicun contrôle possible dans la class AcideRibonucleique
2. Stocker 2 variables va imposer de penser à bien à mettre à jour les 2 : cela peut être fastidieux et souce d'oublis/erreurs

Et ceci

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.

[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

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[benoit256255]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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; 
    }

[joel.drigo]

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

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

1. Pour accèder à une valeur dans la liste, à une position donnée, on utilise la méthode get()
2. 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)
3. 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 :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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 :

1. on peut retourner la liste (et tester le premier, le deuxième et le troisième) par exemple
2. 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 :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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.
3. Avec une liste de référence, on peut aussi faire également une boucle et une comparaison 2 à 2.
4. ...

[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.