Lecture de fichier hexa

**seiryujay** · 27/09/2005, 16h35

Bonjour,

Je voudrais savoir comment faire pour lire un fichier en hexa?
Parce que j'ai un fichier qui contient une première partie textuelle et une deuxième partie en binaire. Et la limite entre ces 2 parties est lo position d'un caractère [EOF] dont le code ASCII est 26 et la valeur hexa 1A.

Il faudrait donc que je récupère la popsition de ce caractère afin de pouvoir me placer en tête de la partie binaire.

Merci!

**ghorgor** · 28/09/2005, 08h21

Ca peut se faire en choisissant l'encodage, sur la classe String (regarde le constructeur String(byte[] bytes, String enc)

Par defaut, String est en ASCII...

Ce que je ferais a ta place :

Fais une lecture binaire de ton fichier, par exemple par bloc de 1000 bytes.

Tu récupéres un byte[] en entrée, que tu convertis en String, simplement, (new String(byte[])), et tu recherches ton charactere EOF... (IndexOf(EOF)). Pour ton EOF, regarde si tu peut le definir avec "\u0026"...

La, tu as ton indice, et tu peux continuer ta lecture toujours en byte, et convertir ca en un String, de la meme maniere, mais en changeant l'encodage, lors de ta conversion byte[] -> String, et tu as ta lecture mixte en ASCII et en Hexa...

**seiryujay** · 28/09/2005, 09h15

Merci msieur.
En fait, je venais de le résoudre avant de lire ton post...

Voilà ce que j'ai fait (je sais pas si c'est la solution la plus jolie, mais en tout cas, ça marche)

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
 
private int getFINIndex2() {
		try {
			ra = new RandomAccessFile(pathname,"r");			
			ds = new DataInputStream(new BufferedInputStream(new FileInputStream(pathname)));
 
			byte buff;
			int toReturn = 0;
			int index = -1;
			boolean eof = false;
 
			try{
				ra.seek(0);		
				int nbLines = 0;
				while(!eof){
					buff = ra.readByte();
					toReturn ++;
					nbLines++;
					if (buff == 26){ // 26 = caractère de fin de la partie en-tête...
						//cest la bonne ligne
//						System.out.println(toReturn);
						return toReturn;
					}
				}
 
				return -1;	
			}
			catch (EOFException e) {
				eof = true;
			}
			catch(Exception e){
				e.printStackTrace();
			}
 
		}
		catch(NumberFormatException nbe){
			nbe.printStackTrace();
			System.out.println("NOT A NUMBER");
		}
		catch(NullPointerException ne){
			ne.printStackTrace();			
			System.out.println("ERROR IN ATTRIBUTE NAME : NOT FOUND IN FILE");	
		}
		catch(Exception e){
			e.printStackTrace();
		}
 
		return -1;
	}

Si vous trouvez ça ignoble, dites le moi...

**ghorgor** · 28/09/2005, 09h24

Ca marche, c'est clair, par contre, si tu as des gros fichiers, tu auras du mal a faire ca de cette maniere, car ton traitement risque d'etre long, vu que tu lis tes byte un a un...

Si tu n'as que des petits fichiers, il n'y aura pas de conséquence...

Si tu as par contre des fichiers qui font quelques dizaines de Mo, ta méthode marchera, mais tu auras le temps d'aller prendre un café, de faire un ciné, d'aller au resto, et de prendre quelques vacances en Papouasie supérieure avant que ca ne soit fini... (Bon, j'exagere un peu, mais à peine...)

ton :

Code :

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

buff = ra.readByte();

Consomme beaucoup, il vaut mieux diminuer le nombre d'accès en lecture / Ecriture. Si tu as un fichier de 1 Ko, tu auras en gros 1000 accès, je te laisse imaginer sur un fichier de 48 Mo...

Après, ca dépend de ton appli, et de la taille de ta partir texte au début...

**seiryujay** · 28/09/2005, 10h02

Tu me conseillerai quoi alors?

**ghorgor** · 28/09/2005, 10h07

Ben ca dépend de ton appli... Si c'est des petits fichiers de 10 Ko que tu vas avoir, ne t'inquiete pas trop, ca passera...

Sinon, je te renvoie sur mon premier post, faire une lecture par bloc, dans un byte[], et faire un repérage en convertissant en String, et chercher le String "\u0026" au sein de ton flux... Ca devrait fonctionner...

**ghorgor** · 28/09/2005, 10h09

Excuse moi, une tite erreur, c'est pas \u0026, mais \u001A...

**seiryujay** · 28/09/2005, 10h23

Ca te parait mieux?

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
 
	private int getFINIndex2() {
		try {
			ra = new RandomAccessFile(pathname,"r");			
			ds = new DataInputStream(new BufferedInputStream(new FileInputStream(pathname)));
 
			byte[] buff = new byte[1000];
			String strBuff;
			int toReturn = 0;
			int index = -1;
			boolean eof = false;
 
			try{
				ra.seek(0);		
				int nbLines = 0;
				while(!eof){
					ra.read(buff);
					strBuff = new String(buff);
					if (strBuff.indexOf("\u001A") != -1){ // 26 = caractère de fin de la partie en-tête...
						//cest la bonne ligne
						toReturn += strBuff.indexOf("\u001A");
						System.out.println("toReturn = "+toReturn);
						return toReturn;
					}
					else {
						toReturn += strBuff.length();
					}
				}
 
				return -1;	
			}
			catch (EOFException e) {
				eof = true;
			}
			catch(Exception e){
				e.printStackTrace();
			}
 
		}
		catch(NumberFormatException nbe){
			nbe.printStackTrace();
			System.out.println("NOT A NUMBER");
		}
		catch(NullPointerException ne){
			ne.printStackTrace();			
			System.out.println("ERROR IN ATTRIBUTE NAME : NOT FOUND IN FILE");	
		}
		catch(Exception e){
			e.printStackTrace();
		}
 
		return -1;
	}

EDIT : j'ai enlevé le +1...

**ghorgor** · 28/09/2005, 10h30

Ouep, je prefere nettement... A priori, tu n'auras pas de soucis sur des gros fichiers...

Juste un truc, il se passe quoi dans ton programme si tu arrives a la fin du fichier sans trouver ton EOF ?

(Si il y a un bug a la génération du fichier, ca peut arriver...)

Tu as une erreur levée quand tu essayes de jongler avec un String issu de ton buff qui doit etre vide...

Je gererai ca avant a ta place en regardant le nombre de byte lus, et si c'est <1000, c'est que tu as atteint la find e ton fichier... Voir sur la methode read, elle doit renvoyer le nombre d'octets lus...

Enfin, arrivé là, c'est chipoter...

**seiryujay** · 28/09/2005, 10h41

Normalement, ça ne devrait pas se produire, mais en théorie il est possible que mon EOF se situe dans le dernier paquet de bytes lus...
Donc je suis obligé de traiter le dernier paquet, même s'il ne fait pas 1000 bytes.
D'où la EOFException, non?
Ou alors j'ai pas compris ce que tu voulais dire...

**ghorgor** · 28/09/2005, 10h49

Si, c'est ca...

Ce que je ferai simplement, c'est récupéré le nombre de byte lus, pour mettre EOF a true, si ce nombre est inférieur à 1000.

Mais ca n'empeche pas la derniere boucle de se terminer, et de vérifier si il y a EOF dans le dernier paquet... Si il y est, ok, on renvoie l'indice, sinon, on renvoit -1...

Ca evite une levée d'exception, c'est tout...

Je trouve ca plus joli de gérer le fait qu'on ait pas trouvé la fin en renvoyant -1 directement, sur un test, plutôt que de lever une exception pour... renvoyer -1 ensuite...

Mais sinon, ca marche tres bien, y' a pas de probleme...

**seiryujay** · 28/09/2005, 10h58

Ok! J'avais pas compris...
Effectivement, c'est plus propre, et je vais le faire de suite.
Merci msieur!

Lecture de fichier hexa

Entrée/Sortie Java

Vue hybride

Discussions similaires

Partager

Partager