Transfomer un File en byte[]

**nebule** · 14/06/2007, 16h50

Bonjour,

J'ai cherché, testé, recherché, retesté mais sans succès.

J'ai un besoin simple : j'ai un fichier dont je connais le chemin et je souhaite le transformer en tableau de byte[].

J'ai essayé avec plusieurs inputstream / outputstream &co mais je comprends pas grand chose !

Quelqu'un pourrait-il m'éclaire

Merci

**TigrouMeow** · 14/06/2007, 16h56

Cadeau :

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
 
        static public byte[] StreamtoByteArray(Stream stream)
        {
            int offset = 0;
            int remaining = (int)stream.Length;
            byte[] data = new byte[remaining];
            while (remaining > 0)
            {
                int read = stream.Read(data, offset, remaining);
                if (read <= 0)
                    throw new EndOfStreamException();
                remaining -= read;
                offset += read;
            }
            return data;
        }
 
        static public byte[] FileToByteArray(string path)
        {
            FileStream fs = new FileStream(path, FileMode.Open);
            byte[] binary = StreamtoByteArray(fs);
            fs.Close();
            return binary;
        }

Plus qu'à appeler FileToByteArray ! Par contre il me semble que y'a une technique un peu plus directe avec .NET 2, mais perso j'utilise ce qui est au dessus depuis un bon moment, et ça marche bien.

**nebule** · 14/06/2007, 16h58

Envoyé par TigrouMeow

Cadeau :

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
 
        static public byte[] StreamtoByteArray(Stream stream)
        {
            int offset = 0;
            int remaining = (int)stream.Length;
            byte[] data = new byte[remaining];
            while (remaining > 0)
            {
                int read = stream.Read(data, offset, remaining);
                if (read <= 0)
                    throw new EndOfStreamException();
                remaining -= read;
                offset += read;
            }
            return data;
        }
 
        static public byte[] FileToByteArray(string path)
        {
            FileStream fs = new FileStream(path, FileMode.Open);
            byte[] binary = StreamtoByteArray(fs);
            fs.Close();
            return binary;
        }

Plus qu'à appeler FileToByteArray ! Par contre il me semble que y'a une technique un peu plus directe avec .NET 2, mais perso j'utilise ce qui est au dessus depuis un bon moment, et ça marche bien.

Merci, par contre si je ne m'abuse, s'est pas du java

**TigrouMeow** · 14/06/2007, 17h00

Pfiouuuuuuuuuuuu

Ahah, bon j'espère que la logique est la même, que mon post serve à quelque chose

**nebule** · 14/06/2007, 17h06

Envoyé par TigrouMeow

Pfiouuuuuuuuuuuu

Ahah, bon j'espère que la logique est la même, que mon post serve à qqchose

La logique oui mais les classe à utiliser non et s'est la que je bloque

**nebule** · 14/06/2007, 17h14

Element de réponse trouvé sur un vieux vieux post (merci

)

http://www.developpez.net/forums/showthread.php?t=38795

**Janitrix** · 14/06/2007, 17h21

Il faut avoir l'esprit clair pour comprendre comment fonctionne tous ces Streams

.

Voici ce que je ferais (je sors ça de tête, c'est non testé, c'est juste pour te montrer la voie) :

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
 
/* On créer une nouvelle méthode qui retourne un tableau de byte
et avec un trhows IOException afin de pouvoir gérer les erreurs à notre guise */
public byte[] getArrayByteFromFile(File f) throws IOException {
/* On récupère la taille du fichier en octet,
donc le nombre de byte qu'on devra lire */
int length = f.length();
/* On crée un tableau de byte avec une longueur
égal à la taille du fichier (logique non :mrgreen: ?)*/
byte[] data = new byte[length];
/* Partie intéressante : on crée un BufferedInputStream,
qui va nous permettre de lire plusieurs byte d'un coup */
BufferedInputStream in = new BufferedInputStream(new FileInputStream(f));
/* On lit la totalité du ficher. Le premier paramètre est le tableau de byte qui va recevoir les données,
le deuxième est la position dans le fichier où on commence à lire les données (donc zéro puisqu'on commence au début du fichier),
enfin le dernier paramètre est le nombre d'octet que l'on veut lire,
ici on donne length puisqu'on veut lire la totalité du fichier d'un coup. */
int result = in.read(data, 0, length);
 
return data;
}

Pour voir en détail la classe BufferedInputStream...

La variable result contient -1 si la fin du fichier a été atteinte, autrement dit, si la lecture a réussie, cette variable doit contenir -1. Enfin, je crois.

Bonne chance

[edit] Arf, j'ai mis 7 minutes à rédiger mon post, j'ai pas vu que tu avais la réponse

**nebule** · 14/06/2007, 17h25

Envoyé par Janitrix

[edit] Arf, j'ai mis 7 minutes à rédiger mon post, j'ai pas vu que tu avais la réponse

Pas grave, au contraire, ton explication est super (avec les commentaires )!!!

j'avais pas pigé le coup du in.read ... j'avais du mal à comprendre comment une void pouvait me remplir mon tableau de byte

Super merci beaucoup

Marie

**Janitrix** · 14/06/2007, 17h29

Bon ok, tant mieux

.

Vu ton ancienneté ici, je ne doute pas que tu connaisses l'utilisation du tag

?

Merci et bonne chance pour la suite

**nebule** · 14/06/2007, 17h31

Envoyé par Janitrix

Bon ok, tant mieux

.

Vu ton ancienneté ici, je ne doute pas que tu connaisses l'utilisation du tag

?

Merci et bonne chance pour la suite

yes nos messages se croisent

**Beaveroli** · 16/10/2009, 10h15

Bonjour,

J'ai moi aussi besoin d'une méthode telle que getArrayByteFromFile.

Cependant dans le code que j'ai pu voir sur ce sujet, on voit :

Code :

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

1
2
3
4
5
6
7
8
9
 
public byte[] getArrayByteFromFile(File f) throws IOException {
 
int length = f.length();
byte[] data = new byte[length];
BufferedInputStream in = new BufferedInputStream(new FileInputStream(f));
int result = in.read(data, 0, length);
 
return data;

Chez moi ca ne compile pas, f.length() renvoyant un type long, et le constructeur du tableau de bytes ne prenant qu'un int pour la taille du tableau.

J'ai donc pour l'instant fait un cast de long vers int, mais pour les fichiers imposants j'ai comme un doute sur la fiabilité de cette solution.

Code :

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

1
2
 
int length = (int)f.length();

Un avis la dessus ?

**adiGuba** · 16/10/2009, 11h29

Salut,

Il faudrait gérer proprement le cas où les fichiers sont trop gros... sinon tu risques d'obtenir une NegativeArraySizeException pas très clair....
Il n'y a pas vraiment besoin du BufferedInputStream puisque tu effectues déjà une lecture par bloc...
Il manque la fermeture du flux !!! C'est une source de problème non néglieable !
Tu ne lis pas forcément ton fichier en entier. En effet le read() lira au plus 'n' bytes.
En fait s'il y a une interruption I/O plutôt que de bloquer et d'attendre la suite, il est possible que le read() rende la main sans avoir lu la totalité des données...
Ce n'est pas forcément reproductible mais il faut en prendre compte...

Bref, cela devrait ressembler à quelque chose comme cela :

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
	public static byte[] getArrayByteFromFile(File f) throws IOException {
 
		final long length = f.length();
		if (length > Integer.MAX_VALUE) { // + de 2 Go
			throw new IOException("File too big");
		}
 
		byte[] data = new byte[(int) length];
 
		final FileInputStream in = new FileInputStream(f);
		try {
 
			int off = 0;	// Position de lecture
			int len = data.length;	// Nombre de bytes restant à lire
			int read;		// Nb de byte lu
 
			do {
				read = in.read(data, off, len);
				if (read > 0) {
					off += read;
					len -= read;
				}
			} while (read >= 0 && len > 0);
 
		} finally {
			in.close();
		}
 
		return data;
	}

Reste encore un problème au cas où le fichier évolue entre le moment où on récupère sa taille et où on le lit.

Si des données sont ajouté on les perdra.
Si le fichier est plus petit, on retournera un tableau trop grand avec des données à zéro.

Une autre solution serait d'utiliser des ByteArraysOutputStream... ce qui permet d'éviter les soucis de taille avec une lecture par pacquet :

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
	public static byte[] getArrayByte(InputStream input, int estimatedSize)
			throws IOException {
		final ByteArrayOutputStream output = new ByteArrayOutputStream(estimatedSize);
		try {
			final byte[] buf = new byte[8192];
			int len;
 
			while ((len = input.read(buf)) >= 0) {
				output.write(buf, 0, len);
			}
		} finally {
			output.close();
		}
		return output.toByteArray();
	}
 
	public static byte[] getArrayByte(InputStream input) throws IOException {
		return getArrayByte(input, 16);
	}
 
	public static byte[] getArrayByteFromFile(File f) throws IOException {
		final long length = f.length();
		if (length > Integer.MAX_VALUE) { // + de 2 Go
			throw new IOException("File too big");
		}
 
		FileInputStream input = new FileInputStream(f);
		try {
			return getArrayByte(input, (int) length);
		} finally {
			input.close();
		}
	}
 
	public static byte[] getArrayByteFromURL(URL url) throws IOException {
		InputStream input = url.openStream();
		try {
			return getArrayByte(input);
		} finally {
			input.close();
		}
	}