Discussion :

[roms712]

Bonjour,

voici mon problème, en fait je dois réaliser la transformée de Burrows Wheeler.
je lis des octets dans un fichier :

par exemple (valeurs entre 0 et 255)
88|84|69|84|69|
je calcule toutes les permutations possible :
88|84|69|84|69|
69|88|84|69|84|
84|69|88|84|69|
69|84|69|88|84|
84|69|84|69|88|

ensuite je dois "trier" la matrice par ordre alphabétique pour obtenir ceci
69|84|69|88|84|
69|88|84|69|84|
84|69|84|69|88|
84|69|88|84|69|
88|84|69|84|69|

ensuite je dois cherche la position dans la matrice triée du groupe d'octets du début
88|84|69|84|69| -> dernière ligne

en fait quand je lis mon groupe d'octets
je transforme ma matrice de byte en tableau de String

Code :

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

1
2
3
4
5
String[] tab=new String[5];
tab[0]=new String(matrice[0]);
tab[1]=new String(matrice[1]);
...
tab[4]=new String(matrice[4]);

puis j'applique un tri rapide sur ce tableau de String et je repasse ensuite les résultats dans ma matrice en faisant :
matrice[i]=String[i].getBytes();

ça marche donc sur les fichiers texte mais dès que je le fais sur des fichiers binaires ça plante on dirait qu'il n'arrive pas à trier mon tableau de String qui ont d'ailleurs des caractères bizarres (caractères spéciaux du genre tabulation, NULL, ...) vu que les valeurs d'octets vont entre 0 et 255, tout du moins entre -128 et 127 en java.
donc ma question est de savoir si je dois passer par des String pour trier ma matrice de byte dans la façon expliquée plus haut? si non, je vois pas comment faire...j'ai une autre solution qui marche mais qui est très lente...

[LGnord]

Au lieu de trier des strings, tu peux trier des tableaux de bytes quitte à définir ton propre comparateur.

Tu eviteras ainsi les problèmes avec les carractéres spéciaux.

[iohack]

Au lieu de trier des strings, tu peux trier des tableaux de bytes quitte à définir ton propre comparateur.

Tu eviteras ainsi les problèmes avec les carractéres spéciaux.

Même pas besoin vu que ça existe dans le JDK :
http://java.sun.com/j2se/1.5.0/docs/...html#sort(byte[])

[roms712]

non ce n'est pas ce que je cherche...
il n'y a pas de méthode java.util.Arrays.sort(byte[][] matrice)
je cherche pas à trier un tableau mais une matrice de byte pour "trier" les lignes...

j'ai essayé d'utiliser ByteBuffer (qui a un compareTo(ByteBuffer), ça trie mais pas comme je voudrais après peut être qu'il y a une petite astuce mais là je vois pas...

voilà en gros 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
ByteBuffer[] tab = new ByteBuffer[taille];
 
for(int i=0; i<taille; i++)
{
   tab[i]=ByteBuffer.wrap(matrice[i]);
   matrice[i]=null;
}
 
java.util.Arrays.sort(tab);
//je reremplis ma matrice avec le tableau trié
for(int i=0; i<taille; i++)
{
   matrice[i] = new byte[taille];
   matrice[i]=tab[i].array();
   tab[i] = null;
}
afficherMatrice();

voilà mon jeu d'essai : fichier texte qui contient "abcdé" -> en octet 97|98|99|100|-23|

non trié avec valeurs entre - 128 et 127
97|98|99|100|-23|
-23|97|98|99|100|
100|-23|97|98|99|
99|100|-23|97|98|
98|99|100|-23|97|
non trié avec valeurs entre 0 et 255
97|98|99|100|233|
233|97|98|99|100|
100|233|97|98|99|
99|100|233|97|98|
98|99|100|233|97|

ce que j'obtiens en "trié" :

-23|97|98|99|100|
97|98|99|100|-23|
98|99|100|-23|97|
99|100|-23|97|98|
100|-23|97|98|99|


233|97|98|99|100| -> pas bon
97|98|99|100|233|
98|99|100|233|97|
99|100|233|97|98|
100|233|97|98|99|
donc en fait il le trie bien mais suivant les valeurs comprises entre -128 et 127

alors que moi j'aurais voulu avoir ça : (valeurs entre 0 et 255)
97|98|99|100|233|
98|99|100|233|97|
99|100|233|97|98|
100|233|97|98|99|
233|97|98|99|100|

[deltree]

il n'y a pas de méthode java.util.Arrays.sort(byte[][] matrice)
je cherche pas à trier un tableau mais une matrice de byte pour "trier" les lignes...

Il y a la méthode Arrays.sort(Object[] o , Comparator c) que tu peux appeler avec:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
	  byte[][] matriceTest = {{ 0x01,0x02}};
 
	  Arrays.sort(matriceTest, new Comparator(){
	  public int compareLine(byte[] a_o1, byte[] a_o2) {
		    //TODO comparer la ligne
	    return 0;
		  }
	    public int compare(Object a_o1, Object a_o2) {
	      return compareLine((byte[]) a_o1, (byte[]) a_o2);
	    }});

(mon exemple de matriceTest est crétin, et le comparator est à coder mais le principe est là )

[roms712]

ouais mais justement c'est la comparaison des tableaux de byte qui me posent problème...c'est peut être plus un problème d'algo que de java car je vois pas comment comparer deux tableaux de byte, ce qui me gène c'est que c'est entre -128 et 127

exemple comment savoir que ce tableau
-23|97|98|99|100| est "supérieur" à celui ci 100|-23|97|98|99|