Java Language
इनपुटस्ट्रीम और आउटपुटस्ट्रीम

वाक्य - विन्यास

• int रीड (बाइट [] बी) IOException फेंकता है

टिप्पणियों

एक स्ट्रिंग में InputStream पढ़ना

कभी-कभी आप बाइट-इनपुट को एक स्ट्रिंग में पढ़ने की इच्छा कर सकते हैं। ऐसा करने के लिए आप कुछ है कि के बीच धर्मान्तरित खोजने की जरूरत होगी byte और "निवासी जावा" UTF-16 कोड पॉइंट्स के रूप में इस्तेमाल char । यह एक InputStreamReader साथ किया जाता है।

प्रक्रिया को थोड़ा तेज करने के लिए, बफर को आवंटित करना "सामान्य" है, ताकि इनपुट से पढ़ते समय हमारे पास बहुत अधिक ओवरहेड न हो।

public String inputStreamToString(InputStream inputStream) throws Exception {
     StringWriter writer = new StringWriter();

     char[] buffer = new char[1024];
     try (Reader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"))) {
           int n;
           while ((n = reader.read(buffer)) != -1) {
                // all this code does is redirect the output of `reader` to `writer` in
                // 1024 byte chunks
                writer.write(buffer, 0, n);
           }
     }
     return writer.toString();
}

इस उदाहरण को जावा एसई 6 (और निम्न) में परिवर्तित करना-असंगत कोड को पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है।

एक आउटपुटस्ट्रीम पर बाइट्स लिखना

एक बार में एक OutputStream बाइट पर बाइट्स लिखना

OutputStream stream = object.getOutputStream();

byte b = 0x00;
stream.write( b );

एक बाइट सरणी लेखन

byte[] bytes = new byte[] { 0x00, 0x00 };

stream.write( bytes );

एक बाइट सरणी के एक खंड लेखन

int offset = 1;
int length = 2;
byte[] bytes = new byte[] { 0xFF, 0x00, 0x00, 0xFF };

stream.write( bytes, offset, length );

समापन धाराएँ

जब आप उनके साथ किए जाते हैं, तो अधिकांश धाराएँ बंद होनी चाहिए, अन्यथा आप मेमोरी रिसाव शुरू कर सकते हैं या किसी फ़ाइल को खुला छोड़ सकते हैं। यह महत्वपूर्ण है कि धाराएं बंद कर दी जाती हैं, भले ही एक अपवाद फेंक दिया गया हो।

try(FileWriter fw = new FileWriter("outfilename");
    BufferedWriter bw = new BufferedWriter(fw);
    PrintWriter out = new PrintWriter(bw))
{
    out.println("the text");
    //more code
    out.println("more text");
    //more code
} catch (IOException e) {
    //handle this however you 
}

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter out = null;
try {
    fw = new FileWriter("myfile.txt");
    bw = new BufferedWriter(fw);
    out = new PrintWriter(bw);
    out.println("the text");
    out.close();
} catch (IOException e) {
    //handle this however you want
}
finally {
    try {
        if(out != null)
            out.close();
    } catch (IOException e) {
        //typically not much you can do here...
    }
}

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

आउटपुट स्ट्रीम में इनपुट स्ट्रीम कॉपी करना

यह फ़ंक्शन दो धाराओं के बीच डेटा की प्रतिलिपि बनाता है -

void copy(InputStream in, OutputStream out) throws IOException {
    byte[] buffer = new byte[8192];
    while ((bytesRead = in.read(buffer)) > 0) {
        out.write(buffer, 0, bytesRead);
    }
}

उदाहरण -

 // reading from System.in and writing to System.out
copy(System.in, System.out);

रैपिंग इनपुट / आउटपुट स्ट्रीम

OutputStream और InputStream में कई अलग-अलग वर्ग हैं, उनमें से प्रत्येक एक अद्वितीय कार्यक्षमता के साथ है। एक धारा को दूसरे के चारों ओर लपेटने से, आप दोनों धाराओं की कार्यक्षमता प्राप्त करते हैं।

आप किसी भी समय किसी भी स्ट्रीम को लपेट सकते हैं, बस ऑर्डर करने पर ध्यान दें।

उपयोगी संयोजन

बफर का उपयोग करते हुए किसी फ़ाइल में वर्ण लिखना

File myFile = new File("targetFile.txt");
PrintWriter writer = new PrintWriter(new BufferedOutputStream(new FileOutputStream(myFile)));

बफर का उपयोग करते हुए फ़ाइल में लिखने से पहले डेटा को संपीड़ित और एन्क्रिप्ट करना

Cipher cipher = ... // Initialize cipher
File myFile = new File("targetFile.enc");
BufferedOutputStream outputStream = new BufferedOutputStream(new DeflaterOutputStream(new CipherOutputStream(new FileOutputStream(myFile), cipher)));

इनपुट / आउटपुट स्ट्रीम रैपर्स की सूची

DataInputStream उदाहरण

package com.streams;  
import java.io.*;    
public class DataStreamDemo {  
  public static void main(String[] args) throws IOException {  
    InputStream input = new FileInputStream("D:\\datastreamdemo.txt");  
    DataInputStream inst = new DataInputStream(input);  
    int count = input.available();  
    byte[] arr = new byte[count];  
    inst.read(arr);  
    for (byte byt : arr) {  
      char ki = (char) byt;  
      System.out.print(ki+"-");  
    }  
  }  
}