Java 1.6 : ResultSet et Collection

Bonjour.

Actuellement, nous avons des applications (Web mais problématique idem en "non-web") en java 1.4. Nous allons les passer en Java 1.6 et j'aurais voullu connaitre les bonnes pratiques. Je m'explique.

En 1.4 :
Lorsque nous faisons une requete sur une table PERSONNE (par exemple), nous récupérons un ResultSet que nous chargons dans un Vector, ce qui nous fait un Vector de Personne.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

Vector resultat=new Vector(); ResultSet rs = s.executeQuery(requete); while(rs.next()) { String mat = rs.getString(1); ... Personne personne = new Personne(mat,...); resultat.add(personne); } return resultat.elements();

---

Ensuite, pour afficher la liste de résultat dans la JSP, nous utilisons une Enumeration (passées dans un paramètre) et bouclons dessus :

Code:

---

1 2 3 4 5 6 7

Enumeration personnes = (Enumeration) request.getAttribute("personnes"); while (personnes.hasMoreElements()) { Personne pers = (Personne) personnes.nextElement(); ... }

---

En Java 1.6, j'ai cru lire qu'il fallait mieux éviter d'utiliser les Enumeration, et utiliser les Iterator (pour utiliser la nouvelle boucle for)
L'idéal est-il de mettre le ResultSet dans une ArrayList, puis d'utiliser un Iterator à a place de l'Enumeration?
ou de continuer à utiliser des Vector (ou d'autres types List, LinkedList...)?
Ou utiliser des ListIterator au lieu d'Iterator?

Merci d'avance

Salut,

Citation:

---

Envoyé par johannsan

En Java 1.6, j'ai cru lire qu'il fallait mieux éviter d'utiliser les Enumeration, et utiliser les Iterator (pour utiliser la nouvelle boucle for)

---

Ces remarques s'appliquent déjà en Java 1.4... En fait cela s'applique depuis Java 1.2 et la "nouvelle" API de Collections...
Vector, Hashtable et Enumeration sont des classes qui datent de Java 1.0 et qui sont inutilement synchronisé (donc potentiellement moins performante). Elles ont été remplacées respectivement par ArrayList, HashMap et Iterator qui correspondent à la nouvelle API de Collections, et qui respectent des interfaces bien précises (Collection, List, Map).


Il n'y a pas de raison de les utiliser, sauf si c'est pour compatibilité avec de vielles APIs qui les utiliserait.
De plus dans une application Web, si la liste reste dans la request d'un utilisateur, il n'y a pas besoin de synchronisation puisqu'on reste dans le même thread.

Et en cas de synchronisation, on utiliserait plutôt Collections.synchronizedList()

Citation:

---

Envoyé par johannsan

L'idéal est-il de mettre le ResultSet dans une ArrayList, puis d'utiliser un Iterator à a place de l'Enumeration?

---

Oui ! Mais pas besoin de retourner un Iterator mais directement l'ArrayList (ou son interface List)
Cette remarque s'appliquait déjà à ton précédent code : le fait de retourner un Vector/ArrayList est plus souple puisqu'on peut éventuellement traiter les données, les tiers voir les parcourir plusieurs fois. Choses que l'on ne peut pas faire avec une Enumeration/Iterator qui ne se parcourent qu'une seule fois...

Code:

---

1 2 3 4 5 6 7 8 9

List<Personne> resultat = new ArrayList<Personne>(); ResultSet rs = s.executeQuery(requete); while(rs.next()) { String mat = rs.getString(1); ... Personne personne = new Personne(mat,...); resultat.add(personne); } return resultat;

---

En fait le groschangement viendra de l'apparition des Generics, qui signalera le type d'objet à stocker dans la liste.

Cela implique également un warning lors du cast de la liste depuis la request, car le compilateur ne peut vérifier que le typeage Generics soit correct.
Tu peux ignorer cela avec @SuppressWarnings("unchecked") :

Code:

---

1 2 3 4 5 6

@SuppressWarnings("unchecked") List<Personne> personnes = (List<Personne>) request.getAttribute("personnes");   for (Personne pers : personnes) { ... }

---

Citation:

---

Envoyé par johannsan

ou de continuer à utiliser des Vector (ou d'autres types List, LinkedList...)?

---

List est une interface. Tu peux l'utiliser comme type déclaré (je te le conseille même) mais il te faudra choisir une implémentation spécifique (ArrayList fait généralement l'affaire).

Le fait de déclarer en List te permettra éventuellement de changer le type de liste plus tard si le besoin s'en fait sentir... Mais là il faut étudier les spécificité de chaque implémentation. ArrayList devrait amplement suffire à mon avis ;)

Citation:

---

Envoyé par johannsan

Ou utiliser des ListIterator au lieu d'Iterator?

---

ListIterator c'est surtout utile si tu as des besoins complexe de parcours, incluant des retours en arrières ou des modifications...





Ca n'a rien à voir, mais comme tu es dans une application web, tu pourrais regarder du coté de la JSTL et des EL pour la partie présentation dans la JSP, qui pourrait correspondre à ceci :

Code:

---

1 2 3

<c:forEach var="pers" items="${personnes}"> ${pers.mat} </c:forEach>

---

a++

Merci pour cette réponse très complète.

Une question subsidiaire : tu dis :

Citation:

---

Code:

---

1 2 3 4

List<Personne> resultat = new ArrayList<Personne>(); .... return resultat;

---

puis :

Code:

---

1 2 3 4 5 6 7

List<Personne> personnes = (List<Personne>) request.getAttribute("personnes");   for (Personne pers : personnes) { ... }

---

---

En Java 1.4, je n'ai pas cette boucle for, donc je suis bien obligé d'utiliser Iterator pour boucler sur la List :

Code:

---

1 2 3 4 5 6

Iterator iter = resultat.iterator(); while (iter.hasNext()) { ... iter.next(); ... }

---

C'est ça?
Merci

Oui tout à fait !


a++