web-dev-qa-db-fra.com

octet [] dans le fichier Java

Avec Java:

J'ai un byte[] qui représente un fichier.

Comment puis-je écrire cela dans un fichier (c.-à-d. C:\myfile.pdf)

Je sais que c'est fait avec InputStream, mais je n'arrive pas à résoudre le problème.

javaarraysfileioinputstream
285
elcool

Utilisez Apache Commons IO

FileUtils.writeByteArrayToFile(new File("pathname"), myByteArray)

Ou, si vous insistez pour faire du travail pour vous-même ...

try (FileOutputStream fos = new FileOutputStream("pathname")) {
   fos.write(myByteArray);
   //fos.close(); There is no more need for this line since you had created the instance of "fos" inside the try. And this will automatically close the OutputStream
}
440
bmargulies

Sans bibliothèques:

try (FileOutputStream stream = new FileOutputStream(path)) {
    stream.write(bytes);
}

Avec Google Guava :

Files.write(bytes, new File(path));

Avec Apache Commons :

FileUtils.writeByteArrayToFile(new File(path), bytes);

Toutes ces stratégies requièrent que vous releviez également une exception IOException.

167
SharkAlley

Une autre solution utilisant Java.nio.file:

byte[] bytes = ...;
Path path = Paths.get("C:\\myfile.pdf");
Files.write(path, bytes);
102
TBieniek

Également depuis Java 7, une ligne avec Java.nio.file.Files:

Files.write(new File(filePath).toPath(), data);

Où data est votre octet [] et filePath est une chaîne. Vous pouvez également ajouter plusieurs options d'ouverture de fichier avec la classe StandardOpenOptions. Ajouter jette ou entourer avec try/catch.

33
EngineerWithJava54321

À partir de Java 7 , vous pouvez utiliser l’instruction try-with-resources pour éviter les fuites de ressources et votre code plus facile à lire. Plus à ce sujet ici .

Pour écrire votre byteArray dans un fichier, vous feriez:

try (FileOutputStream fos = new FileOutputStream("fullPathToFile")) {
    fos.write(byteArray);
} catch (IOException ioe) {
    ioe.printStackTrace();
}
18
Voicu

Essayez une OutputStream ou plus spécifiquement FileOutputStream

4
Gareth Davis

//////////////////////////// 1] Fichier en octet [] /////////////////// //

Path path = Paths.get(p);
                    byte[] data = null;                         
                    try {
                        data = Files.readAllBytes(path);
                    } catch (IOException ex) {
                        Logger.getLogger(Agent1.class.getName()).log(Level.SEVERE, null, ex);
                    }

//////////////////////// 2] Byte [] to File //////////////////////// ///////

 File f = new File(fileName);
 byte[] fileContent = msg.getByteSequenceContent();
Path path = Paths.get(f.getAbsolutePath());
                            try {
                                Files.write(path, fileContent);
                            } catch (IOException ex) {
                                Logger.getLogger(Agent2.class.getName()).log(Level.SEVERE, null, ex);
                            }
2
Piyush Rumao

Je sais que c'est fait avec InputStream

En fait, vous seriez en écriture dans un sortie du fichier ...

2
Powerlord
File f = new File(fileName);    
byte[] fileContent = msg.getByteSequenceContent();    

Path path = Paths.get(f.getAbsolutePath());
try {
    Files.write(path, fileContent);
} catch (IOException ex) {
    Logger.getLogger(Agent2.class.getName()).log(Level.SEVERE, null, ex);
}
2
Piyush Rumao

Vous pouvez essayer Cactoos :

new LengthOf(new TeeInput(array, new File("a.txt"))).value();

Plus de détails: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

1
yegor256

Exemple de base:

String fileName = "file.test";

BufferedOutputStream bs = null;

try {

    FileOutputStream fs = new FileOutputStream(new File(fileName));
    bs = new BufferedOutputStream(fs);
    bs.write(byte_array);
    bs.close();
    bs = null;

} catch (Exception e) {
    e.printStackTrace()
}

if (bs != null) try { bs.close(); } catch (Exception e) {}
1
barti_ddu

Ceci est un programme où nous lisons et imprimons un tableau d'octets offset et de longueur en utilisant le constructeur de chaînes et l'écriture du tableau d'octets offset de longueur dans le nouveau fichier.

`Entrez le code ici

import Java.io.File;   
import Java.io.FileInputStream;
import Java.io.FileOutputStream;
import Java.io.IOException;        

//*This is a program where we are reading and printing array of bytes offset and length using StringBuilder and Writing the array of bytes offset length to the new file*//     

public class ReadandWriteAByte {
    public void readandWriteBytesToFile(){
        File file = new File("count.char"); //(abcdefghijk)
        File bfile = new File("bytefile.txt");//(New File)
        byte[] b;
        FileInputStream fis = null;              
        FileOutputStream fos = null;          

        try{               
            fis = new FileInputStream (file);           
            fos = new FileOutputStream (bfile);             
            b = new byte [1024];              
            int i;              
            StringBuilder sb = new StringBuilder();

            while ((i = fis.read(b))!=-1){                  
                sb.append(new String(b,5,5));               
                fos.write(b, 2, 5);               
            }               

            System.out.println(sb.toString());               
        }catch (IOException e) {                    
            e.printStackTrace();                
        }finally {               
            try {              
                if(fis != null);           
                    fis.close();    //This helps to close the stream          
            }catch (IOException e){           
                e.printStackTrace();              
            }            
        }               
    }               

    public static void main (String args[]){              
        ReadandWriteAByte rb = new ReadandWriteAByte();              
        rb.readandWriteBytesToFile();              
    }                 
}

O/P dans la console: fghij

O/P dans le nouveau fichier: cdefg

0
Yogi