Làm cách nào để đọc / chuyển đổi InputStream thành Chuỗi trong Java?

Nếu bạn có một java.io.InputStreamđối tượng, bạn nên xử lý đối tượng đó như thế nào và tạo ra một String?

Giả sử tôi có một InputStreamdữ liệu chứa dữ liệu văn bản và tôi muốn chuyển đổi nó thành a String, vì vậy, ví dụ tôi có thể ghi nó vào một tệp nhật ký.

Cách dễ nhất để lấy InputStreamvà chuyển đổi nó thành một là Stringgì?

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

Một cách hay để làm điều này là sử dụng Apache commons IOUtils để sao chép InputStreamvào một StringWriter... thứ gì đó như

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

hoặc thậm chí

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

Ngoài ra, bạn có thể sử dụng ByteArrayOutputStreamnếu bạn không muốn kết hợp Luồng và Nhà văn của mình

Tóm tắt các câu trả lời khác tôi tìm thấy 11 cách chính để làm điều này (xem bên dưới). Và tôi đã viết một số bài kiểm tra hiệu suất (xem kết quả bên dưới):

Các cách để chuyển đổi InputStream thành Chuỗi:

1. Sử dụng IOUtils.toString( Sử dụng Apache)

   String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);

2. Sử dụng CharStreams(ổi)

   String result = CharStreams.toString(new InputStreamReader(
         inputStream, Charsets.UTF_8));

3. Sử dụng Scanner(JDK)

   Scanner s = new Scanner(inputStream).useDelimiter("\\A");
   String result = s.hasNext() ? s.next() : "";

4. Sử dụng API luồng (Java 8). Cảnh báo : Giải pháp này chuyển đổi các ngắt dòng khác nhau (như \r\n) thành \n.

   String result = new BufferedReader(new InputStreamReader(inputStream))
     .lines().collect(Collectors.joining("\n"));

5. Sử dụng API Stream song song (Java 8). Cảnh báo : Giải pháp này chuyển đổi các ngắt dòng khác nhau (như \r\n) thành \n.

   String result = new BufferedReader(new InputStreamReader(inputStream)).lines()
      .parallel().collect(Collectors.joining("\n"));

6. Sử dụng InputStreamReadervà StringBuilder(JDK)

   final int bufferSize = 1024;
   final char[] buffer = new char[bufferSize];
   final StringBuilder out = new StringBuilder();
   Reader in = new InputStreamReader(stream, StandardCharsets.UTF_8);
   int charsRead;
   while((charsRead = in.read(buffer, 0, buffer.length)) > 0) {
       out.append(buffer, 0, charsRead);
   }
   return out.toString();

7. Sử dụng StringWritervà IOUtils.copy(Apache Commons)

   StringWriter writer = new StringWriter();
   IOUtils.copy(inputStream, writer, "UTF-8");
   return writer.toString();

8. Sử dụng ByteArrayOutputStreamvà inputStream.read(JDK)

   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. Sử dụng BufferedReader(JDK). Cảnh báo: Giải pháp này chuyển đổi các ngắt dòng khác nhau (như \n\r) thành thuộc tính line.separatorhệ thống (ví dụ: trong Windows thành "\ r \ n").

   String newLine = System.getProperty("line.separator");
   BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
   StringBuilder result = new StringBuilder();
   boolean flag = false;
   for (String line; (line = reader.readLine()) != null; ) {
       result.append(flag? newLine: "").append(line);
       flag = true;
   }
   return result.toString();

10. Sử dụng BufferedInputStreamvà 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. Sử dụng inputStream.read()và StringBuilder(JDK). Cảnh báo : Giải pháp này có vấn đề với Unicode, ví dụ với văn bản tiếng Nga (chỉ hoạt động chính xác với văn bản không phải là Unicode)

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

Cảnh báo :

1. Giải pháp 4, 5 và 9 chuyển đổi các ngắt dòng khác nhau thành một.

2. Giải pháp 11 không thể hoạt động chính xác với văn bản Unicode

Kiểm tra hiệu năng

Các bài kiểm tra hiệu suất cho nhỏ String(chiều dài = 175), url trong github (chế độ = Thời gian trung bình, hệ thống = Linux, điểm số 1.343 là tốt nhất):

              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

Các bài kiểm tra hiệu năng cho big String(length = 50100), url trong github (mode = Average Time, system = Linux, điểm 200.715 là tốt nhất):

               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

Đồ thị (kiểm tra hiệu suất tùy thuộc vào độ dài Luồng đầu vào trong hệ thống Windows 7)

Kiểm tra hiệu suất (Thời gian trung bình) tùy thuộc vào độ dài Luồng đầu vào trong hệ thống 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

Đây là một cách chỉ sử dụng thư viện Java tiêu chuẩn (lưu ý rằng luồng không bị đóng, số dặm của bạn có thể thay đổi).

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

Tôi đã học được mẹo này từ bài viết "Thủ thuật quét ngu ngốc" . Lý do nó hoạt động là vì Máy quét lặp lại các mã thông báo trong luồng và trong trường hợp này, chúng tôi tách các mã thông báo bằng cách sử dụng "bắt đầu ranh giới đầu vào" (\ A), do đó chỉ cung cấp cho chúng tôi một mã thông báo cho toàn bộ nội dung của luồng.

Lưu ý, nếu bạn cần cụ thể về mã hóa của luồng đầu vào, bạn có thể cung cấp đối số thứ hai cho hàm Scannertạo cho biết ký tự nào được sử dụng (ví dụ: "UTF-8").

Hat tip cũng đi đến Jacob , người đã từng chỉ cho tôi bài báo nói.

Apache Commons cho phép:

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

Tất nhiên, bạn có thể chọn mã hóa ký tự khác ngoài UTF-8.

Cũng xem: ( tài liệu )

Đưa vào tài khoản tập tin đầu tiên nên có một java.io.Readerví dụ. Điều này sau đó có thể được đọc và thêm vào một StringBuilder(chúng tôi không cần StringBuffernếu chúng tôi không truy cập nó trong nhiều luồng và StringBuildernhanh hơn). Mẹo ở đây là chúng ta làm việc theo khối và vì thế không cần các luồng đệm khác. Kích thước khối được tham số hóa để tối ưu hóa hiệu suất thời gian chạy.

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

Sử dụng:

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

Nếu bạn đang sử dụng Google-Bộ sưu tập / Quả ổi, bạn có thể làm như sau:

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

Lưu ý rằng tham số thứ hai (ví dụ Charsets.UTF_8) InputStreamReaderkhông cần thiết, nhưng nói chung nên xác định mã hóa nếu bạn biết (bạn nên biết điều đó!)

Đây là giải pháp Java thuần túy tốt nhất phù hợp hoàn hảo cho Android và bất kỳ JVM nào khác.

Giải pháp này hoạt động rất tốt ... nó đơn giản, nhanh chóng và hoạt động trên các luồng nhỏ và lớn giống nhau !! (xem điểm chuẩn ở trên .. số 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;
}

Để hoàn thiện ở đây là giải pháp Java 9 :

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

Hiện readAllBytestại trong cơ sở mã chính của JDK 9, vì vậy nó có khả năng xuất hiện trong bản phát hành. Bạn có thể thử nó ngay bây giờ bằng cách sử dụng các bản dựng ảnh chụp nhanh JDK 9 .

Sử dụng:

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

Đây là giải pháp Java thuần túy (không có thư viện) thanh lịch nhất mà tôi đã nghĩ ra sau một số thử nghiệm:

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

Tôi đã làm một điểm chuẩn trên 14 câu trả lời khác nhau ở đây (xin lỗi vì không cung cấp tín dụng nhưng có quá nhiều bản sao).

Kết quả rất đáng ngạc nhiên. Hóa ra Apache IOUtils là chậm nhất và ByteArrayOutputStreamlà giải pháp nhanh nhất:

Vì vậy, đầu tiên ở đây là phương pháp tốt nhất:

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

Kết quả điểm chuẩn, 20 byte ngẫu nhiên trong 20 chu kỳ

Thời gian tính bằng mili giây

• ByteArrayOutputStreamTest: 194
• NioStream: 198
• Java9ISTransferTo: 201
• Java9ISRead ALLBytes: 205
• BufferedInputStreamVsByteArrayOutputStream: 314
• ApacheStringWriter2: 574
• Quả ổiCharStreams: 589
• Máy quétReaderNextTest: 614
• Máy quét: 633
• ApacheStringWriter: 1544
• StreamApi: Lỗi
• ParallelStreamApi: Lỗi
• BufferReaderTest: Lỗi
• InputStreamAndStringBuilder: Lỗi

Mã nguồn chuẩn

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

}

Tôi sẽ sử dụng một số thủ thuật 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.
    }
}

Về cơ bản giống như một số câu trả lời khác ngoại trừ cô đọng hơn.

Tôi đã chạy một số bài kiểm tra thời gian bởi vì vấn đề thời gian, luôn luôn.

Tôi đã cố gắng để có được phản hồi vào Chuỗi 3 cách khác nhau. (hiển thị bên dưới)
Tôi bỏ qua các khối thử / bắt vì tính dễ đọc.

Để đưa ra bối cảnh, đây là mã trước cho cả 3 cách tiếp cận:

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

Vì vậy, sau khi chạy 500 thử nghiệm trên mỗi phương pháp với cùng một dữ liệu yêu cầu / phản hồi, đây là những con số. Một lần nữa, đây là những phát hiện của tôi và những phát hiện của bạn có thể không hoàn toàn giống nhau, nhưng tôi đã viết điều này để đưa ra một số dấu hiệu cho những người khác về sự khác biệt hiệu quả của các phương pháp này.

Xếp hạng:
Cách tiếp cận số 1
Cách tiếp cận số 3 - chậm hơn 2,6% so với
cách tiếp cận số 1 - chậm hơn 4,3% so với cách tiếp cận số 1

Bất kỳ cách tiếp cận nào trong số này là một giải pháp thích hợp để lấy phản hồi và tạo Chuỗi từ nó.

Giải pháp Java thuần túy sử dụng Stream s, hoạt động kể từ 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()));
    }
}

Như được đề cập bởi Christoffer Hammarström bên dưới câu trả lời khác , sẽ an toàn hơn khi chỉ định rõ ràng Bộ ký tự . Tức là hàm tạo InputStreamReader có thể thay đổi như sau:

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

Đây là câu trả lời ít nhiều của sampath, làm sạch một chút và được biểu diễn dưới dạng hàm:

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

Nếu bạn cảm thấy phiêu lưu, bạn có thể kết hợp Scala và Java và kết thúc với điều này:

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

Trộn mã Java và Scala và các thư viện có lợi ích của nó.

Xem mô tả đầy đủ tại đây: Cách thành ngữ để chuyển đổi InputStream thành Chuỗi trong Scala

Nếu bạn không thể sử dụng Commons IO (FileUtils / IOUtils / CopyUtils), thì đây là một ví dụ sử dụng BufferedReader để đọc từng dòng tệp:

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

Hoặc nếu bạn muốn tốc độ thô, tôi sẽ đề xuất một biến thể về những gì Paul de Vrieze đã đề xuất (tránh sử dụng StringWriter (sử dụng StringBuffer bên trong):

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

Điều này là tốt đẹp bởi vì:

• Nó xử lý Charset một cách an toàn.
• Bạn kiểm soát kích thước bộ đệm đọc.
• Bạn có thể cung cấp độ dài của trình tạo và nó không phải là một giá trị chính xác.
• Được miễn phí từ phụ thuộc thư viện.
• Dành cho Java 7 trở lên.

Làm thế nào để làm nó?

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

Dành cho JDK 9

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

Đây là một câu trả lời được điều chỉnh từ org.apache.commons.io.IOUtils mã nguồn , dành cho những người muốn thực hiện apache nhưng không muốn toàn bộ thư viện.

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

Đảm bảo đóng luồng cuối nếu bạn sử dụng Trình đọc luồng

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: Trên JDK 7+, bạn có thể sử dụng cấu trúc try-with-resource.

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

Một số khác, cho tất cả người dùng 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);
}

Các phương thức tiện ích org.springframework.util.StreamUtilstương tự như các phương thức trong FileCopyUtils, nhưng chúng để luồng mở khi hoàn thành.

Sử dụng java.io.InputStream.transferTo (OutputStream) được hỗ trợ trong Java 9 và ByteArrayOutputStream.toString (Chuỗi) có tên bộ ký tự:

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

Đây là phương pháp hoàn chỉnh để chuyển đổi InputStreamthành Stringmà không cần sử dụng bất kỳ thư viện bên thứ ba nào. Sử dụng StringBuildercho môi trường đơn luồng nếu không sử dụng 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();
}

Đây là cách thực hiện bằng cách chỉ sử dụng JDK bằng cách sử dụng bộ đệm mảng byte. Đây thực sự là cách các IOUtils.copy()phương thức commons-io hoạt động. Bạn có thể thay thế byte[]bằng char[]nếu bạn đang sao chép từ một Readerthay vì 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);

Người dùng Kotlin chỉ cần làm:

println(InputStreamReader(is).readText())

trong khi

readText()

là phương pháp mở rộng tích hợp của thư viện tiêu chuẩn Kotlin.

Cách dễ nhất trong JDK là với các đoạn mã sau.

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

Đây là giải pháp dựa trên Java 8 của tôi , sử dụng API Stream mới để thu thập tất cả các dòng từ một InputStream:

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

Về mặt reducevà concatnó có thể được biểu thị trong Java 8 như:

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

Câu trả lời JDK 7/8 đóng luồng và vẫn ném 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));
  }
}