[Débutant][ArrayList]parcours et recherche d'objets

Version imprimable

Bonjour.
Il me faut faire un programme en mode console(DOS).
Ce programme gere des outils.
Une des fonctions ajouterOutil() demande d'abord le coed de l'outil, si le code rentré existe déja dans la liste des outils, le programme doit redemander le code, et ce tantque le code ne sera pas valide.

Voici une partie de programme qui vérifie le code de l'outil.
Je peux parcourir la liste, de comparer le code de l'outil et d'afficher le message d'erreur, mais je n'arrive pas d'appeler la saisie de code d'outil de nouveau en cas d'erreur.
SVP aidez moi!!
C'est urgent!!!!

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
26
27
28
29
30
        // saisie
        //codeInventaire = saisirCodeInventaire();
 
        unOutil = liste.premierElement();
        //
        //do{
            System.out.println("VERIFIER CODE");
            codeInventaire = saisirCodeInventaire();
 
            if(!liste.estVide()){
                do{
 
                    if(unOutil.getCodeInventaire().equals(codeInventaire)){
                        System.out.println("ERREUR CODE INVENTAIRE!");
                        //finListe = true;
                        codeInventaire = saisirCodeInventaire();
                        codeInventaireExiste = true;
                    }
                    else
                        codeInventaireExiste = false;
 
                    if(!codeInventaireExiste){
                        if(unOutil == liste.dernierElement())
                            finListe = true;
                            else
                                unOutil = liste.successeurDe(unOutil);
                    }
                }while(!finListe || codeInventaireExiste == true);
            }
        //}while(codeInventaireExiste);

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
26
27
28
29
    public T premierElement (){
        if(estVide())
            return null;
        else
            return liste.get(0);
    } // premierElement
 
    /**
     * Retourne la reference de l'objet en fin de liste
     * @return reference de l'objet ou null si liste vide
     */
    public T dernierElement (){
        if(estVide())
            return null;
        else
            return liste.get(liste.size()-1);
    } // dernierElement
 
    /**
     * Retourne la reference de l'élement de la liste qui suit 
     * celui spécifié en paramètre
     * @return la référence de l'objet suivant ou null si liste vide ou fin de la liste
     */
    public T successeurDe (T element){
        if( estVide() || liste.indexOf(element) >= nbElements() )
            return null;
        else
            return liste.get(liste.indexOf(element)+1);
    } // successeurDe

18/02/2006, 23h08
plegat

Salut,

Euh... si tu as le message d'erreur, tu as forcément la saisie du code, c'est la ligne suivante....

Par contre je vois un soucis dans ton algo... si tu entres le code d'un outil existant, il va le détecter, et t'en demander un autre... mais il ne fera la vérification du nouveau code qu'à partir du drnier élément qui a été vérifié. Donc si tu rentres le code d'un élément précédent, il va te le sortir comme non existant ,alors qu'il sera existant.
A chaque code entré, il faudrait vérifier depuis le début de ta liste.
18/02/2006, 23h29
codexomega

Oui, c'est exactement ce qui se passe...
Un autre problème que j'ai, réside dans la récupération de l'objet trouvéavec se meme code d'inventaire dans la liste(mais c'est pour plus tard - pour modifier l'objet dont on a fourni le code d'inventaire) .

J'ai passé la journée à me battre avec ce truc, et je n'arrive à rien!

SVP, donnez moi un exemple de l'algo qui marche, pour la premiere question pour commencer.

Merci.

Je tenterai quelque chose du style:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
boolean flag;
 
System.out.println("VERIFIER CODE"); 
 
do {
    codeInventaire = saisirCodeInventaire(); 
 
    flag=false;
 
    for (int i=0;i<liste.size();i++) {
        if (liste.get(i).equals(codeInventaire)) {
            System.out.println("ERREUR CODE INVENTAIRE!");
            flag=true;
            break;
        }
    }
} while (flag)

(j'ai supposé que ta liste était une ArrayList... il y a peut-être un cast à faire si nécessaire...)

Merci beaucoup!
C'est presque réussi.
Oui, c'est ArrayList qui est utilisé.

Maintenant, ce qui ne fonctionne pas, c'est cela: if (liste.get(i).equals(codeInventaire))

En fait, je ne peux pas utiliser les méthodes propres de ArrayList, mais se servire de la classe utilitaire, qui elle les utilise.

Je sais pas comment don comparer des objets, car dans toutes les méthodes existantes je ne peux passer que des objets...

Je vous donc affiche au complet la classe utilitaire, je vois pas quelle méthode qui s'y trouve pourra m'aider.

Je compte donc sur votre aide.
Merci encore!

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
public class ListeArray <T> implements ADTListe <T>{
 
    // liste des elements
    private ArrayList <T> liste;
 
    /**
     * Constructeur 
     * Creation de la liste
     */
    public ListeArray(){
        liste = new ArrayList <T>();
    } // constructeur
 
    // --- Methodes 
 
    /**
     * Verification si la liste contient ou non des élements
     * @return true si la liste est vide, sinon false
     */
    public boolean estVide (){
        return liste.size() == 0;
    } // estVide
 
    /**
     * Retirer tous les élements de la liste. La liste sera vide
     * 
     */
    public void viderListe (){
        liste.clear();
    } // viderListe
 
    /**
     * Retourne le nombre d'éléments de la liste
     * @return Nombre d'élements (int)
     */
    public int nbElements (){
        return liste.size();
    } // nbElements
 
    /**
     * Ajoute l'élément au début de la liste
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     */
    public T ajouterDebut (T element){
        liste.add(0, element);
        return null;//trouverElement(element);
    } // ajouterDebut
 
    /**
     * Ajoute l'élément à la fin de la liste
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     */
    public T ajouterFin (T element){
        return liste.set(nbElements()-1, element);
    } // ajouterFin
 
    /**
     * Ajoute l'élément en ordre croissant (avec compareTo)
     * @return la référence de l'objet inséré ou null s'il y a eu un probleme
     * ====> pas à être implémentée pour le tp1
     **/
    public T ajouterOrdonne (T element){
        // A venir pour le TP2  
        return null;
    } // ajouterOrdonne
 
    /**
     * Retirer de la liste l'élément spécifié en paramètre
     * @return la référence de l'objet retiré, ou null si l'élément n'existe pas
     */
    public T retirer (T element){
        if(trouverElement(element) != null)
            return liste.remove(liste.indexOf(element));
        else
            return null;
    } // retirer
 
    /**
     * Vérifier si l'élement parametre existe dans la liste
     * @return la reference de l'objet trouvé dans la liste ou null si inexistant
     */
    public T trouverElement (T element){
        if(liste.contains(element)){
            System.out.println("LISTE CONTIENT ELEMENT!");
            return liste.get(liste.indexOf(element));
        }
        else
            return null;
    } // trouverElement
 
    /**
     * Retourne la reference de l'objet en début de liste
     * @return reference de l'objet ou null si liste vide
     */
    public T premierElement (){
        if(estVide())
            return null;
        else
            return liste.get(0);
    } // premierElement
 
    /**
     * Retourne la reference de l'objet en fin de liste
     * @return reference de l'objet ou null si liste vide
     */
    public T dernierElement (){
        if(estVide())
            return null;
        else
            return liste.get(liste.size()-1);
    } // dernierElement
 
    /**
     * Retourne la reference de l'élement de la liste qui suit 
     * celui spécifié en paramètre
     * @return la référence de l'objet suivant ou null si liste vide ou fin de la liste
     */
    public T successeurDe (T element){
        if( estVide() || liste.indexOf(element) >= nbElements() )
            return null;
        else
            return liste.get(liste.indexOf(element)+1);
    } // successeurDe
 
    /**
     * Retourne la reference de l'élement de la liste qui précède
     * celui spécifié en paramètre
     * @return la référence de l'objet precedent ou null si liste vide ou début de la liste
     */
    public T predecesseurDe (T element){
        if( estVide() || liste.indexOf(element) <= 0)
            return null;
        else
            return liste.get(liste.indexOf(element)-1);
    } // predecesseurDe
 
 
 
}

Raaah, du Java 5.0... je suis resté sur le 1.4...
Bon, je vais quand même essayer...

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
 
boolean flag;
 
System.out.println("VERIFIER CODE");
 
do {
    codeInventaire = saisirCodeInventaire();
 
    flag=false;
    String element;
 
    for (int i=0;i<liste.size();i++) {
        if (i==0) {
            element=liste.premierElement();
        } else {
            element=liste.successeurDe(element);
        }
 
        if (element.equals(codeInventaire)) {
            System.out.println("ERREUR CODE INVENTAIRE!");
            flag=true;
            break;
        }
    }
} while (flag)

Ca devrait passer...

19/02/2006, 12h41
Scorpyosis

Le choix d'une ArrayList est il obligatoire, car là tu as une liste que tu dois parcourir a chaque fois pour trouver le bon element, ou non. Moi j'utiliserai une HashTable, car tu est typiquement dans le cas d'une clé/valeur.
Dans ton cas la clé serait le code de l'outil et la valeur le produit en lui même.
19/02/2006, 14h37
codexomega

Oui, je suis obligé de passer par ArrayList, car c'est un TP universitaire.
Le prof nous a donné une interface et il a dit ce qu'on a toutes les méthodes necessaires pour faire le travail....
C'est sure qu'il est con ce mec, mais qu'est-ce que je pourrais faire?
Donc je cous remercie encore une fois pour les réponses.
Je vais tester la solution proposée.
19/02/2006, 18h14
codexomega

Merci à tous de m'avoir repondu.
Vous m'avez beaucoup aidé.
Maintenant mon application fonctionne.