Discussion :

[toufou]

Bonsoir,

Voilà mon problème...

J'ai un tableau de strings data[4][100]

avec par exemple:

Code :

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

1
2
3
4
data[0]={voiture,camion,helicoptere}
data[1]={chien,chat,tigre}
data[2]={assiette,verre,fourchette}
data[3]={patate,haricots,tomates}

passionant comme tableau

Je voudrais pouvoir trier data[0] par ordre alphabetique et que data[1],data[2] t data[3] suivent pour donner le resultat:

Code :

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

1
2
3
4
5
 
data[0]={camion,helicoptere,voiture}
data[1]={chat,tigre,chien}
data[2]={verre,fourchette,assiette}
data[3]={haricots,tomates,patate}

Aprs quelques recherche je retombe regulierement sur ce type de code:

Code :

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

1
2
3
4
5
6
7
8
  Arrays.sort(data, new Comparator<String[]>() {
			            @Override
			            public int compare(final String[] entry1, final String[] entry2) {
			                final String time1 = entry1[0];
			                final String time2 = entry2[0];
			                return time1.compareTo(time2);
			            }
			        });

Malgré avoir lu la doc des fonctions sort et compareto j'ai un peu de mal à comprendre le fonctionnement...et surtout j'ai l'impression que le code est fait pour deux colonnes.

Comment faire pour ma situation?

Merci,
TouFou

[joel.drigo]

Salut,

Arrays.sort() permet de trier un tableau à une dimension. Ton tableau à 2 dimensions est considéré comme un tableau de tableaux, soit un tableau de lignes. Le comparateur sert à indiquer d'entre 2 valeurs, laquelle est plus petite que l'autre, ou si elles sont égales (la méthode compare retourne un nombre négatif si v1<v2, 0 si v1 égal à v2, un nombre positif si v1>v2).

Le problème c'est que tu veux trier des colonnes et pas des lignes. C'est pour ça que le comparateur prend des tableaux de String en paramètre : chacun correspond à une ligne. Il y a un moyen simple de s'en sortir (pas forcément le plus optimisé) : c'est de transposer ton tableau, soit échanger lignes et colonnes. Ainsi, après transposition, trier les lignes, triera des colonnes. Il te reste plus qu'a retransposer après le tri pour retrouver le tableau de lignes.

Un 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
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
public class Array2DExemple {
 
		public static void main(String[] args) {
		String[][] data = new String[][] {
		{"voiture","camion","helicoptere"},
		{"chien","chat","tigre"},
		{"assiette","verre","fourchette"},
		{"patate","haricots","tomates"}
		};
 
		System.out.println("avant");
		println(data);
 
		data = mySort(data);
 
		System.out.println("après");
		println(data);
 
	}
 
	private static void println(String[][] data) {
		for(String[] line : data ) {
			System.out.println(Arrays.toString(line));
		}
	}
 
	private static String[][] mySort(String[][] data) {
		String[][] transposed = transpose(data);
		sort(transposed);
		return transpose(transposed);
	}
 
	private static void sort(String[][] data) {
		Arrays.sort(data, new Comparator<String[]>() {
			@Override
			public int compare(String[] a1, String[] a2) {
				return a1[0].compareTo(a2[0]);
			}
		});
	}
 
	private static String[][] transpose(String[][] data) {
		String[][] transposed = new String[data[0].length][data.length];
		for(int i=0; i<data.length; i++) {
			for(int j=0; j<data[i].length; j++) {
				transposed[j][i]=data[i][j];
			}
		}
		return transposed;
	}
 
}

[toufou]

Merci pour la réponse. Je testerai ça surement ce week-end.

Et merci pour les explications c'est beaucoup plus clair!!


TouFou

[toufou]

Salut,

Testé et approuvé!


Il y a une chose que je ne comprends toujours pas:
Dans le code:

Code Java :

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

1
2
3
4
5
6
7
private static void sort(String[][] data) {
		Arrays.sort(data, new Comparator<String[]>() {
			@Override
			public int compare(String[] a1, String[] a2) {
				return a1[0].compareTo(a2[0]);
			}
		});

a1 et a2 sont choisis comment dans data? les deux premieres colonnes automatiquement?

Si je veux faire la meme operation mais avec un tri suivant la 3eme colonne, comment je dois procéder?

[joel.drigo]

Salut,

La méthode est utilisée par l'algorithme de tri pour connaitre l'ordre de tri des 2 éléments passés en argument. Lorsqu'on trie un tableau à 2 dimensions, on trie un tableau de tableaux : chaque élément passé en argument est donc un tableau (qu'on appelle communément une ligne).

Le tableau d'origine est le suivant :

|voiture    |camion     |helicoptere|
|chien      |chat       |tigre      |
|assiette   |verre      |fourchette |
|patate     |haricots   |tomates    |

Quand on transpose ce tableau, on obtient :

|voiture    |chien      |assiette   |patate     |
|camion     |chat       |verre      |haricots   |
|helicoptere|tigre      |fourchette |tomates    |

C'est ce tableau qu'on tri. Et a1 et a2 sont des lignes de ce tableau : on détermine l'ordre de ces lignes en disant que c'est l'ordre de a1[0] et a2[0], c'est-à-dire qu'on indique que l'ordre des lignes est celui des données de la première colonne (celle d'indice 0). Tu peux en déduire comment trier selon une autre colonne que la première colonne.

[toufou]

Impeccable, ça tourne à merveille

Merci d'avoir pris le temps de répondre de façon aussi clair et détaillée!


TouFou