पढ़ने/लिखने के लिए बाइट्स और एक फ़ाइल से का उपयोग कर केवल जावा.कब

यह की तरह लग रहा है, इन कर रहे हैं करने के लिए जा कोर उपयोगिता/पुस्तकालय तरीकों जो होना चाहिए पर चलाने के लिए Android एपीआई 23 या बाद में.

के विषय में लाइब्रेरी के तरीकों, मैं इसे का सबसे अच्छा बनाने के लिए कोई मान्यताओं पर कैसे अनुप्रयोगों का उपयोग करेगा इन तरीकों में है. कुछ मामलों में आवेदन चाहते हो सकता प्राप्त करने के लिए जाँच की IOExceptionएस (क्योंकि एक फ़ाइल से डेटा मौजूद होना चाहिए के लिए आवेदन करने के लिए काम), अन्य मामलों में आवेदन भी नहीं परवाह है, तो डेटा उपलब्ध नहीं है, क्योंकि (एक फ़ाइल से डेटा केवल कैश भी उपलब्ध है कि एक प्राथमिक स्रोत).

जब यह आता है करने के लिए मैं/हे कार्यों, वहाँ कभी नहीं है एक गारंटी है कि आपरेशन सफल होगा (जैसे उपयोगकर्ता फोन छोड़ने में शौचालय). पुस्तकालय को प्रतिबिंबित करना चाहिए कि और आवेदन देने के एक विकल्प पर संभाल करने के लिए कैसे त्रुटियों.

अनुकूलन करने के लिए मैं/हे प्रदर्शन हमेशा मान खुश "पथ" और त्रुटियों को पकड़ने के लिए पता लगाने की क्या गलत हो गया था. इस काउंटर सहज ज्ञान युक्त करने के लिए सामान्य प्रोग्रामिंग, लेकिन आवश्यक के साथ निपटने में भंडारण पर मैं/ओ के लिए उदाहरण के लिए, सिर्फ अगर जाँच फ़ाइल मौजूद है पढ़ने से पहले एक फ़ाइल से कर सकते हैं अपने आवेदन में दो बार के रूप में धीमी गति से, इन सभी की तरह मैं/हे कार्यों को जोड़ने के लिए तेजी से धीमी गति से अपने आवेदन नीचे. मान लेते हैं कि फ़ाइल मौजूद है और यदि आप एक त्रुटि मिलती है, तो केवल यदि फ़ाइल मौजूद है.

तो दिए गए उन विचारों, मुख्य कार्य की तरह लग सकता है:

public static void writeFile(File f, byte[] data) throws FileNotFoundException, IOException {
    try (FileOutputStream out = new FileOutputStream(f)) {
        out.write(data);
    }
}

public static int readFile(File f, byte[] data) throws FileNotFoundException, IOException {
    try (FileInputStream in = new FileInputStream(f)) {
        return in.read(data); 
    }
}

नोट कार्यान्वयन के बारे में:

• के तरीकों में भी फेंक क्रम-अपवाद की तरह NullPointerExceptions - इन तरीकों में कभी नहीं जा रहे हैं होना करने के लिए "बग मुक्त".
• मुझे नहीं लगता कि बफ़रिंग आवश्यक है/में चाहता था इसके बाद के संस्करण तरीकों के बाद से केवल एक देशी कॉल किया जाता है (यह भी देखें यहाँ).
• आवेदन अब भी विकल्प है करने के लिए केवल पढ़ने के लिए शुरुआत के एक फ़ाइल.

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

public static byte[] readFile(File f) throws FileNotFoundException, IOException {
    int fsize = verifyFileSize(f);
    byte[] data = new byte[fsize];
    int read = readFile(f, data);
    verifyAllDataRead(f, data, read);
    return data;
}

private static int verifyFileSize(File f) throws IOException {
    long fsize = f.length();
    if (fsize > Integer.MAX_VALUE) {
        throw new IOException("File size (" + fsize + " bytes) for " + f.getName() + " too large.");
    }
    return (int) fsize;
}

public static void verifyAllDataRead(File f, byte[] data, int read) throws IOException {
    if (read != data.length) {
        throw new IOException("Expected to read " + data.length 
                + " bytes from file " + f.getName() + " but got only " + read + " bytes from file.");
    }
}

इस कार्यान्वयन के लिए कहते हैं एक बिंदु की विफलता: OutOfMemory है, जहां बिंदु पर नए डेटा सरणी बनाई गई है.

को समायोजित करने के लिए आवेदन इसके अलावा, अतिरिक्त तरीकों जोड़ा जा सकता है के साथ मदद के लिए अलग अलग परिदृश्य है. उदाहरण के लिए, चलो का कहना है कि आवेदन वास्तव में नहीं चाहते हैं के साथ सौदा करने के लिए जाँच अपवाद:

public static void writeFileData(File f, byte[] data) {
    try {
        writeFile(f, data);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
}

public static byte[] readFileData(File f) {
    try {
        return readFile(f);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
    return null;
}

public static int readFileData(File f, byte[] data) {
    try {
        return readFile(f, data);
    } catch (Exception e) {
        fileExceptionToRuntime(e);
    }
    return -1;
}

private static void fileExceptionToRuntime(Exception e) {
    if (e instanceof RuntimeException) { // e.g. NullPointerException
        throw (RuntimeException)e;
    }
    RuntimeException re = new RuntimeException(e.toString());
    re.setStackTrace(e.getStackTrace());
    throw re;
}

विधि fileExceptionToRuntime एक न्यूनतम कार्यान्वयन, लेकिन यह पता चलता है यहाँ पर विचार.

पुस्तकालय भी मदद कर सकता है एक आवेदन का निवारण करने के लिए जब एक त्रुटि होती है. उदाहरण के लिए, एक विधि canReadFile(File f) की जांच कर सकता है यदि फ़ाइल मौजूद है और पठनीय है और बहुत बड़ा नहीं है । आवेदन फोन कर सकता है इस तरह के एक समारोह के बाद एक फ़ाइल को पढ़ने में विफल रहता है, और जाँच के लिए आम कारणों से क्यों एक फ़ाइल को पढ़ा नहीं जा सकता. एक ही किया जा सकता है लिखने के लिए एक फाइल करने के लिए.

हालांकि आप का उपयोग नहीं कर सकते तीसरे पक्ष के पुस्तकालयों के साथ, आप पढ़ सकते हैं अभी भी अपने कोड और उनके अनुभव से सीखना. गूगल में अमरूद उदाहरण के लिए, आप आमतौर पर पढ़ने के एक फ़ाइल बाइट्स में इस तरह:

FileInputStream reader = new FileInputStream("test.txt");
byte[] result = ByteStreams.toByteArray(reader);

कोर के कार्यान्वयन यह है toByteArrayInternal. फोन करने से पहले, आप की जाँच करनी चाहिए:

• एक नहीं null फ़ाइल को पारित कर दिया है (NullPointerException)
• फ़ाइल मौजूद है (FileNotFoundException)

उसके बाद, यह कम है से निपटने के लिए एक InputStream और इस जहां IOExceptions से आते हैं. जब पढ़ने धाराओं चीजों की एक बहुत कुछ के नियंत्रण से बाहर अपने आवेदन में गलत जा सकते हैं (बुरा क्षेत्रों और अन्य हार्डवेयर मुद्दों, मल-कामकाज ड्राइवरों, ओएस अधिकारों का उपयोग) और स्वयं को प्रकट के साथ एक IOException.

मैं हूँ यहाँ नकल कार्यान्वयन:

private static final int BUFFER_SIZE = 8192;

/** Max array length on JVM. */
private static final int MAX_ARRAY_LEN = Integer.MAX_VALUE - 8;

private static byte[] toByteArrayInternal(InputStream in, Queue<byte[]> bufs, int totalLen)
      throws IOException {
    // Starting with an 8k buffer, double the size of each successive buffer. Buffers are retained
    // in a deque so that there's no copying between buffers while reading and so all of the bytes
    // in each new allocated buffer are available for reading from the stream.
    for (int bufSize = BUFFER_SIZE;
        totalLen < MAX_ARRAY_LEN;
        bufSize = IntMath.saturatedMultiply(bufSize, 2)) {
      byte[] buf = new byte[Math.min(bufSize, MAX_ARRAY_LEN - totalLen)];
      bufs.add(buf);
      int off = 0;
      while (off < buf.length) {
        // always OK to fill buf; its size plus the rest of bufs is never more than MAX_ARRAY_LEN
        int r = in.read(buf, off, buf.length - off);
        if (r == -1) {
          return combineBuffers(bufs, totalLen);
        }
        off += r;
        totalLen += r;
      }
    }

    // read MAX_ARRAY_LEN bytes without seeing end of stream
    if (in.read() == -1) {
      // oh, there's the end of the stream
      return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

के रूप में आप कर सकते हैं के तर्क के साथ करने के लिए फ़ाइल पढ़ने में हिस्सा । यह स्थितियों को संभालने के लिए है, जहां आप नहीं जानते का आकार InputStream शुरू करने से पहले, पढ़ने के लिए है । आपके मामले में, आप केवल करने की जरूरत फ़ाइलों को पढ़ने और आप में सक्षम होना चाहिए लंबाई पता करने के लिए पहले से है, तो यह जटिलता से बचा जा सकता है.

अन्य की जांच OutOfMemoryException. में मानक जावा की सीमा बहुत बड़ी है, लेकिन एंड्रॉयड में, यह हो जाएगा एक बहुत छोटा मान । आप की जाँच करनी चाहिए, कोशिश कर रहा से पहले फ़ाइल को पढ़ने के लिए है कि वहाँ है पर्याप्त स्मृति उपलब्ध है.