Tri dans une Collection

**momodev2008** · 20/08/2009, 15h31

bonjour,

J'ai un gros souci en ce moment car je cherche sans trouver comment trier la colonne Nom et la colonne prenom en fonction de la colonne Nom de ma collection.

J'ai essayé ceci mais le probléme c'est que ça trie que le Nom :

Code :

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

1
2
3
4
5
6
7
listeTiersTransiant = rechercherTiersEnCoursDeNavigation(connection, oids,tiersForm, fechtsize);

Collections.sort((List) listeTiersTransiant,new BeanComparator("nom", 
new NullComparator())); 

tiersForm.setListeTiers(listeTiersTransiant);

**CyberChouan** · 20/08/2009, 17h08

Il est un peu dur de voir le problème sans le typage de tes variables.

Indication :

1) Il te faut un unique objet "Personne" ayant les deux champs "nom" et "prénom".
2) Tu ajoutes ces objets dans une liste
3) Tu crées un Comparator<Personne>
4) Tu tries ta liste à l'aide de ce comparateur

Tu auras ta liste triée sans perdre la relation nom-prénom.

**momodev2008** · 20/08/2009, 17h27

Voici le type de la variable

Code :

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

1
2
3

Collection listeTiersTransiant = new ArrayList(fechtsize);

**Heimdal** · 20/08/2009, 17h35

?!?!!

Ola,
Il eut été plus utile de donner le type des objets que tu insères dans ta liste.

Sinon, CyberChouan t'as donné toutes les infos nécessaires je pense.

**momodev2008** · 20/08/2009, 18h30

Merci pour vos réponses, mon souci c'est que la colonne "nom" se trie bien mais celle des "prénoms" ne se trie pas, auriez vous un exemple de comparateur qui trie les "noms" puis trie les "prénoms" tout en laissant les "noms" triés

**ANoki** · 21/08/2009, 10h31

Bonjour,
Pourquoi faire un collection au lieu d'un liste.
Le but d'une collection, n'est t'il pas davoir les objets en vrac, au contraire d'une liste?

**CyberChouan** · 21/08/2009, 15h47

Envoyé par ANoki

Le but d'une collection, n'est t'il pas davoir les objets en vrac, au contraire d'une liste?

Une collection est un ensemble d'éléments pour lequel on n'a pas besoin d'avoir un ordre (pas de tri possible, par de récupération ou d'insertion d'objet à un emplacement précis).

Mais ce n'est pas pour autant un ensemble d'objets en vrac !

Collection est un type parent du type List : une liste est donc une collection.
Si j'écris "Collection c = new ArrayList();", les objets de ma collection ne seront pas en vrac mais triés par leur ordre d'insertion (l'implémentation réelle de la méthode "add" étant celle d'ArrayList).

Par contre, l'objet étant déclaré comme une collection, on n'aura pas accès aux méthodes spécifiques des listes (insertion et récupération d'un objet à une position précise, etc.)

Si on n'utilise pas les spécificités du type List, il vaut mieux utiliser une Collection : on aura un code plus générique.

Dans le cas qui nous occupe (un tri), il est vrai qu'il vaut mieux utiliser une List (l'API Collections ne faisant des tris que sur des listes).

On voit d'ailleurs bien le problème dans le premier post : l'objet ayant été mal typé pour le besoin qu'on en a, le tri oblige à passer par un cast explicite.

**momodev2008** · 24/08/2009, 12h10

Voici ce que j'ai fait

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
 
public class MonComparator implements Comparator{
 
	MonComparator()
	  {
 
	  }
	  public int compare(Object arg0, Object arg1) 
	  {
		  TiersValue p1 = (TiersValue) arg0;
		  TiersValue p2 = (TiersValue) arg1;
 
		  int result = (p1.getNom().charAt(0)+"").compareTo((p2.getNom().charAt(0)+""));
 
		if(result==0)
 
 
			result = (p1.getPrenom().charAt(0)+"").compareTo((p2.getPrenom().charAt(0)+""));
 
		return result;
	  }

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
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
 
public class RechercherTiers{
 
 
	/**
         * Constructeur de la classe
         */
	public RechercherTiers() {
 
	}
 
.
.
.
.
.
.
.
 
 
List listeTiersTransiant = new ArrayList(fechtsize);
 
listeTiersTransiant = rechercherTiersEnCoursDeNavigation(connection, oids,tiersForm, fechtsize);
 
Collections.sort(listeTiersTransiant,new MonComparator());
 
tiersForm.setListeTiers(listeTiersTransiant);
 
 
 
private List rechercherTiersEnCoursDeNavigation( Connection connection, Collection oids, TiersForm tiersForm,int fechtsize) throws MAECliTechnicalException {
		List listeTiersTransiant = new ArrayList(oids.size());
		TiersValue tiersValueTransiant = null;
		Adresse adresseTransiant = null;
		TiersValue tiersValue = null;
		Adresse adresse = null;
		for (Iterator iter = oids.iterator(); iter.hasNext();) {
			String oid = (String) iter.next();	
			log.debug("========================================== Chargement du tiers id = " + oid);
			tiersValueTransiant = new TiersValue();
			//on charge le tiers correspondant a l'oid de la base
			tiersValue = TiersFactory.getInstance().rechercherTiers(connection, Long.parseLong(oid)).consulterTiers(); 
			adresse = tiersValue.getAdresse();
			if (adresse == null) {
				adresse = new Adresse();
			}    
			//tiersValueTransiant.setPays((Pays) connection.clone(tiersValue.getPays(), true));
			tiersValueTransiant.setId(tiersValue.getId());
			tiersValueTransiant.setPays(tiersValue.getPays());			
			tiersValueTransiant.setCodeTiers(tiersValue.getCodeTiers());
			tiersValueTransiant.setNom(tiersValue.getNom());
			tiersValueTransiant.setPrenom(tiersValue.getPrenom());
			if (tiersValue.getEnseigneRoleTiers() != null) {
				tiersValueTransiant.setEnseigneRoleTiers((RoleTiers) connection.clone(tiersValue.getEnseigneRoleTiers(), true));
			}
			adresseTransiant = new Adresse();	
			adresseTransiant.setVoie(adresse.getVoie());
			adresseTransiant.setCodePostal(adresse.getCodePostal());
			adresseTransiant.setVille(adresse.getVille());
			adresseTransiant.setCodeFoyer(adresse.getCodeFoyer());
			adresseTransiant.setPays((Pays) connection.clone(adresse.getPays(), true));
 
			tiersValueTransiant.setAdresse(adresseTransiant);
			//on ajoute le tiers copié a la liste des tiers chargés
			listeTiersTransiant.add(tiersValueTransiant);			
		}
		return listeTiersTransiant;
	}

ça ne marche toujours pas

**Rei Ichido** · 24/08/2009, 13h03

Bonjour,

1. Si tu veux que ton Comparateur compare des TiersValue, autant le typer (Comparator<TiersValue>). Cela dit il faut compiler du java 1.4 pour ce faire.

2. Pourquoi te limites-tu au premier caractère ? Tu peux faire un compareTo sur les String, ce qui te fera une comparaison alphabétique *avec le problème du classement des minuscules avant les majuscules*.

**momodev2008** · 26/08/2009, 17h49

Merci à tous vos réponses

finalement j'ai pu résoudre mon probléme et voilà ce que j'ai fait

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
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
 
public class MonComparator implements Comparator{
 
	public MonComparator()
	  {
 
	  }
	  public int compare(Object arg0, Object arg1) 
	  {
		  SOAPIndividu p1 = (SOAPIndividu) arg0;
		  SOAPIndividu p2 = (SOAPIndividu) arg1;
 
		  if((p1.getPrenom()==null)||(p1.getPrenom()=="")){
			  p1.setPrenom("");
 
		  }
 
		  if((p2.getPrenom()=="")||(p2.getPrenom()==null)){
			  p2.setPrenom("");
		  }
 
		  if((p1.getNom()==null)||(p1.getNom()=="")){
			  p1.setNom("");
 
		  }
 
		  if((p2.getNom()=="")||(p2.getNom()==null)){
			  p2.setNom("");
		  }
 
 
 
 
int result = (p1.getNom()).compareTo(p2.getNom());
//System.out.println("comparaison de noms:"+p1.getNom()+" et "+p2.getNom());
 
 
 
 if(result==0)				
 
	result = (p1.getPrenom()).compareTo(p2.getPrenom());
	//System.out.println("comparaison de prenoms:"+p1.getPrenom()+" et "+p2.getPrenom());
 
 
 
 
return result;
 
 
 
	  }
 
}

puis

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
 
 
Collection listeTiersTransiants = new ArrayList(fechtsize);
List listeTierTransiants = new ArrayList(fechtsize);
 
.
.
.
.
.
listeTierTransiants.addAll(listeTiersTransiants);
 
.
.
.
.
.
Collections.sort(listeTierTransiants,new MonComparator());
 
tiersForm.setListeTiers(listeTierTransiants);

**CyberChouan** · 26/08/2009, 21h51

Même si ce code résout ton problème, il y a une très mauvaise habitude à perdre dans ce code.

Un Comparator doit normalement comparer deux objets, l'entier renvoyé disant lequel est supérieur à l'autre.

Même si rien ne l'interdit, un Comparator ne devrait normalement en aucun cas modifier les objets qu'il compare !!!

L'utilisation de setters devrait donc être sortie de la méthode compareTo, et mise plus en amont dans le code (avant l'appel au Comparator).

**momodev2008** · 27/08/2009, 10h24

Je suis d'accord avec toi mais ici je reçois le résultat d'un webservices qui n'est pas hébergé chez moi donc il m'est impossible d'avoir accés à ce code. Mais sinon sur le principe je suis d'accord c'est d'ailleurs le modéle MVC 2 .

**CyberChouan** · 27/08/2009, 11h41

Envoyé par momodev2008

Je suis d'accord avec toi mais ici je reçois le résultat d'un webservices qui n'est pas hébergé chez moi

Et alors ?... Je pense que tu n'as pas bien compris ma remarque.
Même si tes objets sont récupérés d'un webservice, rien ne t'empêche de faire ton test et ton set en dehors du comparator afin de ne pas dénaturer la fonction de celui-ci !

Ton code :

Code :

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

1
2
3
List<SOAPIndividu> liste = getListeIndividusFromWS();
Collections.sort(liste, tonComparator);
// Le tri de la liste MODIFIANT celle-ci puisque "tonComparator" effectue des modifications sur les objets de la liste :s

Ma proposition (qui rend au Comparator sa fonction de comparaison uniquement, et qui fonctionne avec un webservice) :

Code :

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

1
2
3
4
5
6
List<SOAPIndividu> liste = getListeIndividusFromWS();
 
// Pour chaque individu de la liste, verifier la nullité des champs nom/prenom en les remplaçant par "" le cas échéant
 
Collections.sort(liste, tonNouveauComparator);
// Le tri de la liste NE MODIFIANT PAS celle-ci puisque la correction des champs nuls a déjà été effectuée avant d'entrer dans la méthode de tri !

**Rei Ichido** · 27/08/2009, 11h45

De plus, le comparateur pourrait très bien gérer le cas de nullité à part, sans avoir à remplacer quoi que ce soit, avec une convention null << non null par exemple.

**Heimdal** · 27/08/2009, 12h25

Très d'accord avec les remarques précédentes.
Je me permets de rajouter une remarque:

Code :

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

1
2
 
p1.getPrenom()==""

always false et clairement inutile étant donné la nature du vilain setter appelé alors.

**Rei Ichido** · 27/08/2009, 12h55

Ce n'est pas toujours false, par la magie du String pool

**Heimdal** · 27/08/2009, 13h02

:o Diable, lorsque j'ai pu écrire des trucs comme ça, j'ai jamais constaté qu'il pouvait être true.
Y a une logique quand même ou c'est la loi du chaos qui règne sur ce bout de code?

**Rei Ichido** · 27/08/2009, 13h05

Essentiellement, les Strings affectées directement par un litteral à la compilation viennent du String pool et donc seront == ; les String crées par un new, elles, ne le seront pas. Cela dit il y a des subtilités avec lesquelles je ne suis pas familier ^^

**momodev2008** · 31/08/2009, 11h38

OK les amis ! j'ai reçu une belle leçon de programmation, bref je me remet au boulo !

A plus !!!

Tri dans une Collection

Collection et Stream Java

Discussions similaires

Partager

Partager