octet [] pour fichier en Java

Question

Avec Java:

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

Comment puis-je écrire à un fichier (ie. C:\myfile.pdf)

Je sais que ça fait avec InputStream, mais je ne peux pas sembler travailler dehors.

Answer 1

Utilisez Apache Commons IO

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

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

Answer 2

Essayez un OutputStream ou plus précisément FileOutputStream

Answer 3

Je sais que ça fait avec InputStream

En fait, vous seriez writing à un file output ...

Answer 4

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

Answer 5

Sans bibliothèques:

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

Avec Google Guava:

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

Avec Apache Commons:

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

Toutes ces stratégies exigent que vous attrapez un IOException à un moment donné aussi.

Answer 6

De Java 7 en avant vous pouvez utiliser le essayer avec-ressources déclaration pour éviter les fuites de ressources et de rendre votre code plus facile à lire. Plus sur cela here.

Pour écrire votre byteArray à un fichier que vous feriez:

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

Answer 7

Une autre solution à l'aide java.nio.file:

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

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

/////// /////////////////// 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] Octet [] vers 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); 
          } 

Answer 12

Vous pouvez 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