Byte [] zur Datei in Java

Mit Java:

Ich habe eine byte[], die eine Datei darstellt.

Wie schreibe ich das in eine Datei (dh C:\myfile.pdf)

Ich weiß, dass es mit InputStream gemacht wurde, aber ich kann es scheinbar nicht herausfinden.

Verwenden Sie Apache Commons IO

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

Oder wenn Sie darauf bestehen, Arbeit für sich selbst zu machen ...

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
}

Ohne Bibliotheken:

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

Mit Google Guava :

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

Mit Apache Commons :

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

Alle diese Strategien erfordern, dass Sie auch irgendwann eine IOException abfangen.

Eine andere Lösung mit java.nio.file:

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

Auch seit Java 7 eine Zeile mit java.nio.file.Files:

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

Wobei Daten Ihr Byte [] und filePath ein String ist. Sie können mit der StandardOpenOptions-Klasse auch mehrere Optionen zum Öffnen von Dateien hinzufügen. Fügen Sie Würfe oder Surround mit try / catch hinzu.

Ab Java 7 können Sie die Anweisung try-with-resources verwenden , um Ressourcenlecks zu vermeiden und das Lesen Ihres Codes zu vereinfachen. Mehr dazu hier .

Um Ihre byteArrayin eine Datei zu schreiben , würden Sie tun:

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

Versuchen Sie es mit einem OutputStreamoder genauerFileOutputStream

Ich weiß, dass es mit InputStream gemacht wird

Eigentlich würden Sie in eine Dateiausgabe schreiben ...

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] File to Byte [] /////////////////////// // //

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 [] zur Datei ///////////////////// ///////

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

Grundlegendes Beispiel:

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

Dies ist ein Programm, in dem wir mit dem String Builder ein Array mit einem Versatz und einer Länge von Bytes lesen und drucken und das Array mit einer versetzten Länge von Bytes in die neue Datei schreiben.

` Geben Sie hier den Code ein

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 in der Konsole: fghij

O / P in neuer Datei: cdefg

Sie können Kakteen ausprobieren :

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

Weitere Details: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html