"如何在 Java 中将 InputStream 读取\/转换为字符串？"

Question

如果您有一个java.io.InputStream<\/code>对象，您应该如何处理该对象并生成一个String<\/code> ？

---

假设我有一个包含文本数据的InputStream<\/code> ，并且我想将其转换为String<\/code> ，例如我可以将其写入日志文件。

获取InputStream<\/code>并将其转换为String<\/code>的最简单方法是什么？

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

Answer 1

总结其他答案我发现了 11 种主要方法（见下文）。 我写了一些性能测试（见下面的结果）：

将 InputStream 转换为字符串的方法：<\/strong>

1. 使用IOUtils.toString<\/code> (Apache Utils)

   使用CharStreams<\/code> (Guava)
   使用Scanner<\/code> (JDK)
   使用流 API<\/strong> (Java 8)。 警告<\/strong>：此解决方案将不同的换行符（如\\r\\n<\/code> ）转换为\\n<\/code> 。
   使用并行流 API<\/strong> (Java 8)。 警告<\/strong>：此解决方案将不同的换行符（如\\r\\n<\/code> ）转换为\\n<\/code> 。
   使用InputStreamReader<\/code>和StringBuilder<\/code> (JDK)
   使用StringWriter<\/code>和IOUtils.copy<\/code> (Apache Commons)
   使用ByteArrayOutputStream<\/code>和inputStream.read<\/code> (JDK)
   使用BufferedReader<\/code> (JDK)。 警告：<\/strong>此解决方案将不同的换行符（如\\n\\r<\/code> ）转换为line.separator<\/code>系统属性（例如，在 Windows 中为 "\\r\\n"）。
   使用BufferedInputStream<\/code>和ByteArrayOutputStream<\/code> (JDK)
   使用inputStream.read()<\/code>和StringBuilder<\/code> (JDK)。 警告<\/strong>：此解决方案存在 Unicode 问题，例如俄语文本（仅适用于非 Unicode 文本）
   警告<\/strong>：
    
                                        
   
                                         解决方案 4、5 和 9 将不同的换行符转换为一个。
    
   解决方案 11 无法正确处理 Unicode 文本
   性能测试<\/strong>
   小String<\/code> （长度=175）， github<\/a>中的url（mode=Average Time，system=Linux，1343分最好）的性能测试：
    big String<\/code> (length = 50100), github<\/a>中的url (mode = Average Time, system = Linux, score 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<\/code><\/pre>
    图表（性能测试取决于 Windows 7 系统中的输入流长度）
    
   性能测试（平均时间）取决于 Windows 7 系统中的输入流长度：
   
                                        

Answer 2

一个很好的方法是使用Apache commons IOUtils将InputStream复制到StringWriter ......类似于

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

甚至

// NB: does not close inputStream, you'll have to use try-with-resources for that
String theString = IOUtils.toString(inputStream, encoding); 

或者，如果您不想混合使用 Streams 和 Writers，则可以使用ByteArrayOutputStream

Answer 3

这是一种仅使用标准 Java 库的方法（请注意，流未关闭，您的里程可能会有所不同）。

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

Answer 4

Apache Commons 允许：

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

Answer 5

考虑到文件，首先应该得到一个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();
}

Answer 6

利用：

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

Answer 7

如果您使用的是 Google-Collections\/Guava，您可以执行以下操作：

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

Answer 8

为了完整起见，这里是Java 9<\/strong>解决方案：

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

Answer 9

这是最适合 Android 和任何其他 JVM 的纯 Java 解决方案。

这个解决方案运行得非常好......它简单、快速，并且在大小流上都一样！ （见上面的基准.. 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;
}

Answer 10

利用：

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

Answer 11

这是我经过一些实验后想出的最优雅的纯 Java（无库）解决方案：

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

Answer 12

我在这里对 14 个不同的答案进行了基准测试（很抱歉没有提供学分，但重复的太多了）。

结果非常令人惊讶。 事实证明，Apache IOUtils<\/strong>是最慢的，而ByteArrayOutputStream<\/code>是最快的解决方案：

所以首先这里是最好的方法：

public String inputStreamToString(InputStream inputStream) throws IOException {
    try(ByteArrayOutputStream result = new ByteArrayOutputStream()) {
        byte[] buffer = new byte[1024];
        int length;
        while ((length = inputStream.read(buffer)) != -1) {
            result.write(buffer, 0, length);
        }

        return result.toString(UTF_8);
    }
}

Answer 13

我会使用一些 Java 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.
    }
}

Answer 14

我进行了一些计时测试，因为时间总是很重要。

我试图以 3 种不同的方式将响应转换为字符串。 （如下图）
为了便于阅读，我省略了 try\/catch 块。

为了给出上下文，这是所有 3 种方法的前面代码：

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

Answer 15

使用Stream<\/a>的纯 Java 解决方案，从 Java 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()));
    }
}

Answer 16

这里或多或少是 sampath 的答案，稍微清理一下并表示为一个函数：

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

Answer 17

如果您喜欢冒险，您可以混合使用 Scala 和 Java，然后得到以下结果：

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

Answer 18

如果您不能使用 Commons 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);
    }
}

Answer 19

使用 Java 9 中支持的java.io.InputStream.transferTo(OutputStream)<\/a>和采用字符集名称的ByteArrayOutputStream.toString(String)<\/a> ：

public static String gobble(InputStream in, String charsetName) throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    in.transferTo(bos);
    return bos.toString(charsetName);
}

Answer 20

如果您使用流阅读器，请确保在最后关闭流

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

Answer 21

这个很好，因为：

• 它安全地处理字符集。
• 您可以控制读取缓冲区的大小。
• 您可以设置构建器的长度，它不必是精确值。
• 没有库依赖。
• 适用于 Java 7 或更高版本。

怎么做？

public static String convertStreamToString(InputStream is) throws IOException {
   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));
   }
   return sb.toString();
}

对于 JDK 9

public static String inputStreamString(InputStream inputStream) throws IOException {
    try (inputStream) {
        return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
    }
}

Answer 22

这是改编自org.apache.commons.io.IOUtils<\/code> 源代码<\/a>的答案，适用于那些想要实现 apache 但不想要整个库的人。

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

Answer 23

String inputStreamToString(InputStream inputStream, Charset charset) throws IOException {
    try (
            final StringWriter writer = new StringWriter();
            final InputStreamReader reader = new InputStreamReader(inputStream, charset)
        ) {
        reader.transferTo(writer);
        return writer.toString();
    }
}

Answer 24

另一个，适用于所有 Spring 用户：

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

Answer 25

这是在不使用任何第三方库的情况下将InputStream<\/code>转换为String<\/code>的完整方法。 将StringBuilder<\/code>用于单线程环境，否则使用StringBuffer<\/code> 。

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

Answer 26

Kotlin 用户只需执行以下操作：

println(InputStreamReader(is).readText())

Answer 27

以下是使用字节数组缓冲区仅使用 JDK 的方法。 这实际上是 commons-io IOUtils.copy()<\/code>方法的全部工作方式。 如果您从Reader<\/code>而不是InputStream<\/code>复制，则可以将byte[]<\/code>替换为char[]<\/code> 。

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

Answer 28

JDK 中最简单的方法是使用以下代码片段。

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

Answer 29

就reduce和concat而言，它可以在 Java 8 中表示为：

String fromFile = new BufferedReader(new   
InputStreamReader(inputStream)).lines().reduce(String::concat).get();

Answer 30

这是我基于Java 8的解决方案，它使用新的 Stream API从InputStream收集所有行：

public static String toString(InputStream inputStream) {
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(inputStream));
    return reader.lines().collect(Collectors.joining(
        System.getProperty("line.separator")));
}

Answer 31

下面的代码对我有用。

URL url = MyClass.class.getResource("/" + configFileName);
BufferedInputStream bi = (BufferedInputStream) url.getContent();
byte[] buffer = new byte[bi.available() ];
int bytesRead = bi.read(buffer);
String out = new String(buffer);

请注意，根据 Java 文档， available()方法可能不适用于InputStream但始终适用于BufferedInputStream 。 如果您不想使用available()方法，我们可以随时使用以下代码

URL url = MyClass.class.getResource("/" + configFileName);
BufferedInputStream bi = (BufferedInputStream) url.getContent();
File f = new File(url.getPath());
byte[] buffer = new byte[ (int) f.length()];
int bytesRead = bi.read(buffer);
String out = new String(buffer);

我不确定是否会有任何编码问题。 如果代码有任何问题，请发表评论。

Answer 32

嗯，你可以自己编程……不复杂……

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

Answer 33

关闭流并仍然抛出 IOException 的 JDK 7/8 答案：

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

Answer 34

我写了一个这样做的类，所以我想我会与大家分享。 有时您不想仅仅为了一件事而添加 Apache Commons，并且想要比不检查内容的 Scanner 更愚蠢的东西。

用法如下

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

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

Answer 35

基于已接受的 Apache Commons 答案的第二部分，但填补了小空白以始终关闭流：

    String theString;
    try {
        theString = IOUtils.toString(inputStream, encoding);
    } finally {
        IOUtils.closeQuietly(inputStream);
    }

Answer 36

在Groovy中

inputStream.getText()

Answer 37

您可以使用 Apache Commons。

在 IOUtils 中，您可以找到具有三个有用实现的 toString 方法。

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

Answer 38

试试这4句话

根据 Fred 回忆的观点，不建议使用+=运算符附加String ，因为每次将新char附加到现有String再次创建新的String对象并将其地址分配给st而旧的st对象变为垃圾。

public String convertStreamToString(InputStream is)
{
    int k;
    StringBuffer sb=new StringBuffer();
    while((k=fin.read()) != -1)
    {
        sb.append((char)k);
    }
    return sb.toString();
}

---

不推荐，但这也是一种方式

public String convertStreamToString(InputStream is) { 
    int k;
    String st="";
    while((k=is.read()) != -1)
    {
        st+=(char)k;
    }
    return st;
}

Answer 39

InputStream is = Context.openFileInput(someFileName); // whatever format you have

ByteArrayOutputStream bos = new ByteArrayOutputStream();

byte[] b = new byte[8192];
for (int bytesRead; (bytesRead = is.read(b)) != -1;) {
    bos.write(b, 0, bytesRead);
}

String output = bos.toString(someEncoding);

Answer 40

Guava 提供了更短的高效自动关闭解决方案，以防输入流来自类路径资源（这似乎是流行的任务）：

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

或者

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

还有ByteSource和CharSource 的一般概念，它们温和地负责打开和关闭流。

因此，例如，不是显式打开一个小文件来读取其内容：

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

Answer 41

Raghu K Nair是唯一一个使用扫描仪的人。 我使用的代码有点不同：

String convertToString(InputStream in){
    Scanner scanner = new Scanner(in)
    scanner.useDelimiter("\\A");

    boolean hasInput = scanner.hasNext();
    if (hasInput) {
        return scanner.next();
    } else {
        return null;
    }

}

关于分隔符： 如何在 Java Scanner 中使用分隔符？

Answer 42

public String read(InputStream in) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(in))) {
        return buffer.lines().collect(Collectors.joining("\n"));
    }
}

Answer 43

与 Okio：

String result = Okio.buffer(Okio.source(inputStream)).readUtf8();

Answer 44

InputStreamReader i = new InputStreamReader(s);
BufferedReader str = new BufferedReader(i);
String msg = str.readLine();
System.out.println(msg);

这里 s 是您的InputStream对象，它将被转换为String

Answer 45

您可以使用仙人掌：

String text = new TextOf(inputStream).asString();

UTF-8 编码是默认编码。 如果您需要另一个：

String text = new TextOf(inputStream, "UTF-16").asString();

Answer 46

我已经创建了这段代码，它可以工作。 不需要外部插件。

有一个转换器String to Stream和Stream to String ：

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class STRINGTOSTREAM {

    public static void main(String[] args)
    {
        String text = "Hello Bhola..!\nMy Name Is Kishan ";

        InputStream strm = new ByteArrayInputStream(text.getBytes());    // Convert String to Stream

        String data = streamTostring(strm);

        System.out.println(data);
    }

    static String streamTostring(InputStream stream)
    {
        String data = "";

        try
        {
            StringBuilder stringbuld = new StringBuilder();
            int i;
            while ((i=stream.read())!=-1)
            {
                stringbuld.append((char)i);
            }
            data = stringbuld.toString();
        }
        catch(Exception e)
        {
            data = "No data Streamed.";
        }
        return data;
    }

Answer 47

ISO-8859-1

如果您知道输入流的编码是 ISO-8859-1 或 ASCII，那么这是一种非常高效的方法。 它 (1) 避免了StringWriter的内部StringBuffer出现的不必要的同步，(2) 避免了InputStreamReader的开销，以及 (3) 最大限度地减少了StringBuilder的内部char数组必须被复制的次数。

public static String iso_8859_1(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            chars.append((char)(buffer[i] & 0xFF));
        }
    }
    return chars.toString();
}

UTF-8

相同的通用策略可用于使用 UTF-8 编码的流：

public static String utf8(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    int state = 0;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            if ((state = nextStateUtf8(state, buffer[i])) >= 0) {
                chars.appendCodePoint(state);
            } else if (state == -1) { //error
                state = 0;
                chars.append('\uFFFD'); //replacement char
            }
        }
    }
    return chars.toString();
}

其中nextStateUtf8()函数定义如下：

/**
 * Returns the next UTF-8 state given the next byte of input and the current state.
 * If the input byte is the last byte in a valid UTF-8 byte sequence,
 * the returned state will be the corresponding unicode character (in the range of 0 through 0x10FFFF).
 * Otherwise, a negative integer is returned. A state of -1 is returned whenever an
 * invalid UTF-8 byte sequence is detected.
 */
static int nextStateUtf8(int currentState, byte nextByte) {
    switch (currentState & 0xF0000000) {
        case 0:
            if ((nextByte & 0x80) == 0) { //0 trailing bytes (ASCII)
                return nextByte;
            } else if ((nextByte & 0xE0) == 0xC0) { //1 trailing byte
                if (nextByte == (byte) 0xC0 || nextByte == (byte) 0xC1) { //0xCO & 0xC1 are overlong
                    return -1;
                } else {
                    return nextByte & 0xC000001F;
                }
            } else if ((nextByte & 0xF0) == 0xE0) { //2 trailing bytes
                if (nextByte == (byte) 0xE0) { //possibly overlong
                    return nextByte & 0xA000000F;
                } else if (nextByte == (byte) 0xED) { //possibly surrogate
                    return nextByte & 0xB000000F;
                } else {
                    return nextByte & 0x9000000F;
                }
            } else if ((nextByte & 0xFC) == 0xF0) { //3 trailing bytes
                if (nextByte == (byte) 0xF0) { //possibly overlong
                    return nextByte & 0x80000007;
                } else {
                    return nextByte & 0xE0000007;
                }
            } else if (nextByte == (byte) 0xF4) { //3 trailing bytes, possibly undefined
                return nextByte & 0xD0000007;
            } else {
                return -1;
            }
        case 0xE0000000: //3rd-to-last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0x80000000: //3rd-to-last continuation byte, check overlong
            return (nextByte & 0xE0) == 0xA0 || (nextByte & 0xF0) == 0x90 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0xD0000000: //3rd-to-last continuation byte, check undefined
            return (nextByte & 0xF0) == 0x80 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0x90000000: //2nd-to-last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xA0000000: //2nd-to-last continuation byte, check overlong
            return (nextByte & 0xE0) == 0xA0 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xB0000000: //2nd-to-last continuation byte, check surrogate
            return (nextByte & 0xE0) == 0x80 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xC0000000: //last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0x3F : -1;
        default:
            return -1;
    }
}

自动检测编码

如果您的输入流是使用 ASCII 或 ISO-8859-1 或 UTF-8 编码的，但您不确定是哪一种，我们可以使用与上一种类似的方法，但使用额外的编码检测组件来自动检测返回字符串之前的编码。

public static String autoDetect(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    int state = 0;
    boolean ascii = true;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            if ((state = nextStateUtf8(state, buffer[i])) > 0x7F)
                ascii = false;
            chars.append((char)(buffer[i] & 0xFF));
        }
    }

    if (ascii || state < 0) { //probably not UTF-8
        return chars.toString();
    }
    //probably UTF-8
    int pos = 0;
    char[] charBuf = new char[2];
    for (int i = 0, len = chars.length(); i < len; i++) {
        if ((state = nextStateUtf8(state, (byte)chars.charAt(i))) >= 0) {
            boolean hi = Character.toChars(state, charBuf, 0) == 2;
            chars.setCharAt(pos++, charBuf[0]);
            if (hi) {
                chars.setCharAt(pos++, charBuf[1]);
            }
        }
    }
    return chars.substring(0, pos);
}

如果您的输入流的编码既不是 ISO-8859-1 也不是 ASCII 也不是 UTF-8，那么我遵循已经存在的其他答案。

Answer 48

此代码适用于新的 Java 学习者：

     private String textDataFromFile;

public String getFromFile(InputStream myInputStream) throws FileNotFoundException, IOException {

      BufferedReader bufferReader = new BufferedReader (new InputStreamReader(myInputStream));

       StringBuilder stringBuilder = new StringBuilder();

  String eachStringLine;

    while((eachStringLine=bufferReader.readLine()) != null){          
        stringBuilder.append(eachStringLine).append("\n");
    }

   textDataFromFile = stringBuilder.toString(); 



  return textDataFromFile;

}

Answer 49

如果您需要将字符串转换为没有外部库的特定字符集，则：

public String convertStreamToString(InputStream is) throws IOException {
  try (ByteArrayOutputStream baos = new ByteArrayOutputStream();) {
    is.transferTo(baos);
    return baos.toString(StandardCharsets.UTF_8);
  }
}

Answer 50

以下内容并未解决原始问题，而是一些回复。

几个响应表明形式的循环

String line = null;
while((line = reader.readLine()) != null) {
  // ...
}

或者

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    // ...
}

第一种形式通过在封闭作用域中声明一个变量“read”来污染封闭作用域的命名空间，该变量不会用于 for 循环之外的任何内容。 第二种形式复制了 readline() 调用。

这是在 Java 中编写此类循环的更简洁的方法。 事实证明，for 循环中的第一个子句不需要实际的初始化值。 这将变量“行”的范围保持在 for 循环的主体内。 优雅多了！ 我在任何地方都没有看到有人使用过这个表格（我几年前偶然发现了它），但我一直在使用它。

for (String line; (line = reader.readLine()) != null; ) {
    //...
}

Answer 51

这个问题的解决方案不是最简单的，但是由于没有提到 NIO 流和通道，这里有一个使用 NIO 通道和一个 ByteBuffer 将流转换为字符串的版本。

public static String streamToStringChannel(InputStream in, String encoding, int bufSize) throws IOException {
    ReadableByteChannel channel = Channels.newChannel(in);
    ByteBuffer byteBuffer = ByteBuffer.allocate(bufSize);
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    WritableByteChannel outChannel = Channels.newChannel(bout);
    while (channel.read(byteBuffer) > 0 || byteBuffer.position() > 0) {
        byteBuffer.flip();  //make buffer ready for write
        outChannel.write(byteBuffer);
        byteBuffer.compact(); //make buffer ready for reading
    }
    channel.close();
    outChannel.close();
    return bout.toString(encoding);
}

这是一个如何使用它的示例：

try (InputStream in = new FileInputStream("/tmp/large_file.xml")) {
    String x = streamToStringChannel(in, "UTF-8", 1);
    System.out.println(x);
}

这种方法的性能对于大文件应该是好的。

Answer 52

此代码段位于 \\sdk\\samples\\android-19\\connectivity\\NetworkConnect\\NetworkConnectSample\\src\\main\\java\\com\\example\\android\\networkconnect\\MainActivity.java 中，该代码已获得 Apache 许可，版本 2.0 并由 Google 编写.

/** Reads an InputStream and converts it to a String.
 * @param stream InputStream containing HTML from targeted site.
 * @param len Length of string that this method returns.
 * @return String concatenated according to len parameter.
 * @throws java.io.IOException
 * @throws java.io.UnsupportedEncodingException
 */
private String readIt(InputStream stream, int len) throws IOException, UnsupportedEncodingException {
    Reader reader = null;
    reader = new InputStreamReader(stream, "UTF-8");
    char[] buffer = new char[len];
    reader.read(buffer);
    return new String(buffer);
}

Answer 53

将 inputStream 转换为 String 的方法

public static String getStringFromInputStream(InputStream inputStream) {

    BufferedReader bufferedReader = null;
    StringBuilder stringBuilder = new StringBuilder();
    String line;

    try {
        bufferedReader = new BufferedReader(new InputStreamReader(
                inputStream));
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line);
        }
    } catch (IOException e) {
        logger.error(e.getMessage());
    } finally {
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                logger.error(e.getMessage());
            }
        }
    }
    return stringBuilder.toString();
}

Answer 54

InputStream  inputStream = null;
BufferedReader bufferedReader = null;
try {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    String stringBuilder = new StringBuilder();
    String content;
    while((content = bufferedReader.readLine()) != null){
        stringBuilder.append(content);
    }
    System.out.println("content of file::" + stringBuilder.toString());
}
catch (IOException e) {
            e.printStackTrace();
        }finally{           
            if(bufferedReader != null){
                try{
                    bufferedReader.close();
                }catch(IoException ex){
                   ex.printStackTrace();
            }

Answer 55

您也可以从指定的资源路径获取 InputStream：

public static InputStream getResourceAsStream(String path)
{
    InputStream myiInputStream = ClassName.class.getResourceAsStream(path);
    if (null == myiInputStream)
    {
        mylogger.info("Can't find path = ", path);
    }

    return myiInputStream;
}

要从特定路径获取 InputStream：

public static URL getResource(String path)
{
    URL myURL = ClassName.class.getResource(path);
    if (null == myURL)
    {
        mylogger.info("Can't find resource path = ", path);
    }
    return myURL;
}

Answer 56

我建议使用StringWriter类来解决这个问题。

StringWriter wt= new StringWriter();
IOUtils.copy(inputStream, wt, encoding);
String st= wt.toString();

Answer 57

最简单的方法，一个班轮

 public static void main(String... args) throws IOException {
        System.out.println(new String(Files.readAllBytes(Paths.get("csv.txt"))));
    }

Answer 58

我有 log4j 可用，所以我能够使用 org.apache.log4j.lf5.util.StreamUtils.getBytes 来获取字节，我能够使用 String ctor 将其转换为字符串

String result = new String(StreamUtils.getBytes(inputStream));

Answer 59

注意：这可能不是一个好主意。 此方法使用递归，因此会很快遇到StackOverflowError ：

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

Answer 60

Dont want anyone to waste time on reading such structured response

Just showing signature of get api method
getMyData(KeyValueObject<String, List<String>> input){} which returns List<KeyValueObject<String, String>>
where KVO is like this

public class KeyValueObject<T, K> {
  private T key;
  private K value;
}

to make a call from another api and reading response 

Response response = ClientBuilder.newClient()
                    .target("https:/something")
                    .request(MediaType.APPLICATION_JSON)
.put(Entity.json(new KeyValueObject<>()));

            if (response != null && response.getStatus() == 200) {
                @SuppressWarnings("unchecked")
                KeyValueObject<String, String>[] output= response.readEntity(KeyValueObject[].class);
                
            }

Answer 61

如果您需要编写 10 多行代码来读取该死的字符串，这绝对证明了 Java 作为一种语言是多么垃圾

Answer 62

  InputStream IS=new URL("http://www.petrol.si/api/gas_prices.json").openStream();   

  ByteArrayOutputStream BAOS=new ByteArrayOutputStream();
  IOUtils.copy(IS, BAOS);
  String d= new String(BAOS.toByteArray(),"UTF-8");           

System.out.println(d);

Answer 63

快捷方便：

String result = (String)new ObjectInputStream( inputStream ).readObject();