दिलचस्प पोस्ट
'जेसन' देशी मणि को स्थापित बिल्ड टूल की आवश्यकता होती है कस्टम फॉर्म में Django समय / दिनांक विजेट का उपयोग करना एक पाठ क्षेत्र में उपयोग के लिए <br /> को एक नई पंक्ति में परिवर्तित करना Android में एरेडेडैप्टर वर्ग का उपयोग करके अनुकूलित सूची दृश्य एक संकेतक "dereferencing" क्या मतलब है? लाइन 2 से फ़ाइल पढ़ें या हेडर पंक्ति छोड़ें TypeError: 'str' ऑब्जेक्ट कोने योग्य नहीं है (पायथन) सी # पढ़ने के लिए अनाम रूपों में अनाम रूपों की संपत्ति क्यों हैं? बीन इनिशियलाइजेशन पूरा होने के बाद किसी विधि को कैसे कॉल करें? एंड्रॉइड वर्तमान लोकेल, डिफ़ॉल्ट नहीं है HttpWebRequest प्रमाणन नहीं गुजर रहा है डीएपी, वैल और स्केला में वैर का इस्तेमाल SQLite के लिए एक अच्छा ओ ओ सी + आवरण क्या है कैसे गतिशील रूप से UITableViewCell ऊंचाई का आकार बदलना एक अभिभावक दृश्य नियंत्रक को कॉल करें (एक नेविगेशन नियंत्रक के माध्यम से)

एक स्ट्रिंग में एक इनपुट स्प्रैड को पढ़ें / कन्वर्ट करें

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


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

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

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

वेब के समाधान से एकत्रित समाधान "एक स्ट्रिंग में एक इनपुट स्प्रैड को पढ़ें / कन्वर्ट करें"

ऐसा करने का एक अच्छा तरीका है अपाचे कॉमन्स IOUtils का उपयोग करने के लिए InputStream को एक StringWriter में कॉपी करने के लिए … ऐसा कुछ

 StringWriter writer = new StringWriter(); IOUtils.copy(inputStream, writer, encoding); String theString = writer.toString(); 

या और भी

 // NB: does not close inputStream, you can use IOUtils.closeQuietly for that String theString = IOUtils.toString(inputStream, encoding); 

वैकल्पिक रूप से, आप ByteArrayOutputStream उपयोग कर सकते हैं यदि आप अपने स्ट्रीम और राइटर्स को मिश्रण नहीं करना चाहते हैं

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

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

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

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

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

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

दूसरे उत्तरों को संक्षेप में बताएं मुझे ऐसा करने के लिए 11 मुख्य तरीके मिले (नीचे देखें)। और मैंने कुछ प्रदर्शन परीक्षण (नीचे परिणाम देखें):

एक स्ट्रिंग में एक इनपुट स्प्रैड कन्वर्ट करने के तरीके:

  1. IOUtils.toString ( Apache Utils ) का उपयोग करना

     String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8); 
  2. Charstreams का उपयोग करना ( guava )

     String result = CharStreams.toString(new InputStreamReader( inputStream, Charsets.UTF_8)); 
  3. Scanner का प्रयोग ( जेडीके )

     Scanner s = new Scanner(inputStream).useDelimiter("\\A"); String result = s.hasNext() ? s.next() : ""; 
  4. स्ट्रीम एपीआई ( Java 8 ) का उपयोग करना चेतावनी : यह समाधान अलग लाइन ब्रेक ( \r\n जैसे) को \n करने के लिए परिवर्तित करता है।

     String result = new BufferedReader(new InputStreamReader(inputStream)) .lines().collect(Collectors.joining("\n")); 
  5. समानांतर स्ट्रीम एपीआई ( Java 8 ) का उपयोग करना चेतावनी : यह समाधान अलग लाइन ब्रेक ( \r\n जैसे) को \n करने के लिए परिवर्तित करता है।

     String result = new BufferedReader(new InputStreamReader(inputStream)).lines() .parallel().collect(Collectors.joining("\n")); 
  6. InputStreamReader और StringBuilder का प्रयोग ( JDK )

     final int bufferSize = 1024; final char[] buffer = new char[bufferSize]; final StringBuilder out = new StringBuilder(); Reader in = new InputStreamReader(inputStream, "UTF-8"); for (; ; ) { int rsz = in.read(buffer, 0, buffer.length); if (rsz < 0) break; out.append(buffer, 0, rsz); } return out.toString(); 
  7. स्ट्रिंग वाइटर और IOUtils.copy ( Apache Commons ) का उपयोग करना

     StringWriter writer = new StringWriter(); IOUtils.copy(inputStream, writer, "UTF-8"); return writer.toString(); 
  8. बाइटअरेऑन आउटपुटस्ट्रीम और इनपुटस्ट्रीम। रीड ( जेडीके ) का उपयोग करना

     ByteArrayOutputStream result = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) != -1) { result.write(buffer, 0, length); } // StandardCharsets.UTF_8.name() > JDK 7 return result.toString("UTF-8"); 
  9. बफ़्टेडरडर ( JDK ) का उपयोग करना चेतावनी: यह समाधान अलग लाइन ब्रेक (जैसे \n\r ) को line.separator सिस्टम प्रॉपर्टी (उदाहरण के लिए, "\ r \ n" में विंडोज में) line.separator करते हैं।

     String newLine = System.getProperty("line.separator"); BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); StringBuilder result = new StringBuilder(); String line; boolean flag = false; while ((line = reader.readLine()) != null) { result.append(flag? newLine: "").append(line); flag = true; } return result.toString(); 
  10. BufferedInputStream और ByteArrayOutputStream ( JDK ) का उपयोग करना

     BufferedInputStream bis = new BufferedInputStream(inputStream); ByteArrayOutputStream buf = new ByteArrayOutputStream(); int result = bis.read(); while(result != -1) { buf.write((byte) result); result = bis.read(); } // StandardCharsets.UTF_8.name() > JDK 7 return buf.toString("UTF-8"); 
  11. इनपुटस्ट्रीम.read () और स्ट्रिंगबिल्ल्डर (जेडीके) का उपयोग करना चेतावनी : इस समाधान में यूनिकोड के साथ समस्या है, उदाहरण के लिए रूसी पाठ के साथ (गैर-यूनिकोड पाठ के साथ ही सही ढंग से काम करें)

     int ch; StringBuilder sb = new StringBuilder(); while((ch = inputStream.read()) != -1) sb.append((char)ch); reset(); return sb.toString(); 

चेतावनी :

  1. समाधान 4 , 5 और 9 अलग-अलग लाइन ब्रेक्स को एक में कनवर्ट करें

  2. समाधान 11 यूनिकोड पाठ के साथ ठीक से काम नहीं कर सकता

प्रदर्शन जांच

छोटे String (लंबाई = 175) के लिए प्रदर्शन परीक्षण, गिटौब में यूआरएल (मोड = औसत समय, सिस्टम = लिनक्स, स्कोर 1,343 सर्वोत्तम है):

  Benchmark Mode Cnt Score Error Units 8. ByteArrayOutputStream and read (JDK) avgt 10 1,343 ± 0,028 us/op 6. InputStreamReader and StringBuilder (JDK) avgt 10 6,980 ± 0,404 us/op 10. BufferedInputStream, ByteArrayOutputStream avgt 10 7,437 ± 0,735 us/op 11. InputStream.read() and StringBuilder (JDK) avgt 10 8,977 ± 0,328 us/op 7. StringWriter and IOUtils.copy (Apache) avgt 10 10,613 ± 0,599 us/op 1. IOUtils.toString (Apache Utils) avgt 10 10,605 ± 0,527 us/op 3. Scanner (JDK) avgt 10 12,083 ± 0,293 us/op 2. CharStreams (guava) avgt 10 12,999 ± 0,514 us/op 4. Stream Api (Java 8) avgt 10 15,811 ± 0,605 us/op 9. BufferedReader (JDK) avgt 10 16,038 ± 0,711 us/op 5. parallel Stream Api (Java 8) avgt 10 21,544 ± 0,583 us/op 

बड़ी String (लंबाई = 50100) के लिए प्रदर्शन परीक्षण, जिथूब में यूआरएल (मोड = औसत समय, सिस्टम = लिनक्स, स्कोर 200,715 सर्वोत्तम है):

  Benchmark Mode Cnt Score Error Units 8. ByteArrayOutputStream and read (JDK) avgt 10 200,715 ± 18,103 us/op 1. IOUtils.toString (Apache Utils) avgt 10 300,019 ± 8,751 us/op 6. InputStreamReader and StringBuilder (JDK) avgt 10 347,616 ± 130,348 us/op 7. StringWriter and IOUtils.copy (Apache) avgt 10 352,791 ± 105,337 us/op 2. CharStreams (guava) avgt 10 420,137 ± 59,877 us/op 9. BufferedReader (JDK) avgt 10 632,028 ± 17,002 us/op 5. parallel Stream Api (Java 8) avgt 10 662,999 ± 46,199 us/op 4. Stream Api (Java 8) avgt 10 701,269 ± 82,296 us/op 10. BufferedInputStream, ByteArrayOutputStream avgt 10 740,837 ± 5,613 us/op 3. Scanner (JDK) avgt 10 751,417 ± 62,026 us/op 11. InputStream.read() and StringBuilder (JDK) avgt 10 2919,350 ± 1101,942 us/op 

ग्राफ (विंडोज 7 सिस्टम में इनपुट स्ट्रीम की लंबाई के आधार पर प्रदर्शन परीक्षण)
यहां छवि विवरण दर्ज करें

विंडोज 7 सिस्टम में इनपुट स्ट्रीम की लंबाई के आधार पर प्रदर्शन परीक्षण (औसत समय):

  length 182 546 1092 3276 9828 29484 58968 test8 0.38 0.938 1.868 4.448 13.412 36.459 72.708 test4 2.362 3.609 5.573 12.769 40.74 81.415 159.864 test5 3.881 5.075 6.904 14.123 50.258 129.937 166.162 test9 2.237 3.493 5.422 11.977 45.98 89.336 177.39 test6 1.261 2.12 4.38 10.698 31.821 86.106 186.636 test7 1.601 2.391 3.646 8.367 38.196 110.221 211.016 test1 1.529 2.381 3.527 8.411 40.551 105.16 212.573 test3 3.035 3.934 8.606 20.858 61.571 118.744 235.428 test2 3.136 6.238 10.508 33.48 43.532 118.044 239.481 test10 1.593 4.736 7.527 20.557 59.856 162.907 323.147 test11 3.913 11.506 23.26 68.644 207.591 600.444 1211.545 

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

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

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

यह भी देखें: ( डॉक्स )

खाता फाइल में लेना चाहिए सबसे पहले एक java.io.Reader उदाहरण मिलेगा। यह तब पढ़ा जा सकता है और StringBuilder जोड़ा जा सकता है (अगर हमें StringBuffer की ज़रूरत नहीं है, तो हम इसे कई धागे में प्रवेश नहीं कर रहे हैं, और StringBuilder तेज है)। यहां चाल यही है कि हम ब्लॉकों में काम करते हैं, और जैसे अन्य बफरिंग स्ट्रीम की आवश्यकता नहीं होती है रन-टाइम प्रदर्शन ऑप्टिमाइज़ेशन के लिए ब्लॉक आकार पैरामीटर है

 public static String slurp(final InputStream is, final int bufferSize) { final char[] buffer = new char[bufferSize]; final StringBuilder out = new StringBuilder(); try (Reader in = new InputStreamReader(is, "UTF-8")) { for (;;) { int rsz = in.read(buffer, 0, buffer.length); if (rsz < 0) break; out.append(buffer, 0, rsz); } } catch (UnsupportedEncodingException ex) { /* ... */ } catch (IOException ex) { /* ... */ } return out.toString(); } 

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

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

यदि आप Google-Collections / Guava का उपयोग कर रहे हैं तो आप निम्न कर सकते हैं:

 InputStream stream = ... String content = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8)); Closeables.closeQuietly(stream); 

ध्यान दें कि InputStreamReader लिए दूसरे पैरामीटर (यानी Charsets.UTF_8) आवश्यक नहीं है, लेकिन यदि आप इसे जानते हैं तो यह आमतौर पर एन्कोडिंग निर्दिष्ट करने के लिए एक अच्छा विचार है (जो आपको करना चाहिए!)

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

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

कैसा रहेगा:

 import java.io.BufferedInputStream; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.io.IOException; public static String readInputStreamAsString(InputStream in) throws IOException { BufferedInputStream bis = new BufferedInputStream(in); ByteArrayOutputStream buf = new ByteArrayOutputStream(); int result = bis.read(); while(result != -1) { byte b = (byte)result; buf.write(b); result = bis.read(); } return buf.toString(); } 

यहां पूर्णता के लिए जावा 9 समाधान है:

 public static String toString(InputStream input) throws IOException { return new String(input.readAllBytes(), StandardCharsets.UTF_8); } 

readAllBytes वर्तमान में readAllBytes 9 मुख्य कोडबेस में है, इसलिए यह रिलीज में दिखाई देने की संभावना है आप जेडीके 9 स्नैपशॉट बिल्ड्स का उपयोग करके अभी इसे आज़मा सकते हैं।

मैं कुछ जावा 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. } } 

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

जावा, जावा के बाद से काम करता है।

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

जैसा कि क्रिस्टोफर हम्मरस्ट्रॉम द्वारा अन्य उत्तर के नीचे वर्णित है, यह स्पष्ट रूप से वर्णसेट निर्दिष्ट करने के लिए सुरक्षित है IeInputStreamReader कन्स्ट्रक्टर निम्नानुसार परिवर्तन हो सकता है:

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

मैंने कुछ समय परीक्षण चलाया क्योंकि समय के मामलों, हमेशा

मैंने एक स्ट्रिंग 3 अलग-अलग तरीकों से प्रतिक्रिया प्राप्त करने का प्रयास किया (नीचे दिखाया गया है)
मैंने खातिर पठनीयता के लिए ब्लॉकों की कोशिश / पकड़ को छोड़ दिया।

संदर्भ देने के लिए, यह सभी 3 तरीकों के लिए पूर्ववर्ती कोड है:

  String response; String url = "www.blah.com/path?key=value"; GetMethod method = new GetMethod(url); int status = client.executeMethod(method); 

1)

  response = method.getResponseBodyAsString(); 

2)

 InputStream resp = method.getResponseBodyAsStream(); InputStreamReader is=new InputStreamReader(resp); BufferedReader br=new BufferedReader(is); String read = null; StringBuffer sb = new StringBuffer(); while((read = br.readLine()) != null) { sb.append(read); } response = sb.toString(); 

3)

 InputStream iStream = method.getResponseBodyAsStream(); StringWriter writer = new StringWriter(); IOUtils.copy(iStream, writer, "UTF-8"); response = writer.toString(); 

इसलिए, एक ही अनुरोध / प्रतिक्रिया डेटा के साथ प्रत्येक दृष्टिकोण पर 500 परीक्षण चलाने के बाद, यहां संख्याएं हैं। एक बार फिर, ये मेरे निष्कर्ष हैं और आपके निष्कर्ष बिल्कुल वैसा नहीं हो सकते हैं, लेकिन मैंने ये लिखा है कि इन तरीकों के दक्षता के मतभेदों के अन्य लोगों को कुछ संकेत दें।

रैंक:
दृष्टिकोण # 1
दृष्टिकोण # 3 – # 1 से 2.6% धीमी है
दृष्टिकोण # 2 – # 1 की तुलना में धीमी गति से 4.3%

इन तरीकों में से कोई भी प्रतिक्रिया को हथियाने और उसके बाद से एक स्ट्रिंग बनाने के लिए एक उपयुक्त समाधान है।

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

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

यदि आप साहसी महसूस कर रहे थे, तो आप स्काला और जावा को मिला सकते हैं और इस के साथ समाप्त कर सकते हैं:

 scala.io.Source.fromInputStream(is).mkString("") 

जावा और स्काला कोड और पुस्तकालयों को मिलाते हुए इसके लाभ हैं

यहां पूर्ण विवरण देखें: इनटास्ट्रीम को स्कला में स्ट्रिंग के रूप में कनवर्ट करने के लिए रेशमयुक्त तरीका

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

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

or if you want raw speed I'd propose a variation on what Paul de Vrieze suggested (which avoids using a StringWriter (which uses a StringBuffer internally) :

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

This is an answer adapted from org.apache.commons.io.IOUtils source code , for those who want to have the apache implementation but do not want the whole library.

 private static final int BUFFER_SIZE = 4 * 1024; public static String inputStreamToString(InputStream inputStream, String charsetName) throws IOException { StringBuilder builder = new StringBuilder(); InputStreamReader reader = new InputStreamReader(inputStream, charsetName); char[] buffer = new char[BUFFER_SIZE]; int length; while ((length = reader.read(buffer)) != -1) { builder.append(buffer, 0, length); } return builder.toString(); } 

Make sure to close the streams at end if you use Stream Readers

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

EDIT: On JDK 7+, you can use try-with-resources construct.

 /** * 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(); } } 

Here is the complete method for converting InputStream into String without using any third party library. Use StringBuilder for single threaded environment otherwise use StringBuffer .

 public static String getString( InputStream is) throws IOException { int ch; StringBuilder sb = new StringBuilder(); while((ch = is.read()) != -1) sb.append((char)ch); return sb.toString(); } 

Here's how to do it using just the JDK using byte array buffers. This is actually how the commons-io IOUtils.copy() methods all work. You can replace byte[] with char[] if you're copying from a Reader instead of an InputStream .

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

Another one, for all the Spring users:

 import java.nio.charset.StandardCharsets; import org.springframework.util.FileCopyUtils; public String convertStreamToString(InputStream is) throws IOException { return new String(FileCopyUtils.copyToByteArray(is), StandardCharsets.UTF_8); } 

The utility methods in org.springframework.util.StreamUtils are similar to the ones in FileCopyUtils , but they leave the stream open when done.

Kotlin users simply do:

 println(InputStreamReader(is).readText()) 

whereas

 readText() 

is Kotlin standard library's built-in extension method.

This one is nice because:

  • Hand safety the Charset.
  • You control the read buffer size.
  • You can provision the length of the builder and can be not exactly.
  • Is free from library dependencies.
  • Is for Java 7 or higher.

What the for?

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

The easiest way in JDK is with the following code snipplets.

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

Well you can program it for yourself.. it's not complicated..

 String Inputstream2String (InputStream is) throws IOException { final int PKG_SIZE = 1024; byte[] data = new byte [PKG_SIZE]; StringBuilder buffer = new StringBuilder(PKG_SIZE * 10); int size; size = is.read(data, 0, data.length); while (size > 0) { String str = new String(data, 0, size); buffer.append(str); size = is.read(data, 0, data.length); } return buffer.toString(); } 

JDK 7/8 answer that closes the stream and still throws an IOException:

 StringBuilder build = new StringBuilder(); byte[] buf = new byte[1024]; int length; try (InputStream is = getInputStream()) { while ((length = is.read(buf)) != -1) { build.append(new String(buf, 0, length)); } } 

You can use apache commons. In the IOUtils you can find the toString metod with 3 helpfull implementations.

 public static String toString(InputStream input) throws IOException { return toString(input, Charset.defaultCharset()); } public static String toString(InputStream input) throws IOException { return toString(input, Charset.defaultCharset()); } public static String toString(InputStream input, String encoding) throws IOException { return toString(input, Charsets.toCharset(encoding)); } 

I have written a class that does just that, so I figured I'd share it with everyone. Sometimes you don't want to add Apache Commons just for one thing, and want something dumber than Scanner that doesn't examine the content.

Usage is as follows

 // Read from InputStream String data = new ReaderSink(inputStream, Charset.forName("UTF-8")).drain(); // Read from File data = new ReaderSink(file, Charset.forName("UTF-8")).drain(); // Drain input stream to console new ReaderSink(inputStream, Charset.forName("UTF-8")).drainTo(System.out); 

Here is the code for ReaderSink:

 import java.io.*; import java.nio.charset.Charset; /** * A simple sink class that drains a {@link Reader} to a {@link String} or * to a {@link Writer}. * * @author Ben Barkay * @version 2/20/2014 */ public class ReaderSink { /** * The default buffer size to use if no buffer size was specified. */ public static final int DEFAULT_BUFFER_SIZE = 1024; /** * The {@link Reader} that will be drained. */ private final Reader in; /** * Constructs a new {@code ReaderSink} for the specified file and charset. * @param file The file to read from. * @param charset The charset to use. * @throws FileNotFoundException If the file was not found on the filesystem. */ public ReaderSink(File file, Charset charset) throws FileNotFoundException { this(new FileInputStream(file), charset); } /** * Constructs a new {@code ReaderSink} for the specified {@link InputStream}. * @param in The {@link InputStream} to drain. * @param charset The charset to use. */ public ReaderSink(InputStream in, Charset charset) { this(new InputStreamReader(in, charset)); } /** * Constructs a new {@code ReaderSink} for the specified {@link Reader}. * @param in The reader to drain. */ public ReaderSink(Reader in) { this.in = in; } /** * Drains the data from the underlying {@link Reader}, returning a {@link String} containing * all of the read information. This method will use {@link #DEFAULT_BUFFER_SIZE} for * its buffer size. * @return A {@link String} containing all of the information that was read. */ public String drain() throws IOException { return drain(DEFAULT_BUFFER_SIZE); } /** * Drains the data from the underlying {@link Reader}, returning a {@link String} containing * all of the read information. * @param bufferSize The size of the buffer to use when reading. * @return A {@link String} containing all of the information that was read. */ public String drain(int bufferSize) throws IOException { StringWriter stringWriter = new StringWriter(); drainTo(stringWriter, bufferSize); return stringWriter.toString(); } /** * Drains the data from the underlying {@link Reader}, writing it to the * specified {@link Writer}. This method will use {@link #DEFAULT_BUFFER_SIZE} for * its buffer size. * @param out The {@link Writer} to write to. */ public void drainTo(Writer out) throws IOException { drainTo(out, DEFAULT_BUFFER_SIZE); } /** * Drains the data from the underlying {@link Reader}, writing it to the * specified {@link Writer}. * @param out The {@link Writer} to write to. * @param bufferSize The size of the buffer to use when reader. */ public void drainTo(Writer out, int bufferSize) throws IOException { char[] buffer = new char[bufferSize]; int read; while ((read = in.read(buffer)) > -1) { out.write(buffer, 0, read); } } } 

Guava provides much shorter efficient autoclosing solution in case when input stream comes from classpath resource (which seems to be popular task):

 byte[] bytes = Resources.toByteArray(classLoader.getResource(path)); 

या

 String text = Resources.toString(classLoader.getResource(path), StandardCharsets.UTF_8); 

There is also general concept of ByteSource and CharSource that gently take care of both opening and closing the stream.

So, for example, instead of explicitly opening a small file to read its contents:

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

or just

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