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

Question

मैं a java.io.Fileको कैसे परिवर्तित करूं byte[]?

Comments

एक उपयोग जो मैं सोच सकता हूं वह फाइल से क्रमबद्ध वस्तुओं को पढ़ना है।

— Mahm00d

एक और हैडर का उपयोग करके फ़ाइल प्रकार ढूंढना है।

— जेम्स पी।

इस बाइट का प्रयास करें [] बाइट्स = अशक्त; बफ़रड इनपुटस्ट्रीम फ़ाइलइन्पुटस्ट्रीम = नल; कोशिश {फ़ाइल फ़ाइल = नई फ़ाइल (फ़ाइलपथ); fileInputStream = new BufferedInputStream (नया FileInputStream (फ़ाइल)); // fileInputStream = Thread.currentThread ()। getContextClassLoader ()। getResourceAsStream (this.filePath); बाइट्स = नई बाइट [(int) file.length ()]; fileInputStream.read (बाइट); } catch (FileNotFoundException ex) {थ्रो एक्स; }

— रोहित चौरसिया

Answer 1

यह इस बात पर निर्भर करता है कि आपके लिए सबसे अच्छा साधन क्या है। उत्पादकता के लिहाज से, पहिया को सुदृढ़ नहीं करते हैं और अपाचे कॉमन्स का उपयोग करते हैं। जो यहाँ है IOUtils.toByteArray(InputStream input)।

Comments

@ यमजोरोस: तो सच है! मैं कोड की कुछ अतिरिक्त लाइनें अभी तक एक और निर्भरता से चाहते हैं। निर्भरता की छिपी हुई लागत होती है। आपको उस लाइब्रेरी के साथ अद्यतित रहने की आवश्यकता है, जिसमें आपकी बिल्ड स्क्रिप्टिंग आदि पर निर्भरता शामिल है, इसे अपने कोड आदि का उपयोग करने वाले लोगों से संवाद करें आदि। यदि आप पहले से ही एक पुस्तकालय का उपयोग कर रहे हैं जिसके लिए उपयोग की तुलना में कोड है, तो अन्य मैं कहूंगा इसे खुद लिखो।

— स्टिजन डे विट

यह एक फ़ाइल को पढ़ने के तरीके के सवाल का जवाब देता है, लेकिन यह सवाल नहीं है कि कैसे java.IO.File के ऑब्जेक्ट को बाइट में परिवर्तित किया जाए []।

— इंगो

यह कैसे एक पढ़ने के लिए प्रयोग किया जाता Fileहै byte[]? मैं Java6 का उपयोग कर रहा हूं, इसलिए मैं NIO विधियों का उपयोग नहीं कर सकता :(

— PASTRY

@ymajoros कृपया आप हमारे साथ कोई "मानक 3-लाइन समाधान" साझा करेंगे, इसलिए हमें एक सुदृढ़ीकरण-पर-व्हील-निर्भरता पर भरोसा करने की ज़रूरत नहीं है?

— मत्तियो

@matteo: कोई भी? अन्य उत्तर देखें, जैसे Files.readAllBytes ()। सरल, कोई निर्भरता नहीं।

— यमजोरों

Answer 2

से JDK 7 आप उपयोग कर सकते हैं Files.readAllBytes(Path)।

उदाहरण:

import java.io.File;
import java.nio.file.Files;

File file;
// ...(file is initialised)...
byte[] fileContent = Files.readAllBytes(file.toPath());

Comments

मेरे पास एक फ़ाइल ऑब्जेक्ट है, पथ नहीं (http पोस्ट अनुरोध से)

— aldo.roman.nurena

@ aldo.roman.nurena JDK7 ने एक File.toPath () विधि पेश की, जो आपको एक पथ वस्तु प्रदान करेगी।

— केवीएल

आप एक फ़ाइल से एक पथ प्राप्त कर सकते हैं। कोशिश करें: फ़ाइल फ़ाइल = नई फ़ाइल ("/ पथ"); पाथ पाथ = Paths.get (file.getAbsolutePath ()); बाइट [] डेटा = Files.readAllBytes (पथ);

— gfelisberto

Java.nio में संभाले फ़ाइल को बंद कैसे किया जाता है - दूसरे शब्दों में, उपरोक्त कोड को कुछ बंद करना चाहिए?

— एक्यूप्‍पी

@akauppi उत्तर में लिंक देखें: "विधि सुनिश्चित करती है कि फ़ाइल बंद है ..."

— बर्नहार्ड बार्कर

Answer 3

JDK 7 के बाद से - एक लाइनर:

byte[] array = Files.readAllBytes(Paths.get("/path/to/file"));

किसी बाहरी निर्भरता की आवश्यकता नहीं है।

Comments

यह अब स्वीकृत उत्तर की तुलना में बेहतर विकल्प है, जिसके लिए अपाचे कॉमन्स की आवश्यकता है।

— james.garriss

धन्यवाद :) मुझे भी इसकी आवश्यकता थी: स्ट्रिंग टेक्स्ट = नया स्ट्रिंग (Files.readAllBytes (नई फ़ाइल ("/ path / to / file") .Path ())); जो मूल रूप से stackoverflow.com/a/26888713/1257959 है

— cgl

Android में, इसके लिए न्यूनतम API स्तर 26 होना आवश्यक है।

— आशुतोष चमोली

आपको जोड़ने की आवश्यकता होगी import java.nio.file.Files;और import java.nio.file.Paths;यदि आप पहले से नहीं हैं।

— सैम

Answer 4

import java.io.RandomAccessFile;
RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);

जावा 8 के लिए दस्तावेज़: http://docs.oracle.com/javase/8/docs/api/java/io/RandomAccessFile.html

Comments

आपको f.read का रिटर्न मान चेक करना होगा ()। यहां कभी-कभी ऐसा हो सकता है, कि आप पूरी फाइल नहीं पढ़ेंगे।

— बग_

ऐसी स्थिति तभी हो सकती है जब आप इसे पढ़ते समय फ़ाइल बदल रहे हों। अन्य सभी मामलों में IOException को फेंक दिया जाता है। इस समस्या को हल करने के लिए, मैं रीड-राइट मोड में फ़ाइल खोलने का सुझाव देता हूं: रैंडमअटेफ़ाइल (फ़ाइलनाम, "आरडब्ल्यू")

— दिमित्री मित्केविच

मैं केवल फ़ाइल के एक हिस्से को पढ़ने के लिए अन्य स्रोतों की कल्पना कर सकता था (फ़ाइल एक नेटवर्क साझा पर है ...) readFully () में वह अनुबंध है जिसे आप खोज रहे हैं।

— DThought

याद रखें कि RandomAccessFile थ्रेड सुरक्षित नहीं है। तो, कुछ मामलों में सिंक्रनाइज़ेशन की आवश्यकता हो सकती है।

— bancer

@DmitryMitskevich अन्य मामलों के साथ-साथ फाइलसिस्टम पर भी हैं जो संभवतः गैर-अनुरूप हैं। उदाहरण के लिए, लाइन में / प्रोक / पर "फाइल्स" पढ़ने से छोटी रीडिंग हो सकती हैं (यानी आपको यह सब पढ़ने के लिए लूप की जरूरत है)

— nos

Answer 5

मूल रूप से आपको इसे मेमोरी में पढ़ना होगा। फ़ाइल खोलें, सरणी आवंटित करें, और फ़ाइल से सामग्री को सरणी में पढ़ें।

सबसे सरल तरीका कुछ इस तरह है:

public byte[] read(File file) throws IOException, FileTooBigException {
    if (file.length() > MAX_FILE_SIZE) {
        throw new FileTooBigException(file);
    }
    ByteArrayOutputStream ous = null;
    InputStream ios = null;
    try {
        byte[] buffer = new byte[4096];
        ous = new ByteArrayOutputStream();
        ios = new FileInputStream(file);
        int read = 0;
        while ((read = ios.read(buffer)) != -1) {
            ous.write(buffer, 0, read);
        }
    }finally {
        try {
            if (ous != null)
                ous.close();
        } catch (IOException e) {
        }

        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
        }
    }
    return ous.toByteArray();
}

इस फ़ाइल में सामग्री के कुछ अनावश्यक नकल (: फ़ाइल से करने के लिए वास्तव में डेटा तीन बार नकल है buffer, से bufferकरने के लिए ByteArrayOutputStream, से ByteArrayOutputStreamवास्तविक जिसके परिणामस्वरूप सरणी के लिए)।

आपको यह भी सुनिश्चित करने की आवश्यकता है कि आप मेमोरी में केवल एक निश्चित आकार तक की फाइलें पढ़ते हैं (यह आमतौर पर एप्लिकेशन निर्भर है) :-)।

आपको IOExceptionफ़ंक्शन के बाहर का भी इलाज करने की आवश्यकता है ।

एक और तरीका यह है:

public byte[] read(File file) throws IOException, FileTooBigException {
    if (file.length() > MAX_FILE_SIZE) {
        throw new FileTooBigException(file);
    }

    byte[] buffer = new byte[(int) file.length()];
    InputStream ios = null;
    try {
        ios = new FileInputStream(file);
        if (ios.read(buffer) == -1) {
            throw new IOException(
                    "EOF reached while trying to read the whole file");
        }
    } finally {
        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
        }
    }
    return buffer;
}

इसकी कोई अनावश्यक नकल नहीं है।

FileTooBigExceptionएक कस्टम अनुप्रयोग अपवाद है। MAX_FILE_SIZEलगातार एक आवेदन मापदंडों है।

बड़ी फ़ाइलों के लिए आपको शायद एक स्ट्रीम प्रोसेसिंग एल्गोरिदम सोचना चाहिए या मेमोरी मैपिंग (देखें java.nio) का उपयोग करना चाहिए ।

Comments

ios को कोशिश के बाहर घोषित करने की आवश्यकता है

— डेरिल स्पिट्जर

दूसरे उदाहरण में बयान "ios.read (बफर)" केवल फ़ाइल के पहले 4096 बाइट्स में पढ़ा जाएगा (पहले उदाहरण में उपयोग किए गए समान 4k बफर को मानते हुए)। दूसरे उदाहरण के लिए काम करने के लिए, मुझे लगता है कि रीड को थोड़ी देर के अंदर होना चाहिए जो -1 के परिणाम की जांच करता है (फ़ाइल का अंत तक पहुंच गया)।

— Stijn de Witt

क्षमा करें, ऊपर मेरी टिप्पणी को खारिज कर दें, कथन सेटिंग को फ़ाइल की लंबाई में चूक गए। फिर भी, मुझे पहला उदाहरण तरीका अधिक पसंद है। एक बार में पूरी फाइल को एक बफर में पढ़ना स्केलेबल नहीं है। फ़ाइल बड़ी होने पर आप मेमोरी से बाहर निकलने का जोखिम लेंगे।

— स्टिजन डे विट

"सरलतम" तरीका कोशिश-से-संसाधनों का उपयोग करेगा।

— सीना मदनी

शांत, लेकिन क्रिया करने के लिए थोड़ा।

— Sapphire_Brick

Answer 6

जैसा कि किसी ने कहा, Apache Commons File Utils में वह हो सकता है जिसकी आपको तलाश है

public static byte[] readFileToByteArray(File file) throws IOException

उदाहरण का उपयोग ( Program.java):

import org.apache.commons.io.FileUtils;
public class Program {
    public static void main(String[] args) throws IOException {
        File file = new File(args[0]);  // assume args[0] is the path to file
        byte[] data = FileUtils.readFileToByteArray(file);
        ...
    }
}

Answer 7

आप इसे करने के लिए NIO एपीआई का उपयोग कर सकते हैं। मैं इस कोड के साथ ऐसा कर सकता था जब तक कि कुल फ़ाइल आकार (बाइट्स में) एक इंट में फिट होगा।

File f = new File("c:\\wscp.script");
FileInputStream fin = null;
FileChannel ch = null;
try {
    fin = new FileInputStream(f);
    ch = fin.getChannel();
    int size = (int) ch.size();
    MappedByteBuffer buf = ch.map(MapMode.READ_ONLY, 0, size);
    byte[] bytes = new byte[size];
    buf.get(bytes);

} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} finally {
    try {
        if (fin != null) {
            fin.close();
        }
        if (ch != null) {
            ch.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

मुझे लगता है कि MappedByteBuffer का उपयोग करने के बाद से यह बहुत तेज है।

Comments

यदि आप केवल एक बार फाइल पढ़ने जा रहे हैं, तो मेमोरी मैपिंग का उपयोग करने की बिल्कुल आवश्यकता नहीं है, और यह एक सामान्य फाइलइंस्ट्रीमस्ट्रीम का उपयोग करते हुए दो बार अधिक मेमोरी का उपयोग करके समाप्त हो जाएगा।

— जेम्स

दुर्भाग्य से MappedByteBuffer स्वचालित रूप से जारी नहीं किया गया है।

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

भयानक, नए उदाहरण में प्रिंटस्टैकट्रेस, क्लासिक टूटे अपवाद हैंडलिंग शामिल हैं।

— जेम्स

मैं सहमत हूँ .. इसका डिफ़ॉल्ट सामान जो ग्रहण में है। मुझे लगता है कि मुझे अपवाद को फिर से हटाना चाहिए!

— अमित

Ive एक फ़ाइल से बाइट [] बनाने के लिए nio को बेंचमार्किंग कर रहा है। प्रत्यक्ष बफर का उपयोग करने के अलावा यह वास्तव में दो बार अधिक मेमोरी लेता है। हालाँकि यह बहुत बड़ी फ़ाइलों के लिए तेज़ है (लगभग 200M के लिए बफ़र किए गए IO की तुलना में दोगुना) यह 5M के आस-पास की फ़ाइलों के लिए 5 के कारक द्वारा खो देता है।

— चॉफर्स

Answer 8

यदि आपके पास जावा 8 नहीं है, और मुझसे सहमत हैं कि कोड की कुछ पंक्तियों को लिखने से बचने के लिए एक विशाल पुस्तकालय सहित एक बुरा विचार है:

public static byte[] readBytes(InputStream inputStream) throws IOException {
    byte[] b = new byte[1024];
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    int c;
    while ((c = inputStream.read(b)) != -1) {
        os.write(b, 0, c);
    }
    return os.toByteArray();
}

कॉलर स्ट्रीम को बंद करने के लिए जिम्मेदार है।

Answer 9

// Returns the contents of the file in a byte array.
    public static byte[] getBytesFromFile(File file) throws IOException {        
        // Get the size of the file
        long length = file.length();

        // You cannot create an array using a long type.
        // It needs to be an int type.
        // Before converting to an int type, check
        // to ensure that file is not larger than Integer.MAX_VALUE.
        if (length > Integer.MAX_VALUE) {
            // File is too large
            throw new IOException("File is too large!");
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[(int)length];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;

        InputStream is = new FileInputStream(file);
        try {
            while (offset < bytes.length
                   && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
                offset += numRead;
            }
        } finally {
            is.close();
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file "+file.getName());
        }
        return bytes;
    }

Comments

इसके अलावा, लूप के अंदर सुन्न रखें। छोटे से वैध दायरे में परिवर्तन की घोषणा करें। जबकि लूप के बाहर इसे डालना केवल उस जटिल "सक्षम" परीक्षण को सक्षम करने के लिए आवश्यक है; लूप के अंदर ईओएफ के लिए परीक्षण करना बेहतर होगा (और अगर ऐसा होता है तो ईओएफएक्स अपवाद को फेंक दें)।

— इरिकसन

throw new IOException("File is too large!");फ़ाइल बहुत बड़ी होने पर हमें क्या करना चाहिए? क्या इसके बारे में भी कोई उदाहरण है?

— फेर

Answer 10

इसे करने का सरल तरीका:

File fff = new File("/path/to/file");
FileInputStream fileInputStream = new FileInputStream(fff);

// int byteLength = fff.length(); 

// In android the result of file.length() is long
long byteLength = fff.length(); // byte count of the file-content

byte[] filecontent = new byte[(int) byteLength];
fileInputStream.read(filecontent, 0, (int) byteLength);

Comments

सरल तरीके हैं, जैसे कि वन-लाइनर्स जिनका पहले ही उल्लेख किया जा चुका है।

— Sapphire_Brick

@Sapphire_Brick सरल तरीके से हाँ - लेकिन एक लाइनर सभी स्थितियों में फिट नहीं होता है। जैसे कि Android।

— बेहर

Answer 11

फ़ाइल से बाइट्स पढ़ने के लिए सबसे सरल तरीका

import java.io.*;

class ReadBytesFromFile {
    public static void main(String args[]) throws Exception {
        // getBytes from anyWhere
        // I'm getting byte array from File
        File file = null;
        FileInputStream fileStream = new FileInputStream(file = new File("ByteArrayInputStreamClass.java"));

        // Instantiate array
        byte[] arr = new byte[(int) file.length()];

        // read All bytes of File stream
        fileStream.read(arr, 0, arr.length);

        for (int X : arr) {
            System.out.print((char) X);
        }
    }
}

Comments

मैं "सरलतम तरीका" होने का तर्क देता हूं :)

— BlondCode

क्या आप यहाँ समझा सकते हैं? आपका तर्क क्यों है?

— मुहम्मद सादिक़

कुछ खास नहीं है, लेकिन आप सरलतम कहते हैं और मैं अधिक सरल समाधान देखता हूं -> मेरी राय में यह सबसे सरल नहीं है। शायद यह कुछ साल पहले था, लेकिन दुनिया बदल रही है। मैं इस तरह के एक बयान के साथ अपने स्वयं के समाधान लेबल नहीं करूंगा। ;) यदि केवल आपने लिखा है "मेरी राय में सबसे सरल है .." या "सबसे सरल मैंने पाया .." आपको परेशान नहीं करना चाहता, बस इसे संप्रेषित करना अच्छा समझा।

— ब्लॉन्डकोड

@ मुहम्मदसादिक: कुछ भी आयात न करें .*, इसे बुरा व्यवहार माना जाता है।

— नीलमणि_क्रिक

Answer 12

अमरूद है आपको पेश करने के लिए Files.toByteArray () है। इसके कई फायदे हैं:

1. यह कोने के मामले को कवर करता है जहां फाइलें 0 की लंबाई की रिपोर्ट करती हैं लेकिन फिर भी इसमें सामग्री होती है
2. यह अत्यधिक अनुकूलित है, अगर आपको फ़ाइल लोड करने की कोशिश करने से पहले एक बड़ी फ़ाइल में पढ़ने की कोशिश कर रहा है, तो आपको एक आउटऑफ़मैरीएक्स अपवाद मिलता है। (File.length के चतुर उपयोग के माध्यम से ())
3. आपको पहिए को फिर से नहीं लगाना है।

Answer 13

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;

File file = getYourFile();
Path path = file.toPath();
byte[] data = Files.readAllBytes(path);

Comments

JDK स्तर क्या है?

— जोनाथन एस। फिशर

Answer 14

समुदाय विकी उत्तर के रूप में एक ही दृष्टिकोण का उपयोग करना, लेकिन क्लीनर और बॉक्स से बाहर संकलन (पसंदीदा दृष्टिकोण यदि आप अपाचे कॉमन्स के कामों को आयात नहीं करना चाहते हैं, उदाहरण के लिए एंड्रॉइड पर):

public static byte[] getFileBytes(File file) throws IOException {
    ByteArrayOutputStream ous = null;
    InputStream ios = null;
    try {
        byte[] buffer = new byte[4096];
        ous = new ByteArrayOutputStream();
        ios = new FileInputStream(file);
        int read = 0;
        while ((read = ios.read(buffer)) != -1)
            ous.write(buffer, 0, read);
    } finally {
        try {
            if (ous != null)
                ous.close();
        } catch (IOException e) {
            // swallow, since not that important
        }
        try {
            if (ios != null)
                ios.close();
        } catch (IOException e) {
            // swallow, since not that important
        }
    }
    return ous.toByteArray();
}

Answer 15

मुझे विश्वास है कि यह सबसे आसान तरीका है:

org.apache.commons.io.FileUtils.readFileToByteArray(file);

Comments

2009 में टॉम के इस सुझाव के साथ पहले से ही एक उत्तर है

— नॉट हेर्रमैन

Answer 16

ReadFully इस फाइल से बाइट सरणी में b.length बाइट्स को रीड करता है, जो वर्तमान फाइल पॉइंटर पर शुरू होता है। यह विधि फ़ाइल से बार-बार पढ़ती है जब तक कि अनुरोधित बाइट्स की संख्या पढ़ नहीं ली जाती है। यह विधि तब तक अवरुद्ध होती है जब तक कि अनुरोधित बाइट्स की संख्या को नहीं पढ़ा जाता है, धारा का अंत पता चला है, या एक अपवाद फेंक दिया गया है।

RandomAccessFile f = new RandomAccessFile(fileName, "r");
byte[] b = new byte[(int)f.length()];
f.readFully(b);

Answer 17

यदि आप बाइट्स को पूर्व-आवंटित बाइट बफर में पढ़ना चाहते हैं, तो यह उत्तर मदद कर सकता है।

आपका पहला अनुमान शायद उपयोग करना होगा InputStream read(byte[])। हालांकि, इस पद्धति में एक दोष है जो इसे उपयोग करने के लिए अनुचित रूप से कठिन बनाता है: इसमें कोई गारंटी नहीं है कि सरणी वास्तव में पूरी तरह से भर जाएगी, भले ही कोई ईओएफ सामने न हो।

इसके बजाय, एक नज़र डालें DataInputStream readFully(byte[])। यह इनपुट स्ट्रीम के लिए एक आवरण है, और इसमें उपर्युक्त समस्या नहीं है। इसके अतिरिक्त, ईओएफ का सामना करने पर यह विधि फेंकता है। बहुत अच्छे।

Answer 18

न केवल निम्न तरीके से एक java.io.ile को बाइट में परिवर्तित किया जाता है [], मैंने इसे एक फ़ाइल में पढ़ने का सबसे तेज़ तरीका भी पाया है, जब एक दूसरे के खिलाफ कई अलग-अलग जावा फ़ाइल पढ़ने के तरीकों का परीक्षण किया जाता है:

java.nio.file.Files.readAllBytes ()

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

public class ReadFile_Files_ReadAllBytes {
  public static void main(String [] pArgs) throws IOException {
    String fileName = "c:\\temp\\sample-10KB.txt";
    File file = new File(fileName);

    byte [] fileBytes = Files.readAllBytes(file.toPath());
    char singleChar;
    for(byte b : fileBytes) {
      singleChar = (char) b;
      System.out.print(singleChar);
    }
  }
}

Answer 19

मुझे तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना एक और समाधान जोड़ने दें। यह एक अपवाद हैंडलिंग पैटर्न का पुनः उपयोग करता है जो स्कॉट ( लिंक ) द्वारा प्रस्तावित किया गया था । और मैं एक अलग संदेश में बदसूरत हिस्सा ले जाया गया (मैं कुछ FileUtils वर्ग में छिपा होता है;))

public void someMethod() {
    final byte[] buffer = read(new File("test.txt"));
}

private byte[] read(final File file) {
    if (file.isDirectory())
        throw new RuntimeException("Unsupported operation, file "
                + file.getAbsolutePath() + " is a directory");
    if (file.length() > Integer.MAX_VALUE)
        throw new RuntimeException("Unsupported operation, file "
                + file.getAbsolutePath() + " is too big");

    Throwable pending = null;
    FileInputStream in = null;
    final byte buffer[] = new byte[(int) file.length()];
    try {
        in = new FileInputStream(file);
        in.read(buffer);
    } catch (Exception e) {
        pending = new RuntimeException("Exception occured on reading file "
                + file.getAbsolutePath(), e);
    } finally {
        if (in != null) {
            try {
                in.close();
            } catch (Exception e) {
                if (pending == null) {
                    pending = new RuntimeException(
                        "Exception occured on closing file" 
                             + file.getAbsolutePath(), e);
                }
            }
        }
        if (pending != null) {
            throw new RuntimeException(pending);
        }
    }
    return buffer;
}

Answer 20

public static byte[] readBytes(InputStream inputStream) throws IOException {
    byte[] buffer = new byte[32 * 1024];
    int bufferSize = 0;
    for (;;) {
        int read = inputStream.read(buffer, bufferSize, buffer.length - bufferSize);
        if (read == -1) {
            return Arrays.copyOf(buffer, bufferSize);
        }
        bufferSize += read;
        if (bufferSize == buffer.length) {
            buffer = Arrays.copyOf(buffer, bufferSize * 2);
        }
    }
}

Answer 21

पढ़ने के लिए एक और रास्ता फ़ाइल से बाइट्स

Reader reader = null;
    try {
        reader = new FileReader(file);
        char buf[] = new char[8192];
        int len;
        StringBuilder s = new StringBuilder();
        while ((len = reader.read(buf)) >= 0) {
            s.append(buf, 0, len);
            byte[] byteArray = s.toString().getBytes();
        }
    } catch(FileNotFoundException ex) {
    } catch(IOException e) {
    }
    finally {
        if (reader != null) {
            reader.close();
        }
    }

Comments

खोखले पकड़ने वाले ब्लॉक का उपयोग न करें। यह डिबगिंग को कठिन बनाता है।

— Sapphire_Brick

Answer 22

//The file that you wanna convert into byte[]
File file=new File("/storage/0CE2-EA3D/DCIM/Camera/VID_20190822_205931.mp4"); 

FileInputStream fileInputStream=new FileInputStream(file);
byte[] data=new byte[(int) file.length()];
BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
bufferedInputStream.read(data,0,data.length);

//Now the bytes of the file are contain in the "byte[] data"

Comments

हालांकि यह कोड प्रश्न का हल प्रदान कर सकता है, इसलिए संदर्भ जोड़ना बेहतर है कि यह क्यों / कैसे काम करता है। यह भविष्य के उपयोगकर्ताओं को सीखने में मदद कर सकता है, और उस ज्ञान को अपने कोड में लागू कर सकता है। जब कोड समझाया जाता है, तो आपको उपयोगकर्ताओं से upvotes के रूप में सकारात्मक प्रतिक्रिया मिलने की संभावना होती है।

— बोरवम

खैर, यह महत्वपूर्ण हिस्सा है जिसे मैं भविष्य की पोस्ट में ध्यान में रखूंगा। आपके उपयोगी अंतर्दृष्टि के लिए धन्यवाद।

— ओसामा महमूद

Answer 23

इसे इस्तेमाल करे :

import sun.misc.IOUtils;
import java.io.IOException;

try {
    String path="";
    InputStream inputStream=new FileInputStream(path);
    byte[] data=IOUtils.readFully(inputStream,-1,false);
}
catch (IOException e) {
    System.out.println(e);
}

Comments

इसके लिए एक विशेष JRE कार्यान्वयन की आवश्यकता होती है जो किसी अन्य JRE पर चलने पर ऐप को तोड़ देगा।

— रट्टमन

थोड़ी सी गलती: IOException और IOexception नहीं है, लेकिन धन्यवाद :)

— Matan Marciano

@MatanMarciano: मेरा बुरा

— Sapphire_Brick

Answer 24

में JDK8

Stream<String> lines = Files.lines(path);
String data = lines.collect(Collectors.joining("\n"));
lines.close();

Comments

मेरे फ्रेंच बोलने वाले मित्र का प्रश्न पढ़ें, यह एक "बाइट []" में बदलने के बारे में पूछता है और आपका उत्तर यह प्रदान नहीं करता है।

— कैसर कीस्टर

यह बाइट में परिवर्तित करने के लिए उत्तर देने के लिए एक भी दूरस्थ विकल्प प्रदान नहीं करता है []!

— अंडो