byte [] para archivar en Java

Con Java:

Tengo un byte[]que representa un archivo.

¿Cómo escribo esto en un archivo (es decir C:\myfile.pdf)?

Sé que se hizo con InputStream, pero parece que no puedo resolverlo.

Utilice Apache Commons IO

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

O, si insiste en hacer el trabajo por usted mismo ...

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
}

Sin ninguna biblioteca:

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

Con Google Guava :

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

Con Apache Commons :

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

Todas estas estrategias requieren que capture una IOException en algún momento también.

Otra solución usando java.nio.file:

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

También desde Java 7, una línea con java.nio.file.Files:

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

Donde data es su byte [] y filePath es una cadena. También puede agregar múltiples opciones de apertura de archivos con la clase StandardOpenOptions. Agregue tiros o rodee con try / catch.

A partir de Java 7 en adelante, puede usar la declaración de prueba con recursos para evitar fugas de recursos y hacer que su código sea más fácil de leer. Más sobre eso aquí .

Para escribir su byteArrayen un archivo que haría:

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

Prueba uno OutputStreamo más específicamenteFileOutputStream

Sé que se hace con InputStream

En realidad, estaría escribiendo en un archivo de salida ...

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] Archivo al 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 [] al archivo //////////////////// ///////

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

Ejemplo básico:

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

Este es un programa en el que estamos leyendo e imprimiendo una matriz de bytes de desplazamiento y longitud usando String Builder y escribiendo la matriz de bytes de longitud de desplazamiento en el nuevo archivo.

` Ingrese el código aquí

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 en consola: fghij

O / P en archivo nuevo: cdefg

Puedes probar Cactoos :

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

Más detalles: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html