बाइट [] जावा में फाइल करने के लिए

327

जावा के साथ:

मेरे पास एक byte[] एक फ़ाइल का प्रतिनिधित्व करता है।

मैं इसे फ़ाइल में कैसे लिखूँ (अर्थात C:\myfile.pdf )

मुझे पता है कि यह InputStream के साथ किया गया है, लेकिन मैं इसे काम नहीं कर सकता।

— elcool
स्रोत

502

Apache Commons IO का उपयोग करें

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

या, यदि आप खुद के लिए काम करने पर जोर देते हैं ...

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
}

— bmargulies
स्रोत

28

@R। बेमरोज खैर, यह शायद दुख की स्थिति में संसाधनों को साफ करने का प्रबंधन करता है।

— टॉम हॉल्टिन -

1

दस्तावेज़ से: नोट: v1.3 से, फ़ाइल की मूल निर्देशिका बनाई जाएगी यदि वे मौजूद नहीं हैं।

— बामरगुलिस

24

यदि लेखन विफल रहता है, तो आप आउटपुट स्ट्रीम को लीक कर देंगे। आपको हमेशा try {} finally {}उचित संसाधन सफाई सुनिश्चित करने के लिए उपयोग करना चाहिए ।

— स्टीवन श्लैंस्कर

3

fos.close () कथन निरर्थक है क्योंकि आप कोशिश के साथ संसाधनों का उपयोग कर रहे हैं जो स्वचालित रूप से स्ट्रीम बंद कर देता है, भले ही लेखन विफल हो।

— तिहोमिर मेचिज़ 16

4

मैं नियमित रूप से जावा के साथ 2 लाइनों के साथ अपाचे कॉमन्स आईओ का उपयोग क्यों करूंगा

— गैब्रियलबीबी

185

बिना किसी पुस्तकालय के:

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

Google अमरूद के साथ :

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

अपाचे कॉमन्स के साथ :

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

इन सभी रणनीतियों के लिए आवश्यक है कि आप किसी बिंदु पर एक IOException भी पकड़ें।

— SharkAlley
स्रोत

118

एक और समाधान का उपयोग कर java.nio.file:

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

— TBieniek
स्रोत

1

केवल

— ओरीड

2

मुझे नहीं लगता कि C:\myfile.pdfवैसे भी एंड्रॉइड पर काम करेगा ...;)

— TBieniek

37

जावा 7 के बाद से, java.nio.file.Files के साथ एक पंक्ति:

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

जहां डेटा आपकी बाइट [] है और फ़ाइलपैथ एक स्ट्रिंग है। आप StandardOpenOptions क्लास के साथ कई फ़ाइल ओपन विकल्प भी जोड़ सकते हैं। थ्रो जोड़ें या कोशिश / पकड़ के साथ चारों ओर।

— EngineerWithJava54321
स्रोत

6

आप Paths.get(filePath);इसके बजायnew File(filePath).toPath()

— टिम ब्यूटे

@ हलील मुझे नहीं लगता कि यह सही है। Javadocs के अनुसार खुले विकल्पों के लिए एक वैकल्पिक 3 तर्क है और "यदि कोई विकल्प मौजूद नहीं है, तो यह विधि काम करती है जैसे कि CREATE, TRUNCATE_EXISTING, और WRITE विकल्प मौजूद हैं। दूसरे शब्दों में, यह फ़ाइल को लिखने, बनाने के लिए खोलता है। यदि यह मौजूद नहीं है तो फ़ाइल शुरू करें, या शुरू में 0. के आकार में एक मौजूदा नियमित-फ़ाइल को काट-छाँट करें।

— केविन सैडलर

19

से जावा 7 आगे आप उपयोग कर सकते हैं कोशिश के साथ-संसाधन संसाधन लीक से बचने और अपने कोड को पढ़ने में आसान बनाने के लिए बयान। उस पर और अधिक यहाँ ।

अपनी byteArrayफ़ाइल को लिखने के लिए आप क्या करेंगे:

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

— Voicu
स्रोत

मैंने इसका उपयोग करने की कोशिश की और यह बाइट्स के साथ समस्याओं का कारण बना जो कि यूटीएफ -8 वर्ण नहीं थे, इसलिए मैं इस एक के साथ सावधान रहूंगा यदि आप एक फ़ाइल बनाने के लिए व्यक्तिगत बाइट्स लिखने की कोशिश कर रहे हैं, उदाहरण के लिए।

— पीडीआर

4

एक OutputStreamया अधिक विशेष रूप से प्रयास करेंFileOutputStream

— गैरेथ डेविस
स्रोत

1

मुझे पता है कि यह InputStream के साथ किया गया है

दरअसल, आप एक फ़ाइल आउटपुट के लिए लिख रहे हैं ...

— Powerlord
स्रोत

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] बाइट के लिए फाइल [] ///////////////////// //

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] बाइट [] फाइल करने के लिए /////////////////////// ///////

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

— पीयूष रूमाओ
स्रोत

उत्तर के लिए धन्यवाद..लेकिन मुझे "fileName" के बारे में भ्रम है, मेरा मतलब है कि जिस प्रकार की फाइल आप डेटा सहेज रहे हैं, वह किस प्रकार की है? क्या आप समझा सकते हैं?

— SRAM

1

हाय SRam, यह पूरी तरह से आपके आवेदन पर निर्भर करता है कि आप रूपांतरण क्यों कर रहे हैं और आप किस प्रारूप में आउटपुट चाहते हैं, मैं सुझाव देना चाहूंगा कि आप .txt प्रारूप में जाएं (जैसे: - myconvertedfilename.txt) लेकिन फिर से अपनी पसंद।

— पीयूष रूमाओ

0

मूल उदाहरण:

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

— barti_ddu
स्रोत

0

यह एक ऐसा प्रोग्राम है, जिसमें हम स्ट्रिंग बिल्डर की मदद से बाइट्स ऑफ़सेट और लेंथ की रीडिंग और प्रिंटिंग अरेंज कर रहे हैं और बाइट्स की एरे को नई फ़ाइल में ऑफ़सेट लंबाई लिखते हैं।

` यहाँ कोड दर्ज करें

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 कंसोल में: fghij

नई फ़ाइल में O / P: cdefg

— योगी
स्रोत

0

आप कैक्टस की कोशिश कर सकते हैं :

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

अधिक जानकारी: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-actact.html

— yegor256
स्रोत