如何在 Java 中将 InputStream 读取/转换为字符串？
Posted
技术标签:
【中文标题】如何在 Java 中将 InputStream 读取/转换为字符串？【英文标题】：How do I read / convert an InputStream into a String in Java? 【发布时间】：2010-09-23 11:47:50 【问题描述】：如果您有一个java.io.InputStream 对象，您应该如何处理该对象并生成一个String？
假设我有一个包含文本数据的InputStream，我想将其转换为String，例如我可以将其写入日志文件。
获取InputStream 并将其转换为String 的最简单方法是什么？
public String convertStreamToString(InputStream is)
// ???
【问题讨论】：
这能回答你的问题吗？ Scanner is skipping nextLine() after using next() or nextFoo()? 请记住，您需要考虑输入流的编码。系统默认值不一定总是你想要的。t 这些答案大部分是在 Java 9 之前编写的，但现在您可以使用 .readAllBytes 从 InputStream 获取字节数组。所以，简单的“new String(inputStream.readAllBytes())”使用 String 的 byte[] 构造函数。 【参考方案1】：最简单的方法，一个班轮
public static void main(String... args) throws IOException
System.out.println(new String(Files.readAllBytes(Paths.get("csv.txt"))));
【讨论】：
【参考方案2】：注意：这可能不是一个好主意。此方法使用递归，因此会很快达到***Error：
public String read (InputStream is)
byte next = is.read();
return next == -1 ? "" : next + read(is); // Recursive part: reads next byte recursively
【讨论】：
这不仅仅是一个糟糕的选择。如果输入流包含超过几百个字符，它将失败并返回***Error。
@StephenC 在我看来这是一个糟糕的选择
我同意。使用不起作用的方法是一个“糟糕的选择”（除了在微不足道的情况下）。但不是只是一个“糟糕的选择”。无论如何，我投反对票是因为这是错误的……而不是因为这是一个“糟糕的选择”。也因为你没有解释为什么不应该使用这种方法。
对于 Java 语言和实现，没有尾调用优化是经过深思熟虑的设计选择；见softwareengineering.stackexchange.com/questions/272061/…。它应该被视为 Java 所固有的。当然，所有现存的主流 Java 实现都是通用的……包括 android。
@parsecer 因为当 RAM 无法处理正在使用的内存时，它不会耗尽，而是在堆栈无法处理更多堆栈调用时死亡，这比任何一个数字都小得多合理的制度。【参考方案3】：
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);
【讨论】：
这实际上与问题有关 0.0 这是机器人回复吗？你最好调整你的算法。【参考方案4】：如果您需要将字符串转换为特定字符集 无需外部库 那么：
public String convertStreamToString(InputStream is) throws IOException
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();)
is.transferTo(baos);
return baos.toString(StandardCharsets.UTF_8);
【讨论】：
【参考方案5】：总结其他答案我发现了 11 种主要方法（见下文）。我写了一些性能测试（见下面的结果）：
将 InputStream 转换为 String 的方法：
使用IOUtils.toString (Apache Utils)
String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
使用CharStreams（番石榴）
String result = CharStreams.toString(new InputStreamReader(
inputStream, Charsets.UTF_8));
使用Scanner (JDK)
Scanner s = new Scanner(inputStream).useDelimiter("\\A");
String result = s.hasNext() ? s.next() : "";
使用 Stream API (Java 8)。 警告：此解决方案将不同的换行符（如\r\n）转换为\n。
String result = new BufferedReader(new InputStreamReader(inputStream))
.lines().collect(Collectors.joining("\n"));
使用并行流 API (Java 8)。 警告：此解决方案将不同的换行符（如\r\n）转换为\n。
String result = new BufferedReader(new InputStreamReader(inputStream))
.lines().parallel().collect(Collectors.joining("\n"));
使用InputStreamReader 和StringBuilder (JDK)
int bufferSize = 1024;
char[] buffer = new char[bufferSize];
StringBuilder out = new StringBuilder();
Reader in = new InputStreamReader(stream, StandardCharsets.UTF_8);
for (int numRead; (numRead = in.read(buffer, 0, buffer.length)) > 0; )
out.append(buffer, 0, numRead);
return out.toString();
使用 StringWriter 和 IOUtils.copy (Apache Commons)
StringWriter writer = new StringWriter();
IOUtils.copy(inputStream, writer, "UTF-8");
return writer.toString();
使用ByteArrayOutputStream 和inputStream.read (JDK)
ByteArrayOutputStream result = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
for (int length; (length = inputStream.read(buffer)) != -1; )
result.write(buffer, 0, length);
// StandardCharsets.UTF_8.name() > JDK 7
return result.toString("UTF-8");
使用BufferedReader (JDK)。 警告：此解决方案将不同的换行符（如\n\r）转换为line.separator 系统属性（例如，在Windows 中为“\r\n”）。
String newLine = System.getProperty("line.separator");
BufferedReader reader = new BufferedReader(
new InputStreamReader(inputStream));
StringBuilder result = new StringBuilder();
for (String line; (line = reader.readLine()) != null; )
if (result.length() > 0)
result.append(newLine);
result.append(line);
return result.toString();
使用BufferedInputStream 和ByteArrayOutputStream (JDK)
BufferedInputStream bis = new BufferedInputStream(inputStream);
ByteArrayOutputStream buf = new ByteArrayOutputStream();
for (int result = bis.read(); result != -1; result = bis.read())
buf.write((byte) result);
// StandardCharsets.UTF_8.name() > JDK 7
return buf.toString("UTF-8");
使用inputStream.read() 和StringBuilder (JDK)。 警告：此解决方案存在 Unicode 问题，例如俄语文本（仅适用于非 Unicode 文本）
StringBuilder sb = new StringBuilder();
for (int ch; (ch = inputStream.read()) != -1; )
sb.append((char) ch);
return sb.toString();
警告：
解决方案 4、5 和 9 将不同的换行符转换为一个。
解决方案 11 无法正确处理 Unicode 文本
性能测试
小String（长度=175）的性能测试，github中的url（模式=平均时间，系统=Linux，1343分最好）：
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），github中的url（模式=平均时间，系统=Linux，得分200715最好）的性能测试：
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
图表（性能测试取决于 Windows 7 系统中的输入流长度）
性能测试（平均时间）取决于 Windows 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
【讨论】：
干得好。在底部提供一个 tl;dr 总结可能很有用，即丢弃存在换行/ unicode 问题的解决方案，然后（在剩下的那些中）说有或没有外部库哪个最快。 这个答案好像不完整 我对自发布此答案以来添加的 Java 9InputStream.transferTo 和 Java 10 Reader.transferTo 解决方案感到好奇，因此我查看了链接代码并为它们添加了基准测试。我只测试了“大字符串”基准。 InputStream.transferTo 是所有测试过的解决方案中最快的，运行时间为 test8 在我的机器上运行的 60%。 Reader.transferTo 比 test8 慢，但比所有其他测试都快。也就是说，它在 95% 的时间内以 test1 运行，所以这并不是一个显着的改进。
我在对这篇文章的编辑中将所有 while 循环转换为 for 循环，以避免在循环之外使用未使用的变量污染命名空间。这是一个适用于大多数 Java 读取器/写入器循环的巧妙技巧。
使用 Java 9，您可以使用 .readAllBytes 从 InputStream 中获取字节数组。所以“new String(inputStream.readAllBytes())”使用String的byte[]构造函数工作。【参考方案6】：
为了完整起见，这里是 Java 9 解决方案：
public static String toString(InputStream input) throws IOException
return new String(input.readAllBytes(), StandardCharsets.UTF_8);
这使用了 Java 9 中添加的 readAllBytes 方法。
【讨论】：
我对这个 here 进行了基准测试，发现这是我机器上最快的解决方案，运行时间大约是第二快的基准测试解决方案的 60%。 >此方法阻塞，直到所有剩余字节都被读取并检测到流结束，或者抛出异常。【参考方案7】：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();
【讨论】：
【参考方案8】：此代码适用于新的 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;
【讨论】：
【参考方案9】：我已经创建了这段代码，它可以工作。不需要外部插件。
有一个转换器String 到Stream 和Stream 到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;
【讨论】：
【参考方案10】：这是最适合 Android 和任何其他 JVM 的纯 Java 解决方案。
这个解决方案效果非常好......它简单、快速，并且在大小流上都一样！ （参见上面的基准。No. 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;
【讨论】：
【参考方案11】：这个很好，因为：
它可以安全地处理字符集。 您可以控制读取缓冲区的大小。 您可以设置构建器的长度，它不必是精确值。 没有库依赖。 适用于 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);
【讨论】：
【参考方案12】：我建议使用 StringWriter 类来解决这个问题。
StringWriter wt= new StringWriter();
IOUtils.copy(inputStream, wt, encoding);
String st= wt.toString();
【讨论】：
IOUtils 有一个更简单的功能。【参考方案13】：我在这里对 14 个不同的答案进行了基准测试（很抱歉没有提供学分，但重复的太多了）。
结果非常令人惊讶。事实证明，Apache IOUtils 是最慢的，ByteArrayOutputStream 是最快的解决方案：
所以首先这里是最好的方法：
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);
20 个周期内 20 MB 随机字节的基准测试结果
以毫秒为单位的时间
ByteArrayOutputStreamTest：194 Niostream：198 Java9ISTransferTo：201 Java9ISReadAllBytes：205 BufferedInputStreamVsByteArrayOutputStream: 314 ApacheStringWriter2：574 GuavaCharStreams：589 ScannerReaderNoNextTest: 614 ScannerReader：633 ApacheStringWriter：1544 StreamApi：错误 ParallelStreamApi：错误 BufferReaderTest：错误 InputStreamAndStringBuilder：错误基准测试源代码
import com.google.common.io.CharStreams;
import org.apache.commons.io.IOUtils;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
/**
* Created by Ilya Gazman on 2/13/18.
*/
public class InputStreamToString
private static final String UTF_8 = "UTF-8";
public static void main(String... args)
log("App started");
byte[] bytes = new byte[1024 * 1024];
new Random().nextBytes(bytes);
log("Stream is ready\n");
try
test(bytes);
catch (IOException e)
e.printStackTrace();
private static void test(byte[] bytes) throws IOException
List<Stringify> tests = Arrays.asList(
new ApacheStringWriter(),
new ApacheStringWriter2(),
new NioStream(),
new ScannerReader(),
new ScannerReaderNoNextTest(),
new GuavaCharStreams(),
new StreamApi(),
new ParallelStreamApi(),
new ByteArrayOutputStreamTest(),
new BufferReaderTest(),
new BufferedInputStreamVsByteArrayOutputStream(),
new InputStreamAndStringBuilder(),
new Java9ISTransferTo(),
new Java9ISReadAllBytes()
);
String solution = new String(bytes, "UTF-8");
for (Stringify test : tests)
try (ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes))
String s = test.inputStreamToString(inputStream);
if (!s.equals(solution))
log(test.name() + ": Error");
continue;
long startTime = System.currentTimeMillis();
for (int i = 0; i < 20; i++)
try (ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes))
test.inputStreamToString(inputStream);
log(test.name() + ": " + (System.currentTimeMillis() - startTime));
private static void log(String message)
System.out.println(message);
interface Stringify
String inputStreamToString(InputStream inputStream) throws IOException;
default String name()
return this.getClass().getSimpleName();
static class ApacheStringWriter implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
StringWriter writer = new StringWriter();
IOUtils.copy(inputStream, writer, UTF_8);
return writer.toString();
static class ApacheStringWriter2 implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
return IOUtils.toString(inputStream, UTF_8);
static class NioStream implements Stringify
@Override
public String inputStreamToString(InputStream in) throws IOException
ReadableByteChannel channel = Channels.newChannel(in);
ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 16);
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(UTF_8);
static class ScannerReader implements Stringify
@Override
public String inputStreamToString(InputStream is) throws IOException
java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
return s.hasNext() ? s.next() : "";
static class ScannerReaderNoNextTest implements Stringify
@Override
public String inputStreamToString(InputStream is) throws IOException
java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
return s.next();
static class GuavaCharStreams implements Stringify
@Override
public String inputStreamToString(InputStream is) throws IOException
return CharStreams.toString(new InputStreamReader(
is, UTF_8));
static class StreamApi implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
return new BufferedReader(new InputStreamReader(inputStream))
.lines().collect(Collectors.joining("\n"));
static class ParallelStreamApi implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
return new BufferedReader(new InputStreamReader(inputStream)).lines()
.parallel().collect(Collectors.joining("\n"));
static class ByteArrayOutputStreamTest implements Stringify
@Override
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);
static class BufferReaderTest implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
String newLine = System.getProperty("line.separator");
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
StringBuilder result = new StringBuilder(UTF_8);
String line;
boolean flag = false;
while ((line = reader.readLine()) != null)
result.append(flag ? newLine : "").append(line);
flag = true;
return result.toString();
static class BufferedInputStreamVsByteArrayOutputStream implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
BufferedInputStream bis = new BufferedInputStream(inputStream);
ByteArrayOutputStream buf = new ByteArrayOutputStream();
int result = bis.read();
while (result != -1)
buf.write((byte) result);
result = bis.read();
return buf.toString(UTF_8);
static class InputStreamAndStringBuilder implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
int ch;
StringBuilder sb = new StringBuilder(UTF_8);
while ((ch = inputStream.read()) != -1)
sb.append((char) ch);
return sb.toString();
static class Java9ISTransferTo implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
ByteArrayOutputStream bos = new ByteArrayOutputStream();
inputStream.transferTo(bos);
return bos.toString(UTF_8);
static class Java9ISReadAllBytes implements Stringify
@Override
public String inputStreamToString(InputStream inputStream) throws IOException
return new String(inputStream.readAllBytes(), UTF_8);
【讨论】：
Making benchmarks in Java is not easy（尤其是因为 JIT）。看完 Benchmark 源码后，我深信上面这些数值并不准确，大家要慎重相信。 @Dalibor 您可能应该为您的主张提供更多理由，而不仅仅是一个链接。 我认为自己制定基准并不容易，这是众所周知的事实。对于那些不知道的人，有链接;） @Dalibor 我可能不是最好的，但我对 Java 基准测试有很好的理解，所以除非你能指出一个具体的问题，否则你只是在误导，我不会继续与你在这些条件下。 来自接受的答案：规则 0：阅读论文，它基本上警告不要尝试微基准测试。规则 1：你没有热身阶段。规则 2-3：你没有表明你使用了这些标志。规则 8：使用 JMH 之类的库。在 cmets 中有 135 票：不要使用System.currentTimeMillis()。继续其他高度投票的答案。 Jon Skeet：在迭代之间使用System.gc()，并运行足够长的时间来测量结果，以秒为单位，而不是毫秒。在单个 JVM 运行中混合测试是不好的，因为为一个测试完成的编译器优化会影响另一个。【参考方案14】：
也可以从指定的资源路径获取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;
【讨论】：
这不能回答问题。【参考方案15】：您可以使用 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));
【讨论】：
前两种方法有什么区别？【参考方案16】：嗯，你可以自己编程……并不复杂……
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();
【讨论】：
由于您在本地使用buffer 变量，并且没有机会在多个线程之间共享，您应该考虑将其类型更改为StringBuilder，以避免（无用的）同步的开销。跨度>
亚历克斯说得好！我认为我们都同意这种方法在很多方面都不是线程安全的。甚至输入流操作也不是线程安全的。
如果流包含跨越多行的 UTF-8 字符，该算法可以将字符一分为二，打断字符串。
@VladLifliand 一个 UTF-8 字符究竟是如何跨越多行的？根据定义，这是不可能的。你可能还有别的意思。
@ChristianHujer 他的意思可能是buffers 而不是lines。 UTF-8 代码点/字符可以是多字节的。【参考方案17】：
用途：
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();
【讨论】：
readLine() 删除换行符，因此生成的字符串将不包含换行符，除非您在添加到构建器的每一行之间添加行分隔符。【参考方案18】：
这里是只使用标准Java库的一种方式（注意流没有关闭，你的里程可能会有所不同）。
static String convertStreamToString(java.io.InputStream is)
java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
return s.hasNext() ? s.next() : "";
我从"Stupid Scanner tricks" 文章中学到了这个技巧。它起作用的原因是因为Scanner 迭代流中的标记，在这种情况下，我们使用“输入边界的开始” (\A) 分隔标记，因此只为流的全部内容提供了一个标记。
注意，如果您需要具体说明输入流的编码，您可以向Scanner 构造函数提供第二个参数，该参数指示要使用的字符集（例如“UTF-8”）。
帽子提示也送给Jacob，他曾经向我指出过上述文章。
【讨论】：
我们不应该在返回值之前关闭扫描仪吗？ @OlegMarkelov 可能。【参考方案19】：如果您不能使用 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);
或者，如果您想要原始速度，我会提出 Paul de Vrieze 建议的变体（避免使用 StringWriter（在内部使用 StringBuffer）：
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);
【讨论】：
【参考方案20】：用途：
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();
【讨论】：
【参考方案21】：Apache Commons 允许：
String myString = IOUtils.toString(myInputStream, "UTF-8");
当然，你可以选择除 UTF-8 之外的其他字符编码。
另见：(documentation)
【讨论】：
试图取回 InputStream，不工作***.com/q/66349701/3425489【参考方案22】：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，那么我会遵从已经存在的其他答案。
【讨论】：
【参考方案23】：就reduce和concat而言，在Java 8中可以表示为：
String fromFile = new BufferedReader(new
InputStreamReader(inputStream)).lines().reduce(String::concat).get();
【讨论】：
【参考方案24】：In Groovy
inputStream.getText()
【讨论】：
【参考方案25】：一个很好的方法是使用Apache commons@987654322@将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 和 Writer，也可以使用 ByteArrayOutputStream
【讨论】：
toString 是否被弃用？我看到IOUtils.convertStreamToString()
我添加了一个编辑以包含指向实际源代码本身的可搜索链接作为参考。我相信这为那些想了解该命令如何工作的人提供了更多答案。【参考方案26】：
与 Okio：
String result = Okio.buffer(Okio.source(inputStream)).readUtf8();
【讨论】：
【参考方案27】：基于the accepted Apache Commons answer 的第二部分，但填充了小间隙以始终关闭流：
String theString;
try
theString = IOUtils.toString(inputStream, encoding);
finally
IOUtils.closeQuietly(inputStream);
【讨论】：
请注意，根据我的benchmark results，此解决方案效率最低【参考方案28】：使用 Java 9 支持的 java.io.InputStream.transferTo(OutputStream) 和采用字符集名称的 ByteArrayOutputStream.toString(String)：
public static String gobble(InputStream in, String charsetName) throws IOException
ByteArrayOutputStream bos = new ByteArrayOutputStream();
in.transferTo(bos);
return bos.toString(charsetName);
【讨论】：
这应该是公认的答案【参考方案29】：这个问题的解决方案不是最简单的，但是由于没有提到 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);
这种方法的性能应该对大文件有好处。
【讨论】：
【参考方案30】：我进行了一些计时测试，因为时间总是很重要。
我尝试以 3 种不同的方式将响应转换为字符串。 （如下所示） 为了便于阅读，我省略了 try/catch 块。
为了给出上下文，这是所有 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%
这些方法中的任何一种都是获取响应并从中创建字符串的合适解决方案。
【讨论】：
以上是关于如何在 Java 中将 InputStream 读取/转换为字符串？的主要内容，如果未能解决你的问题，请参考以下文章
如何在 Java 中将 InputStream 读取/转换为字符串？
如何在 Java 中将 InputStream 读取/转换为字符串？
如何在 Java 中将 InputStream 读取/转换为字符串？
如何在 Java 中将 InputStream 转换为字符串？