Vector de Personnes

Version imprimable

Vector de Personnes

Bonjour,
je voudrais créer une classe ListeDePersonnes qui servira à mémoriser des Personnes et j'aimerais le faire avec un Vector.

Code:

1
2
3
4
5
6
 
public class Personne{	
        private String nom;
	private String prenom;
	...
}

Pour commencer, pouvez-vous me dire si ceci est correcte?

Code:

1
2
3
4
5
 
public class ListeDePersonnes{
    Vector listePers = new Vector ();
 
}

Ensuite, je rajouterais une méthode pour tester le fonctionnement du vecteur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class ListeDePersonnes{
    Vector listePers = new Vector ();
 
    public void testVector(){    
        listePers.addElement(new Personne (André, Tara);
        listePers.addElement(new Personne (Antoine, Dupont);
        listePers.addElement(new Personne (Antoinette, Durand);
 
    // ici je voudrais parcourir mon vecteur avec un foreach 
    // afficher le nom des trois personnes mais je n'y arrive pas... 
 
    }
 
}

08/10/2009, 16h29
Djakisback

Salut,
est-ce que le choix du Vector est imposé ? car en théorie une ArrayList est plus adaptée si t'utilises un seul thread (faq1, faq2).
A part ça, il serait plus simple d'étendre Vector ou ArrayList plutôt que de stocker une liste interne. Sinon pour ton for et le typage tu peux regarder ici.
Bye
08/10/2009, 16h30
zorm
Bonjour,

En quelle version de java travailles tu?
Parce que les Vector ne sont plus utilisés depuis un moment.
http://java.developpez.com/faq/java/...IONS_info_list

Et grâce aux classes génériques, tu n'as surement pas besoin de créer cette classe:

si tu fais :

Code:

List<Personne> listePersonne = new ArrayList<Personne>();

Tu pourras faire après
Code:

1 2 3 4 for(Personne personne : listePersonne){ personne.methode(); }
08/10/2009, 17h15
alex2746

Je suis obligé d'utiliser un Vector...

D'avance merci.
09/10/2009, 11h16
dingoth

Bon bah...

Code:

List<TaClasse> list = new Vector<TaClasse>();

Et quand tu ne seras plus obligé d'utiliser Vector, remplace-le par ArrayList ;)

Ici est là question

Citation:

Envoyé par alex2746

// ici je voudrais parcourir mon vecteur avec un foreach
// afficher le nom des trois personnes mais je n'y arrive pas...

}

}

Une réponse possible :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Dans la classe Personne public String getNom(){return this.nom;} public String getPrenom(){return this.prenom;} Dans ton Main par exemple : Enumeration e=listePers.elements(); System.out.println("Les personnes enregistrées"); while(e.hasMoreElements()){ Personne laPersonne = (Personne) e.nextElement()); System.out.println(laPersonne.getNom() + " " + laPersonne.getPrenom()); }

10/10/2009, 14h50
alex2746
Salut, je dois utiliser un FOREACH obligatoirement, pas un itérateur...

Je pensais pouvoir donc écrire ceci, mais ca ne marche pas:
Code:

1 2 3 for (Personne p : listePers) System.out.println("rien");
Quelqu'un pourrait m'aider à utiliser le FOREACH pour parcourir mon vecteur?

Merci d'avance.
10/10/2009, 15h29
dingoth

Oui, change l'initialisation de ton vecteur pour ceci :

Code:

Vector<Personne> listePers = new Vector<Personne>();
10/10/2009, 20h17
alex2746
Merci.
Un conseil...
on me demande donc de créer une classe servant à mémoriser des Personnes et d'utiliser pour ce faire un Vector.

Est ce mieux de déclarer le Vector en private ou non?

Donc, ceci?
Code:

1 2 3 4 public class ListePersonnes{ private Vector<Personne> listePers = new Vector <Personne> (); }
Ou ceci?
Code:

1 2 3 4 public class ListePersonnes{ Vector<Personne> listePers = new Vector <Personne> (); }
Dernière chose:
Si on me demande uniquement de faire ce que j'ai décris plus haut, je n'ai pas besoin de constructeurs, autres attributs, méthodes, etc?

Merci d'avance.
11/10/2009, 15h52
michel.di

normalement tu déclares tes attributs en private et tu ne donnes que les accesseurs nécessaires. Tout les attributs ne sont pas forcément visible pour l'extérieur

Sinon tu peux aussi implémenter Iterable voir le code ci-dessous.

Je suis contre l'héritage de Vector. La composition reste une meilleur solution. En effet, si tu hérite de Vector, ton objet va posséder les méthodes addElement, removeElement,... Si un jour tu décides de plus utiliser Vector mais ArrayList, alors tu devras soit recoder tous les clients de la classe, soit implémenter ces méthodes. Dans la composition, tu expose uniquement les méthodes que tu veux (et avec le nom que tu décides). Donc même si tu changes ton implémentation, les clients ne changent pas.

Pour des raisons un peu similaires à la composition, ta liste de personnes peut être de type List en utilisant la classe Vector comme implémentation. Si un jour tu changes l'implémentation en ArrayList, le reste de ta classe ne change pas.

C'est pourquoi je propose comme solution les classes suivantes :

La classe Personne

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 class Personne {
    private String nom;
    private String prenom;
 
    public Personne() {
    }
 
    public Personne(String prenom, String nom) {
        this.nom = nom;
        this.prenom = prenom;
    }
 
    public String getNom() {
        return nom;
    }
 
    public void setNom(String nom) {
        this.nom = nom;
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
}

La classe ListeDePersonne :

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
 
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
 
public class ListeDePersonnes implements Iterable<Personne> {
    private List<Personne> listePers = new Vector<Personne>();
 
    public boolean add(Personne p) {
        return listePers.add(p);
    }
 
    public boolean addAll(Collection<Personne> p) {
        return listePers.addAll(p);
    }
 
    public Iterator<Personne> iterator() {
        return listePers.iterator();
    }
 
    public boolean remove(Personne p) {
        return listePers.remove(p);
    }
 
    public boolean removeAll(Collection<Personne> personnes) {
        return listePers.removeAll(personnes);
    }
 
    public int size() {
        return listePers.size();
    }
}

La classe de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class TestPersonne {
 
    public static void main(String[] args) {
        ListeDePersonnes listePersonnes = new ListeDePersonnes();
        listePersonnes.add(new Personne("André", "Tara"));
        listePersonnes.add(new Personne("Antoine", "Dupont"));
        listePersonnes.add(new Personne("Antoinette", "Durand"));
 
        for (Personne p : listePersonnes) {
            System.out.println(p.getPrenom() + " " + p.getNom());
        }
    }
}