octet [] à déposer en Java


327

Avec Java:

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

Comment écrire ceci dans un fichier (ie. C:\myfile.pdf)

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

Réponses:


502

Utiliser Apache Commons IO

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

Ou, si vous insistez pour travailler 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
}

28
@R. Bemrose Eh bien, il parvient probablement à nettoyer les ressources dans le triste cas.
Tom Hawtin - tackline

1
Depuis la doc: REMARQUE: à partir de la v1.3, les répertoires parents du fichier seront créés s'ils n'existent pas.
bmargulies

24
Si l'écriture échoue, vous perdrez le flux de sortie. Vous devez toujours utiliser try {} finally {}pour garantir un nettoyage correct des ressources.
Steven Schlansker

3
l'instruction fos.close () est redondante car vous utilisez try-with-resources qui ferme automatiquement le flux, même si l'écriture échoue.
Tihomir Meščić

4
Pourquoi devrais-je utiliser Apache Commons IO alors qu'il s'agit de 2 lignes avec Java standard
GabrielBB

185

Sans aucune bibliothèque:

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 nécessitent que vous interceptiez également une exception IOException à un moment donné.


118

Une autre solution utilisant java.nio.file:

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

1
uniquement pour Andorid O (8.0) +
kangear

2
Je ne pense pas que C:\myfile.pdfcela fonctionnerait de toute façon sur Android ...;)
TBieniek

37

Depuis Java 7 également, 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. Ajoutez des lancers ou entourez avec try / catch.


6
Vous pouvez utiliser à la Paths.get(filePath);place denew File(filePath).toPath()
Tim Büthe

@Halil, je ne pense pas que ce soit vrai. Selon les javadocs, il existe un troisième argument facultatif pour les options ouvertes et "Si aucune option n'est présente, cette méthode fonctionne comme si les options CREATE, TRUNCATE_EXISTING et WRITE étaient présentes. En d'autres termes, elle ouvre le fichier pour l'écriture, créant la fichier s'il n'existe pas, ou tronquer initialement un fichier régulier existant à une taille de 0. "
Kevin Sadler

19

À partir de Java 7 , vous pouvez utiliser l' instruction try-with-resources pour éviter les fuites de ressources et faciliter la lecture de votre code. Plus à ce sujet ici .

Pour écrire votre byteArrayfichier dans un fichier, vous devez:

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

J'ai essayé de l'utiliser et cela a causé des problèmes avec des octets qui n'étaient pas des caractères UTF-8, donc je serais prudent avec celui-ci si vous essayez d'écrire des octets individuels pour construire un fichier, par exemple.
pdrum



1
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);
}

1

//////////////////////////// 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] Octet [] vers le fichier //////////////////// ///////

 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);
                            }

Merci pour la réponse .. mais j'ai de la confusion concernant "fileName" je veux dire quel est le type de fichier dans lequel vous enregistrez les données? pouvez-vous s'il vous plaît expliquer?
SRam

1
Salut SRam, cela dépend uniquement de votre application, pourquoi vous effectuez la conversion et dans quel format vous voulez la sortie, je suggère d'opter pour un format .txt (par exemple: - myconvertedfilename.txt) mais encore une fois, c'est votre choix.
Piyush Rumao

0

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) {}

0

Il s'agit d'un programme dans lequel nous lisons et imprimons un tableau de décalage et de longueur d'octets à l'aide de String Builder et écrivons le tableau de longueur de décalage d'octets 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 un nouveau fichier: cdefg


En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.