Discussion :

[fomazou]

comment puis-je pour manipuler les bits.
je pouvoir lir un fichier lire les caractères et mettre le bits (correspondants) dans un tableau!

[iohack]

va falloir être plus précis, tu parles de caractères or un caractère peut être codé sur un nombre différent de bit (selon l'encodage). Ensuite tu veux mettre des bits dans un tableau, sous quelle forme ?

[jibbi]

Salut

On peut faire ca avec un ByteArrayInputStream

[Duc Lebowski]

Voili voilou :

Code :

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

1
2
3
4
5
6
7
8
9
 
public byte[] getBytes(String filepath) throws IOException
{
    FileInputStream in = new FileInputStream(new File(filepath));
    byte[] b = new byte[in.available()];
    in.read(b);
    in.close();
    return b;
}

[iohack]

Voili voilou :

Code :

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

1
2
3
4
5
6
7
8
9
 
public byte[] getBytes(String filepath) throws IOException
{
    FileInputStream in = new FileInputStream(new File(filepath));
    byte[] b = new byte[in.available()];
    in.read(b);
    in.close();
    return b;
}

heu, il se passe quoi si le fichier fait 4Go ?

[Duc Lebowski]

heu, il se passe quoi si le fichier fait 4Go ?

Réponse 1 : et il se passe quoi si des extraterrestres lancent une cyber-attaque sur la terre ?

Réponse 2 : t'as plus de place sur ton disque dur !

Réponse 3 : si tu as 10 Go de RAM tout va pour le mieux !

fomazou, quelle taille fait ton fichier ?

[adiGuba]

Salut,

heu, il se passe quoi si le fichier fait 4Go ?

Un OutOfMemoryError... mais c'est tout à fait normal

Mais il y a surtout trois points qui me chiffonne bien plus que cela :

• La fermeture du flux n'est pas dans un bloc finally... en cas d'erreur lors de la lecture le fichier ne sera pas fermé...
• available() ne renvoi pas la taille du fichier, mais une "estimation" du nombre de byte qui peuvent être lu sans provoquer de bloquage d'I/O. Avec de petit fichier cela peut très bien marcher... mais si le fichier est de taille conséquente on risque de tronquer la lecture ! De plus certain type d'InputStream peuvent très bien toujours renvoyer 0 !!!
• De même, rien ne garantie qu'un seul appel à read() permettra de lire la totalité du fichier...

On peut faire ca avec un ByteArrayInputStream

Plutôt un ByteArrayOutputStream...


Cela donnerait ceci, en utilisant une lecture par bloc de 8192 bytes :

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
	public byte[] getBytes(String filepath) throws IOException {
	    ByteArrayOutputStream baos = new ByteArrayOutputStream();
	    FileInputStream in = new FileInputStream(filepath);
	    try {
	    	// On lit par bloc de 8192 bytes :
	    	byte[] buf = new byte[8192];
	    	int len;
 
	    	while ( (len=in.read(buf)) >= 0) {
	    		baos.write(buf, 0, len);
	    	}
	    } finally {
	    	in.close();
	    }
	    return baos.toByteArray();
	}

Le ByteArrayOutputStream se redimensionne automatiquement lorsque c'est nécessaire (tout comme les StringBuffer/StringBuilder). Le gros problème de cette solution c'est que la méthode toByteArray() renvoi une copie du tableau généré, et que pendant un moment on se retrouve avec les données en double en mémoire, ce qui peut être pénalisant pour de gros fichier.

Dans ce cas il faudrait plutôt se baser sur la méthode length() de File et gérer la lecture en boucle :

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
	public byte[] getBytes(String filepath) throws IOException {
		File file = new File(filepath);
		long length = file.length();
 
		if (length<=0) {
			throw new IOException("Taille de fichier incorrecte...");
			/* Note : dans ce cas on pourrait envisager une lecture
			 * via un ByteArrayOutputStream, car length() peut renvoyer 0
			 * avec certains fichiers spéciaux du système d'exploitation
			 */
		}
 
		if (length>Integer.MAX_VALUE) {
			throw new IOException("Fichier trop grand...");
			/* Note : cela permet d'éviter des erreurs à cause
			 * du cast de long en int qui donnerait une valeur négatives
			 */
		}
 
		// Création du buffer :
		int toRead = (int) length;
		byte[] buf = new byte[toRead];
 
	    FileInputStream in = new FileInputStream(filepath);
	    try {
	    	int index = 0;
	    	int read;
 
	    	while (toRead>0) {
	    		read = in.read(buf, index, toRead);
	    		index += read;
	    		toRead -= toRead;
	    	}
	    } finally {
	    	in.close();
	    }
	    return buf;
	}

A noter qu'on pourrait également utiliser un ByteBuffer... voir directement un MappedByteBuffer pour de gros fichier (voir FileChannel.map()).


a++