Discussion :

[missd12]

Bonjour,

Je cherche le moyen de trier une liste selon plusieurs élément des objets.
J'ai une liste A contenant plusieurs objets B et je souhaite tri cette liste par ordre décroissant de l'élément IndiceA (qui est un integer allant de 1 à 6) de mes objets, Si un objet dispose d'un indice identique, je réalise le tri sur la date de mes objet, à date identique on fait le tri sur un numero de l'objet. Pour être plus précis voila ce que j'ai:

Nom Objet Indice Date Num
A 2 01/01/2010 10
B 3 05/06/2010 11
C 4 03/07/2004 12
D 1 06/07/2009 13
E 3 05/06/2010 14
F 1 03/03/2005 15


et aprés avoir effectuer le tri je souhaite avoir:

Par odre décroissant de l'indice, si deux indice identique par date croissante, si date identique par num croissant


Nom Objet Indice Date Num
C 4 03/07/2004 12
B 3 05/06/2010 11
E 3 05/06/2010 14
A 2 01/01/2010 10
F 1 03/03/2005 15
D 1 06/07/2009 13


Aprés quelques recherche sur Internet j'ai tenté d'utiliser un comparator, mais cela ne fonctionne pas, voici mon code:

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
 
 
public static class Comparateur implements Comparator<ProxyA> 
{ 
 
    public Comparateur() {}         
 
    public int compare(ProxyA o1, 
                             ProxyA o2) 
    {        
 
        int j=o1.getIndice();
        int t=o2.getIndice();
 
     if(j==t)
     {
           Date date1 = o1.getDate();
          Date date2 = o2.getDate();
 
           if(j==t)
           {
                int l= o1.getNUM();
                int j = o2.getNUM();
             }       
      }
 
 
           //
      return j.compareTo(t);
    }    
  }

Merci de votre aide

[Caalador]

Essaie avec Comparable :

5.2.1.1. sort(List)
Cette fonction trie la liste passée en paramètre en fonction de leur "ordonement naturel". Tous les éléments de la liste doivent implémenter l'interface Comparable, et donc redéfinir la fonction compareTo(Object), qui renvoie 0 si les deux objets sont égaux, moins si l'objet appelant est "inférieur" et plus si l'objet appelant est "suppérieur". Par exemple :

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
public class Personne implements Comparable
{
  public String nom,prenom;
  Personne(String nom, String prenom)
  {
    this.nom=nom;
    this.prenom=prenom;
  }
  public int compareTo(Object o) // on redéfinit compareTo(Object)
  {
    Personne p=(Personne)o;
    if(nom.equals(p.nom))
    {
      return prenom.compareTo(p.prenom);
    }
   return nom.compareTo(p.nom);
  }
}

Supposons ensuite une liste l de Personne, pour la trier, il suffira d'appeler Collections.sort(l).

[thelvin]

Essaie avec Comparable :

Oui, c'est pas plus mal de faire que ProxyA implémente Comparable<ProxyA>, puisque c'est voué à être comparable. Mais bon, là le problème c'est sur l'implémentation de compare() ou compareTo().

C'est vrai qu'il y a des chances de se tromper, mais l'idée est simple :
- si l'indice de o1 est inférieur à celui de o2, renvoyer 1 pour "classé après" ou "supérieur"
- si c'est l'inverse, renvoyer -1
- si c'est égal, comparer les Dates avec o1.getDate().compareTo(o2.getDate()) :
-- si c'est différent de zéro, le renvoyer tel que, puisque c'est le bon ordre.
-- si c'est zéro, comparer les NUMs comme au début, mais croissant.
--- si même les NUMs sont égaux, renvoyer zéro.

[merill]

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
 
 
public static class Comparateur implements Comparator<ProxyA> 
{ 
 
    public Comparateur() {}         
 
    public int compare(ProxyA o1, 
                             ProxyA o2) 
    {        
 
        int j=o1.getIndice();
        int t=o2.getIndice();
 
     if(j==t)
     {
           Date date1 = o1.getDate();
          Date date2 = o2.getDate();
 
           if(j==t)
           {
                int l= o1.getNUM();
                int j = o2.getNUM();
             }       
      }
 
 
           //
      return j.compareTo(t);
    }    
  }

Merci de votre aide

probleme d'algorithme

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

public static class Comparateur implements Comparator<ProxyA> 
{ 
 
    public Comparateur() {}         
    
    public int compare(ProxyA o1, 
                             ProxyA o2) 
    {        
    
        int j=o1.getIndice();
        int t=o2.getIndice();

     if(j==t)
     {
           Date date1 = o1.getDate();
          Date date2 = o2.getDate();
// j et t n'on pas bougé, donc sera toujour vrai
           if(j==t)
 plutot faire cela
           int res=date1.compareTo(date2);
           if(res == 0)
           {
                int l= o1.getNUM();
                int j = o2.getNUM();
             }       
            else
             {
                 return res;
              }
      }


           //
      return j.compareTo(t);
    }    
  }

enfin, après c'est a toi de vérifier que ton algo fait bien ce que tu veux qu'il fasse

[missd12]

Merci pour vos réponses j'ai trouvé la solution grâce à vous