Discussion :

[bankette]

Bonjour,

J'ai recherché mais je ne trouve rien qui réponde à mon souci, que je ne dois pas être le premier à me poser. Il doit me manquer les bon mots clés....

J'ai un arrayList contenant des Strings, je souhaite les trier.
Mon souci étant que tous mes strings sont composés d'une lettre , d'un espace et d'un chiffre.
exemple :
a 1
b 1
a 2
b 12
a 10
b 3

Lorsque je tri, j'obtient :
a 1
a 10
a 2
b 1
b 12
b 3

Alors que je souhaiterai :
a 1
a 2
a 10
b 1
b 3
b 12

Comment puis-je faire?

Merci d'avance

[adiGuba]

Salut,


Si tes chaines ont toutes le même format, tu peux utiliser un Comparator spécifique qui découpera la chaine :

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
class SComparator implements Comparator<String> {
	@Override
	public int compare(String s1, String s2) {
		// On recherche les espaces :
		int index1 = s1.indexOf(' ');
		int index2 = s1.indexOf(' ');
 
		// Si on ne trouve pas d'espace dans une des chaines :
		if (index1<0 || index2<0) {
			// On fait une comparaison standard :
			return s1.compareTo(s2);
		}
 
		// Sinon on compare d'abord la chaine devant l'espace :
		int diff = s1.substring(0, index1).compareTo(s2.substring(0, index2));
 
		// si la première partie est identique :
		if (diff==0) {
			// On compare les valeurs numériques :
			int v1 = Integer.parseInt(s1.substring(index1+1));
			int v2 = Integer.parseInt(s1.substring(index2+1));
 
			diff = v1-v2;
		}
		return diff;
	}
}

Bien sûr si le format n'est pas respecté cela plantera...

Après il y a surement mieux à faire en gérant n'importe quelle format chaine !


a++

[SucreGlace]

Comment puis-je faire?

Implémente un Comparator qui effectue exactement la comparaison que tu désires...

[bankette]

Super, c'est exactement ce qu'il me fallait, je ne connaissais pas.

J'ai repris la fonction de adiGuba et les doc de SucreGlace et j'ai fais une petite fonction qui va bien, elle compare deux chaines mot à mot et si deux mots sont des entiers elle fait une comparaison sur leur valeur. Comme ça quelle que soit la structure du string pas de risque de plantage.

Si vous voyez une faille, n'hésitez pas

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
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
 
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;
 
/**
 *
 * @author bankette
 */
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // on crée une liste comme on veut
        List test = new ArrayList();
        test.add("b 1");
        test.add("b 01");
        test.add("b 01 zz");
        test.add("b 1 zz");
        test.add("b 1");
        test.add("af b 1");
        test.add("ba b 1");
        test.add("bcd 1");
        test.add("b 11");
        test.add("b 5 zzz");
        test.add("b 1");
        test.add("a 2");
        test.add("a 1");
        test.add("b 1");
        test.add("a 10");
        Collections.sort(test, new SComparator());
        for(int i = 0; i < test.size(); i++){
            System.out.println(test.get(i));
        }
 
 
    }
 
}
 
class SComparator implements Comparator<String> {
	@Override
	public int compare(String str1, String str2) {
            // on crée deux listes qui contiendront les mots de chaque String
            List listS1 = new ArrayList();
            List listS2 = new ArrayList();
            StringTokenizer st = new StringTokenizer(str1);
            int i=0;
            // on rempli la première liste
            while (st.hasMoreTokens()) {
                listS1.add(st.nextToken());
                //System.out.println("décomposé en " +listS1.get(i));
                i++;
            }
            // on rempli la seconde liste
            st = new StringTokenizer(str2);
            i=0;
            while (st.hasMoreTokens()) {
                listS2.add(st.nextToken());
                //System.out.println("décomposé en " +listS2.get(i));
                i++;
            }
 
            // On compare les chaines une a une dans chaque liste
            int diff;
            i=0;
            while (i<listS1.size() && i<listS2.size()) {
                String s1 = ""+listS1.get(i);
                String s2 = ""+listS2.get(i);
                if(estUnEntier(s1) && estUnEntier(s2)){
                    int v1 = Integer.parseInt(s1);
                    int v2 = Integer.parseInt(s2);
                    diff = v1-v2;
                    if(diff!=0){
                        return diff;
                    }
                }else{
                    // On fait une comparaison standard :
                    diff =  s1.compareTo(s2);
                    if(diff!=0){
                        return diff;
                    }
                }
                i++;
            }
            // si une chaine est égal a l'autre plus d'autres mots, la plus longue sera donc à la fin
            return listS1.size()-listS2.size();
 
 
	}
 
        public boolean estUnEntier(String chaine) {
		try {
			Integer.parseInt(chaine);
		} catch (NumberFormatException e){
			return false;
		}
 
		return true;
	}
}

Bon bien sur 'a 01' et 'a 1' seront considéré comme strictement égaux, mais c'est ce que je voulais.

Encore merci pour votre aide