Transfomer un File en byte[]

Version imprimable

14/06/2007, 16h50
nebule

Transfomer un File en byte[]

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 :roll:

Merci

Cadeau :

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
 
        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.

Citation:

Envoyé par TigrouMeow

Cadeau :

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
 
        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 :roll:

14/06/2007, 17h00
TigrouMeow

Pfiouuuuuuuuuuuu 8O Ahah, bon j'espère que la logique est la même, que mon post serve à quelque chose ;)
14/06/2007, 17h06
nebule

Citation:

Envoyé par TigrouMeow

Pfiouuuuuuuuuuuu 8O 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 :? ;)
14/06/2007, 17h14
nebule

Element de réponse trouvé sur un vieux vieux post (merci :google: :lol: )

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

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

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

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 :?

14/06/2007, 17h25
nebule

Citation:

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 :D

Marie
14/06/2007, 17h29
Janitrix

Bon ok, tant mieux :mrgreen: .

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

Merci et bonne chance pour la suite ;)
14/06/2007, 17h31
nebule

Citation:

Envoyé par Janitrix

Bon ok, tant mieux :mrgreen: .

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

Merci et bonne chance pour la suite ;)

yes nos messages se croisent ;)

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:

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:

1 2 int length = (int)f.length();
Un avis la dessus ?

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:

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:

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(); } }
Enfin si l'on doit manipuler de très gros fichier, on pourrait passer par les MappedByteBuffer...

a++

16/10/2009, 14h37
Beaveroli

Merci pour ces solutions ! :)
29/05/2012, 10h29
BartRoX

Citation:

Envoyé par TigrouMeow

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

Moi je développe en C#, et 5 ans plus tard, ton post m'aura été utile, merci ! ;)

(Et merci Google :mouarf: )