Lecture fichier binaire

Version imprimable

Bonjour,
Je dois lire un fichier binaire.
et le fichier biaire commence par une ligne.
il me faut les donnees qu'il y a apres. Commen,t je fais pour sauter cette ligne ? ( elle se termine par le caractere binaire 0A)
Sachant que mon prog doit lire le fichier binaire qui est en little indian en faisant :
- Sauter le premiere ligne
- lire les 35 octets ( c un nom)
- sauter les 166 octets inutiles
- lire les 2 octets ( c un numero (Id))
- lire les 35 octets ( c un nom)
- sauter les 166 octets inutiles
- lire les 2 octets ( c un numero (Id))
.
.
.
jusqua le fin

Pour le moment g fait ca mais il me manque a sauter la premiere ligne

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
DataInputStream dis = new DataInputStream
            ( new FileInputStream(cheminZoneEssai+"m.ch1"));
 
            b = new byte[256];
            byte_nom = new byte[36];
            byte_id = new byte[10];
            int nbreDeLigne = 1;
 
 
            //System.out.println("\n str:"+bytes+" :"+str);
            int bytes = 0 ;
            if (bytes != -1) {
                while (true) {
                    bytes = dis.read (b, 0, 39); // nomvoie
                    System.out.println("nomvoie : "+ bytes );
                    if (bytes == -1) {break;}
                    bytes = dis.read (b, 0, 166); // inutile
                    if (bytes == -1) { break; }
                    bytes = readCharLittleEndian(dis); // Id
                    System.out.println("ID : "+ bytes );
                    if (bytes == -1) {break;}
                }
            }

Code:

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
 
boolean is1stLine = false;
// Remplit le tableau de bit
bytes = dis.read(b, 0, 256);
while ( bytes!=-1 ) {
 
   // Traitement de la première ligne
   if ( is1stLine ) {
 
      // Recherche du caractère incriminé
      int pos = 0;
      while ( pos < bytes && is1stLine )
         is1stLine = ( b[ pos++ ] == 0x0A );
 
      // Toujours la même ligne, on continue la lecture
      if ( is1stLine ) {
 
         bytes = dis.read(b, 0, 256);
 
     } else {
         // Le caractère a été trouvé, on décale les bytes
         byte[] temp = new byte[ 256 ];
         bytes -= pos;
         for( int i = 0; i < bytes; i ++ )
            temp[ i ] = b[ i + pos ];
         b = temp;
 
     } // Fin traitement de la première ligne
 
      // Traitement post première ligne
     else {
 
           // ...
 
     }
 
} // Fin de boucle
 
// Traitement d'erreur n°1 : Le fichier ne contient qu'une seule ligne
if ( is1stLine ) {}

Merci !
Tu es le seul a me repondre.

Voila g complete ton code mais ca ne me donne pas les bonnes valeurs ( je suis un debutant alors c possible qu'il y ai des choses bizarres)
Pour les 39 premiers octets ( nom voie c une string) mais ca me donne des chiffres. mais mon bleme c comment lire cette string de 39 si ce n'est comme g fait?

Code:

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
  /**
      * Lit le fichier m.ch1
      */
    public static void lireFichiermch1 (String cheminZoneEssai)
        throws IOException
    {
        buffer = new char[1024];
 
        //System.out.println("\n LectureFichier : "+cheminFichier);
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream(cheminZoneEssai +
                        "m.ch1"));
 
            b = new byte[100000];
 
            int bytes = 0;
            boolean is1stLine = false;
//          Remplit le tableau de bit
         bytes = dis.read(b, 0, 256);
         while ( bytes!=-1 ) {
 
            // Traitement de la première ligne
            if ( is1stLine ) {
 
               // Recherche du caractère incriminé
               int pos = 0;
               while ( pos < bytes && is1stLine )
                  is1stLine = ( b[ pos++ ] == 0x0A );
 
               // Toujours la même ligne, on continue la lecture
               if ( is1stLine ) {
 
                  bytes = dis.read(b, 0, 256);
 
              } else {
                  // Le caractère a été trouvé, on décale les bytes
                  byte[] temp = new byte[ 256 ];
                  bytes -= pos;
                  for( int i = 0; i < bytes; i ++ )
                     temp[ i ] = b[ i + pos ];
                  b = temp;
 
              } // Fin traitement de la première ligne
            }
               // Traitement post première ligne
              else {
 
 
 
 
                  //System.out.println("\n str:"+bytes+" :"+str);
 
                  if (bytes != -1) {
                      while (true) {
                          bytes = dis.read (b, 0, 39); // nomvoie
                          System.out.println("nomvoie : "+ bytes );
                          if (bytes == -1) {break;}
                          bytes = dis.read (b, 0, 166); // inutile
                          if (bytes == -1) { break; }
                          bytes = readCharLittleEndian(dis); // Id
                          System.out.println("ID : "+ bytes );
                          if (bytes == -1) {break;}
                      }
                  } 
 
 
 
         } // Fin de boucle
 
//          Traitement d'erreur n°1 : Le fichier ne contient qu'une seule ligne
         if ( is1stLine ) {}
         }
           //System.out.println (" maxy : " + maxy + "min y : " + miny);
        } catch (MalformedURLException e) {
            e.printStackTrace ();
        } catch (IOException e) {
            e.printStackTrace ();
        }
    }

En général quand je fais une lecture d'un fichier "formaté" je place tout ce que je peux dans un buffer (ici b), je cherche ce qui m'interresse et je stocke les informations si j'ai besoin d'en garder une trace.

Ceci te montrera un peu la philosophie

Code:

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
 
DataInputStream dis = new DataInputStream(new FileInputStream(cheminZoneEssai +
                        "m.ch1"));
 
// Informations de bufferisation du nom
byte[] nom_buffer = new byte[39];
int nom_restant = nom_buffer.length;
int nom_pos = 0;
 
// Informations du parcours du fichier
byte[] buffer = new byte[100000];
int bytes = 0;
int flag = 1;
 
// Remplit le tableau de bit
bytes = dis.read(buffer, 0, buffer.length);
while ( bytes!=-1 ) {
<div style="margin-left:40px">switch ( flag ) {
 
<div style="margin-left:40px">// Première ligne
case 1:
<div style="margin-left:40px">// Recherche du caractère incriminé
int pos = 0;
while ( pos < bytes && flag==1 )
<div style="margin-left:40px">flag = ( buffer[ pos++ ] == 0x0A ) ? 2 : 1;</div>if ( flag == 1 ) {
<div style="margin-left:40px">// Toujours la première ligne, on continue la lecture
bytes = dis.read(buffer, 0, buffer.length);</div>} else {
<div style="margin-left:40px">// Le caractère a été trouvé, on décale les bytes
bytes -= pos;
for( int i = 0; i < bytes; i ++ )
<div style="margin-left:40px">buffer[ i ] = buffer[ i + pos ];
 </div></div>}
// Fin traitement de la première ligne
break;
 </div>// Traitement nom
case 2:
<div style="margin-left:40px">if ( bytes >= nom_restant ) {
<div style="margin-left:40px">// le buffer contient assez de caractères
bytes -= nom_restant;
// bufferisation
for(int i = nom_pos, j = 0; i < nom_pos + nom_restant; j++, i++ )
<div style="margin-left:40px">nom_buffer[ i ] = buffer[ j ];</div>flag = 3;
// nettoyage du buffer
for( int i = 0; i < bytes; i++ )
<div style="margin-left:40px">buffer[i] = buffer[i+pos];</div></div>} else {
<div style="margin-left:40px">// Le buffer ne contient pas assez de caractères
for(int i = nom_pos, j = 0; j < bytes; i++; j++)
<div style="margin-left:40px">nom_buffer[ i ] = buffer[ j ];</div>// On avance dans le fichier
bytes = dis.read( buffer, 0, buffer.length );
 </div>}
// Fin traitement du nom
break;
 
 
// ...
 </div></div>} // Fin du switch( flag )</div>} // Fin du while byte != -1
 
// Traitement de transformation
String nom = new String( nom_buffer );

30/05/2006, 16h53
gabule

Merci