java जावा में एक स्ट्रिंग में इनपुटस्ट्रीम को कैसे पढ़ / परिवर्तित करें?





15 Answers

यहां केवल मानक जावा लाइब्रेरी का उपयोग करने का एक तरीका है (ध्यान दें कि स्ट्रीम बंद नहीं है, वाईएमएमवी)।

static String convertStreamToString(java.io.InputStream is) {
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

मैंने इस चाल को "बेवकूफ स्कैनर चाल" लेख से सीखा। कारण यह काम करता है क्योंकि Scanner धारा में टोकन पर पुनरावृत्ति करता है, और इस मामले में हम "इनपुट सीमा की शुरुआत" (\ ए) का उपयोग करके टोकन को अलग करते हैं, इस प्रकार हम स्ट्रीम की पूरी सामग्री के लिए केवल एक टोकन देते हैं।

नोट, यदि आपको इनपुट स्ट्रीम के एन्कोडिंग के बारे में विशिष्ट होना आवश्यक है, तो आप Scanner कन्स्ट्रक्टर को दूसरा तर्क प्रदान कर सकते हैं जो इंगित करता है कि किस वर्ण का उपयोग करना है (उदाहरण के लिए "यूटीएफ -8")।

हैट टिप Jacob, को भी जाता है Jacob, जिसने मुझे एक बार लेख में बताया था।

संपादित: Patrick से एक सुझाव के लिए धन्यवाद, एक खाली इनपुट स्ट्रीम को संभालने के दौरान समारोह को और अधिक मजबूत बना दिया। एक और संपादन: मिश्रित कोशिश / पकड़, पैट्रिक का रास्ता अधिक लापरवाही है।

java string io stream inputstream

यदि आपके पास java.io.InputStream ऑब्जेक्ट है, तो आप उस ऑब्जेक्ट को कैसे संसाधित कर सकते हैं और String उत्पादन कैसे कर सकते हैं?

मान लीजिए मेरे पास एक InputStream है जिसमें टेक्स्ट डेटा है, और मैं इसे String रूपांतरित करना चाहता हूं, इसलिए उदाहरण के लिए मैं इसे लॉग फ़ाइल में लिख सकता हूं।

InputStream लेने और इसे String बदलने का सबसे आसान तरीका क्या है?

public String convertStreamToString(InputStream is) { 
    // ???
}



अपाचे कॉमन्स अनुमति देता है:

String myString = IOUtils.toString(myInputStream, "UTF-8");

बेशक, आप यूटीएफ -8 के अलावा अन्य चरित्र एन्कोडिंग चुन सकते हैं।

यह भी देखें: ( Docs )




इस बारे में कैसा है?

InputStream in = /* your InputStream */;
StringBuilder sb=new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String read;

while((read=br.readLine()) != null) {
    //System.out.println(read);
    sb.append(read);   
}

br.close();
return sb.toString();



यह मेरा शुद्ध जावा और एंड्रॉइड समाधान है, अच्छी तरह से काम करता है ...

public String readFullyAsString(InputStream inputStream, String encoding)
        throws IOException {
    return readFully(inputStream).toString(encoding);
}    

public byte[] readFullyAsBytes(InputStream inputStream)
        throws IOException {
    return readFully(inputStream).toByteArray();
}    

private ByteArrayOutputStream readFully(InputStream inputStream)
        throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    int length = 0;
    while ((length = inputStream.read(buffer)) != -1) {
        baos.write(buffer, 0, length);
    }
    return baos;
}



यहां कुछ प्रयोग के बाद आया सबसे सुंदर, शुद्ध-जावा (कोई लाइब्रेरी) समाधान नहीं है:

public static String fromStream(InputStream in) throws IOException
{
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    StringBuilder out = new StringBuilder();
    String newLine = System.getProperty("line.separator");
    String line;
    while ((line = reader.readLine()) != null) {
        out.append(line);
        out.append(newLine);
    }
    return out.toString();
}



मैं कुछ जावा 8 चाल का उपयोग करता हूँ।

public static String streamToString(final InputStream inputStream) throws Exception {
    // buffering optional
    try
    (
        final BufferedReader br
           = new BufferedReader(new InputStreamReader(inputStream))
    ) {
        // parallel optional
        return br.lines().parallel().collect(Collectors.joining("\n"));
    } catch (final IOException e) {
        throw new RuntimeException(e);
        // whatever.
    }
}

अनिवार्य रूप से कुछ अन्य उत्तरों के समान ही संक्षेप में छोड़कर।




Stream एस का उपयोग कर शुद्ध जावा समाधान , जावा 8 के बाद से काम करता है।

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

// ...
public static String inputStreamToString(InputStream is) throws IOException {
    try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
        return br.lines().collect(Collectors.joining(System.lineSeparator()));
    }
}

जैसा कि अन्य उत्तर के नीचे क्रिस्टोफर हैमरस्ट्रॉम द्वारा वर्णित है, स्पष्ट रूप से Charset निर्दिष्ट करना सुरक्षित है । Ie इनपुटस्ट्रीम रीडर कन्स्ट्रक्टर निम्नानुसार परिवर्तन हो सकता है:

new InputStreamReader(is, Charset.forName("UTF-8"))



यहां कम-से-कम संपथ का उत्तर दिया गया है, थोड़ा सा साफ किया गया है और फ़ंक्शन के रूप में प्रतिनिधित्व किया गया है:

String streamToString(InputStream in) throws IOException {
  StringBuilder out = new StringBuilder();
  BufferedReader br = new BufferedReader(new InputStreamReader(in));
  for(String line = br.readLine(); line != null; line = br.readLine()) 
    out.append(line);
  br.close();
  return out.toString();
}



यदि आप कॉमन्स IO (FileUtils / IOUtils / CopyUtils) का उपयोग नहीं कर सकते हैं तो फ़ाइल लाइन को लाइन लाइन पढ़ने के लिए BufferedReader का उपयोग करके एक उदाहरण यहां दिया गया है:

public class StringFromFile {
    public static void main(String[] args) /*throws UnsupportedEncodingException*/ {
        InputStream is = StringFromFile.class.getResourceAsStream("file.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(is/*, "UTF-8"*/));
        final int CHARS_PER_PAGE = 5000; //counting spaces
        StringBuilder builder = new StringBuilder(CHARS_PER_PAGE);
        try {
            for(String line=br.readLine(); line!=null; line=br.readLine()) {
                builder.append(line);
                builder.append('\n');
            }
        } catch (IOException ignore) { }
        String text = builder.toString();
        System.out.println(text);
    }
}

या यदि आप कच्ची गति चाहते हैं तो मैं पॉल डी वीरीज़ ने जो कुछ सुझाव दिया है उस पर एक भिन्नता का प्रस्ताव देना होगा (जो स्ट्रिंगवाइटर का उपयोग करने से बचाता है (जो आंतरिक रूप से स्ट्रिंगबफर का उपयोग करता है):

public class StringFromFileFast {
    public static void main(String[] args) /*throws UnsupportedEncodingException*/ {
        InputStream is = StringFromFileFast.class.getResourceAsStream("file.txt");
        InputStreamReader input = new InputStreamReader(is/*, "UTF-8"*/);
        final int CHARS_PER_PAGE = 5000; //counting spaces
        final char[] buffer = new char[CHARS_PER_PAGE];
        StringBuilder output = new StringBuilder(CHARS_PER_PAGE);
        try {
            for(int read = input.read(buffer, 0, buffer.length);
                    read != -1;
                    read = input.read(buffer, 0, buffer.length)) {
                output.append(buffer, 0, read);
            }
        } catch (IOException ignore) { }

        String text = output.toString();
        System.out.println(text);
    }
}



यदि आप स्ट्रीम रीडर का उपयोग करते हैं तो स्ट्रीम को अंत में बंद करना सुनिश्चित करें

private String readStream(InputStream iStream) throws IOException {
    //build a Stream Reader, it can read char by char
    InputStreamReader iStreamReader = new InputStreamReader(iStream);
    //build a buffered Reader, so that i can read whole line at once
    BufferedReader bReader = new BufferedReader(iStreamReader);
    String line = null;
    StringBuilder builder = new StringBuilder();
    while((line = bReader.readLine()) != null) {  //Read till end
        builder.append(line);
        builder.append("\n"); // append new line to preserve lines
    }
    bReader.close();         //close all opened stuff
    iStreamReader.close();
    //iStream.close(); //EDIT: Let the creator of the stream close it!
                       // some readers may auto close the inner stream
    return builder.toString();
}

संपादित करें: जेडीके 7+ पर, आप कोशिश-के-संसाधन निर्माण का उपयोग कर सकते हैं।

/**
 * Reads the stream into a string
 * @param iStream the input stream
 * @return the string read from the stream
 * @throws IOException when an IO error occurs
 */
private String readStream(InputStream iStream) throws IOException {

    //Buffered reader allows us to read line by line
    try (BufferedReader bReader =
                 new BufferedReader(new InputStreamReader(iStream))){
        StringBuilder builder = new StringBuilder();
        String line;
        while((line = bReader.readLine()) != null) {  //Read till end
            builder.append(line);
            builder.append("\n"); // append new line to preserve lines
        }
        return builder.toString();
    }
}



बाइट सरणी बफर का उपयोग करके केवल जेडीके का उपयोग करके इसे कैसे करें। यह वास्तव में कॉमन्स-आईओ IOUtils.copy()विधियों को कैसे काम करता है। यदि आप किसी के बजाय कॉपी कर रहे हैं तो आप इसके byte[]साथ प्रतिस्थापित कर सकते char[]हैं ।ReaderInputStream

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

...

InputStream is = ....
ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
byte[] buffer = new byte[8192];
int count = 0;
try {
  while ((count = is.read(buffer)) != -1) {
    baos.write(buffer, 0, count);
  }
}
finally {
  try {
    is.close();
  }
  catch (Exception ignore) {
  }
}

String charset = "UTF-8";
String inputStreamAsString = baos.toString(charset);



कोटलिन उपयोगकर्ता बस करते हैं:

println(InputStreamReader(is).readText())

जहाँ तक

readText()

कोटलिन मानक पुस्तकालय की अंतर्निहित विस्तार विधि है।




यह अच्छा है क्योंकि:

  • हाथ सुरक्षा चार्सेट।
  • आप पढ़े बफर आकार को नियंत्रित करते हैं।
  • आप बिल्डर की लंबाई का प्रावधान कर सकते हैं और बिल्कुल नहीं हो सकते हैं।
  • लाइब्रेरी निर्भरताओं से मुक्त है।
  • जावा 7 या उच्चतर के लिए है।

के लिए क्या?

public static String convertStreamToString(InputStream is) {
   if (is == null) return null;
   StringBuilder sb = new StringBuilder(2048); // Define a size if you have an idea of it.
   char[] read = new char[128]; // Your buffer size.
   try (InputStreamReader ir = new InputStreamReader(is, StandardCharsets.UTF_8)) {
     for (int i; -1 != (i = ir.read(read)); sb.append(read, 0, i));
   } catch (Throwable t) {}
   return sb.toString();
}



जेडीके में सबसे आसान तरीका निम्नलिखित कोड स्निपलेट्स के साथ है।

String convertToString(InputStream in){
    String resource = new Scanner(in).useDelimiter("\\Z").next();
    return resource;
}



जब क्लाउडपाथ संसाधन (जो लोकप्रिय कार्य लगता है) से इनपुट स्ट्रीम आता है तो गुवा बहुत कम कुशल ऑटोक्लोज़िंग समाधान प्रदान करता है :

String content = Files.asCharSource(new File("robots.txt"), StandardCharsets.UTF_8).read();
byte[] data = Files.asByteSource(new File("favicon.ico")).read();

या

String content = Files.toString(new File("robots.txt"), StandardCharsets.UTF_8);
byte[] data = Files.toByteArray(new File("favicon.ico"));

ByteSource और CharSource की सामान्य अवधारणा भी है जो धीरे-धीरे दोनों को खोलने और बंद करने का ख्याल रखती है।

तो, उदाहरण के लिए, इसकी सामग्री को पढ़ने के लिए स्पष्ट रूप से एक छोटी फ़ाइल खोलने की बजाय:

public String read (InputStream is) {
    byte next = is.read();
    return next == -1 ? "" : next + read(is); // Recursive part: reads next byte recursively
}

या केवल

 String content = Files.toString(new File("robots.txt"), StandardCharsets.UTF_8); byte[] data = Files.toByteArray(new File("favicon.ico")); 



Related