web-dev-qa-db-ja.com

JavaでInputStreamを読み込んでStringに変換する方法を教えてください。

Java.io.InputStreamオブジェクトがある場合、そのオブジェクトをどのように処理してStringを生成する必要がありますか？

テキストデータを含むInputStreamがあり、それをStringに変換したいとします。たとえば、それをログファイルに書き込むことができます。

InputStreamを取り、それをStringに変換する最も簡単な方法は何ですか？

public String convertStreamToString(InputStream is) {
    // ???
}
javastringiostreaminputstream
3650
Johnny Maelstrom

これを行う良い方法は、 Apacheコモン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を使用することもできます。

2228
Harry Lime

これは標準の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トリック」 の記事から学んだ。これが機能するのは、 Scanner がストリーム内のトークンに対して反復処理を行うためです。この場合は、 "入力境界の始まり"（\ A）を使用してトークンを分離します。ストリーム。

入力ストリームのエンコーディングについて詳しく知る必要がある場合は、Scannerコンストラクタに2番目の引数を指定して、使用する文字セットを指定できます（例： "UTF-8"）。

Hat tipは Jacob にも行きます。

2182
Pavel Repin

私がこれをする11の主な方法を見つけた他の答えを要約しなさい（下記参照）。そして私はいくつかの性能テストを書きました（下記の結果を見てください）：

InputStreamを文字列に変換する方法：

  1. IOUtils.toStringを使う（Apache Utils） 

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

  2. CharStreamsを使う（グアバ） 

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

  3. Scanner（JDK）を使う 

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

  4. Stream API を使用する（Java 8）。 警告 ：この解決策は、（\r\nのような）さまざまな改行を\nに変換します。

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

  5. パラレルストリームAPIを使用する （Java 8）。 警告 ：この解決策は、（\r\nのような）さまざまな改行を\nに変換します。 

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

  6. InputStreamReaderとStringBuilderを使用する（JDK） 

    final int bufferSize = 1024;
final char[] buffer = new char[bufferSize];
final StringBuilder out = new StringBuilder();
Reader in = new InputStreamReader(inputStream, "UTF-8");
for (; ; ) {
    int rsz = in.read(buffer, 0, buffer.length);
    if (rsz < 0)
        break;
    out.append(buffer, 0, rsz);
}
return out.toString();

  7. StringWriterとIOUtils.copyを使う（Apache Commons）

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

  8. ByteArrayOutputStreamと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. 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();
boolean flag = false;
for (String line; (line = reader.readLine()) != null; ) {
    result.append(flag? newLine: "").append(line);
    flag = true;
}
return result.toString();

  10. BufferedInputStreamとByteArrayOutputStreamを使用する（JDK） 

    BufferedInputStream bis = new BufferedInputStream(inputStream);
ByteArrayOutputStream buf = new ByteArrayOutputStream();
int result = bis.read();
while(result != -1) {
    buf.write((byte) result);
    result = bis.read();
}
// StandardCharsets.UTF_8.name() > JDK 7
return buf.toString("UTF-8");

  11. inputStream.read()とStringBuilder（JDK）を使う。 警告 ：この解決法は、ロシア語のテキストなど、Unicodeに問題があります（Unicode以外のテキストでのみ正しく機能します）。

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

警告 ：

  1. 解決策4、5、9は、異なる改行を1つに変換します。

  2. 解決策11はUnicodeテキストでは正しく機能しない

パフォーマンステスト

小さなString（長さ= 175）、 github のURL（モード=平均時間、システム= Linux、スコア1,343が最良）に対するパフォーマンステスト：

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

大きなString（長さ= 50100）、 github のURL（モード=平均時間、システム= Linux、スコア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

グラフ（Windows 7システムの入力ストリーム長に応じたパフォーマンステスト）
enter image description here

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
1964
Viacheslav Vedenin

Apache Commonsでは以下のことが可能です。

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

もちろん、UTF-8以外の他の文字エンコーディングを選択することもできます。

また見なさい：（ ドキュメンテーション ）

810
Chinnery

ファイルを考慮すると、まず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();
}
275
Paul de Vrieze

つかいます：

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

Google-Collections/Guavaを使用している場合は、次のことができます。

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

InputStreamReaderのための2番目のパラメータ（すなわちCharsets.UTF_8）は必要ではないことに注意してください、しかし、あなたがそれを知っているなら（それはあなたがそうするべきです！）エンコーディングを指定することは一般的に良い考えです。

163
Sakuraba

これは私の純粋なJavaとAndroidのソリューションです、そしてそれはうまく機能します...

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;
}
111
TacB0sS

これは私がいくつかの実験の後に思い付いた、最も洗練された、純粋な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();
}
57
Drew Noakes

つかいます：

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

完全を期すために、ここに Java 9 solutionとします。

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

readAllBytes は現在JDK 9メインコードベースに入っているので、リリースに現れるでしょう。 JDK 9スナップショットビルド を使って今すぐ試すことができます。

47
Tagir Valeev

私はいくつかの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.
    }
}

簡潔さを除けば、基本的に他のいくつかの答えと同じです。

35
Simon Kuang

私はここで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
  • Java9IST TransferTo：201
  • Java9ISReadAllBytes：205
  • BufferedInputStreamVsByteArrayOutputStream：314
  • ApacheStringWriter2：574
  • GuavaCharStreams：589
  • ScannerReaderNoNextTest：614
  • スキャナリーダー：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);
        }
    }

}
33
Ilya Gazman

時間が重要なので、私はいくつかのタイミングテストを実行しました。

私はレスポンスをString 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]アプローチ＃1
アプローチ＃3 - ＃1より2.6％遅い
アプローチ＃2 - ＃1よりも4.3％遅い

これらのアプローチはいずれも、応答を取得してそれからStringを作成するための適切なソリューションです。

29
Brett Holt

Stream sを使った純粋な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()));
    }
}

下記のChristofferHammarströmによって述べられているように その他の答え _は明示的に Charset を指定する方が安全です。すなわちInputStreamReaderコンストラクタは次のように変更できます。

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

これは多かれ少なかれ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();
}
23
TKH

冒険好きなら、ScalaとJavaを混ぜ合わせて、これで終わるでしょう。

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

JavaとScalaのコードとライブラリを混在させることには利点があります。

ここで完全な説明を見なさい： ScalaでInputStreamを文字列に変換する慣用的な方法

21
Jack

Commons IO（FileUtils/IOUtils/CopyUtils）を使用できない場合は、BufferedReaderを使用してファイルを1行ずつ読み取る例を示します。

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

これはorg.Apache.commons.io.IOUtilssource code から、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();
}
17
Dreaming in Code

ストリームリーダーを使用する場合は、最後にストリームを閉じるようにしてください。

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

編集：JDK 7以降では、try-with-resourcesコンストラクトを使用できます。

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

これは、サードパーティのライブラリを使用せずにInputStreamをStringに変換するための完全な方法です。シングルスレッド環境の場合はStringBuilderを使用し、それ以外の場合は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();
}
15
laksys

これは、バイト配列バッファを使用してJDKだけを使用してそれを行う方法です。これが実際にcommons-io IOUtils.copy()メソッドがすべてどのように機能するかです。 ReaderではなくInputStreamからコピーする場合は、byte[]をchar[]に置き換えることができます。

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);
14
Matt Shannon

もう1つ、すべての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);
}

org.springframework.util.StreamUtilsのユーティリティメソッドはFileCopyUtilsのものと似ていますが、完了するとストリームを開いたままにします。

12
James

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

Kotlinユーザーは単にこうします：

println(InputStreamReader(is).readText())

一方 

readText()

kotlin標準ライブラリに組み込まれている拡張方法です。

11
Alex

これはニースです。

  • 手の安全性はCharsetです。
  • 読み込みバッファサイズを制御します。
  • あなたはビルダーの長さをプロビジョニングすることができ、正確にはできません。
  • ライブラリの依存関係から解放されています。
  • Java 7以上用です。

何のために？ 

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

JDKで最も簡単な方法は、次のコードスニペットを使用することです。 

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

これは私の Java 8 ベースの解決策で、 new 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")));
}
6
Christian Rädel

Groovyの場合

inputStream.getText()
5
Snekse

reduceおよびconcatに関しては、Java 8では次のように表現できます。

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

私はちょうどそれをするクラスを書きました、それで私はそれを私がみんなと共有するだろうと考えました。場合によっては、Apache Commonsを1つだけに追加したくない場合や、コンテンツを調べない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);
        }
    }
}
4
Ben Barkay

の受け入れられているApache Commons答え - の2番目の部分に基づいて しかし常にストリームを閉じるための小さなギャップが埋められて

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

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で区切り文字を使用する方法を教えてください。

4
Halfacht

以下のコードは私のために働きました。 

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

エンコードの問題があるかどうかはわかりません。コードに問題がある場合はコメントしてください。

4
Anand N

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"));
4
Vadzim
public String read(InputStream in) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(in))) {
        return buffer.lines().collect(Collectors.joining("\n"));
    }
}
3
Hao Zheng

オキオと：

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

ストリームを閉じても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));
  }
}
3
Brian Pontarelli

あなたはApache Commonsを使うことができます。

IOUtilsには、3つの便利な実装を含む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));
}
3
Rys
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);
3
Vaishali Sutariya
InputStreamReader i = new InputStreamReader(s);
BufferedReader str = new BufferedReader(i);
String msg = str.readLine();
System.out.println(msg);

これはあなたのInputStreamオブジェクトで、これはStringに変換されます。 

3
Omkar Khot

これら4つのステートメントを試してください..

Fredが思い出した点によると、新しいStringが既存のcharに追加されるたびにStringが追加されるので、Stringに+=演算子を追加することはお勧めできません再び_ objectを使用し、そのアドレスを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;
}
3
JavaTechnical

まあ、あなたは自分でそれをプログラムすることができます...それは複雑ではないです...

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

以下は元の質問ではなく、いくつかの回答です。

いくつかの回答は、次の形式のループを示唆しています。

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

または

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

最初の形式は、forループの外側では使用されない変数 "read"を囲みスコープで宣言することによって、囲みスコープの名前空間を汚染します。 2番目の形式はreadline（）呼び出しを複製したものです。

これは、Javaでこの種のループを書くためのはるかにクリーンな方法です。 forループの最初の節には実際のイニシャライザ値は必要ありません。これにより、変数 "line"の有効範囲がforループの本体内に収まります。もっとエレガント！私は誰もこのフォームをどこかで使っているのを見たことがありません（一日前にランダムに発見しました）が、いつも使っています。

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

Cactoos を使えます。

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

UTF-8エンコーディングがデフォルトです。他に必要なものがあります。

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

注：これはおそらく良い考えではありません。このメソッドは再帰を使用しているため、StackOverflowErrorをすぐにヒットします。

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

これを使うのは悪い選択だからといって、これを控えめにしないでください。これはほとんどクリエイティブでした:)

2
HyperNeutrino

ISO-8859-1

入力ストリームのエンコーディングがISO-8859-1またはASCIIであることがわかっている場合は、これを行うための very /の実行方法があります。 （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のいずれかを使用してエンコードされているが、どちらが確実でないかについては、最後の方法と似た方法を使用できます。 auto-detect 文字列を返す前のエンコーディングに対する検出コンポーネント。

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でもないエンコーディングを持っているなら、私はすでに存在する他の答えに従う。

1
Hans Brende

つかいます：

String theString = IOUtils.toString(inputStream, encoding);
1
Avinash

この問題に対するこの解決策は最も単純ではありませんが、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);
}

このメソッドのパフォーマンスは、大きなファイルに適しています。

1
gil.fernandes
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();
            }
1
Harsh

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

この断片は、\ sdk\samples\Android-19\connectivity\NetworkConnect\NetworkConnectSample\src\main\Java\com\example\Android\networkconnect\MainActivity.Javaにあり、Apache License、Version 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);
}
1
Fred

String resultString = IOUtils.toString（userInputStream、 "UTF-8"）;

0
Akash

私はこのコードを作成しました、そしてそれはうまくいきます。必要な外部プラグインはありません。

文字列からストリームへの変換とストリームから文字列への変換があります。

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;
    }
0
13hola

その問題には StringWriter クラスをお勧めします。

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

指定したリソースパスから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;
}
0
Ravi