オブジェクトがあるjava.io.InputStream場合、そのオブジェクトをどのように処理して生成する必要がありますStringか？
テキストデータを含むがあり、InputStreamそれをに変換したいとしStringます。たとえば、それをログファイルに書き込むことができます。
InputStreamを取得してに変換する最も簡単な方法は何Stringですか？
public String convertStreamToString(InputStream is) {
// ???
}
これを行うための11の主な方法を見つけました（以下を参照）。そして、いくつかのパフォーマンス テストを作成しました (以下の結果を参照)。
InputStream を String に変換する方法:
使用IOUtils.toString(Apache ユーティリティ)
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() : "";
ストリーム 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 は、異なる改行を 1 つに変換します。
解決策 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 システムの入力ストリームの長さに応じたパフォーマンス テスト)
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
これを行うための良い方法は、Apacheコモンズ を使用して...のようなものIOUtilsにコピーすることです。InputStreamStringWriter
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);
ByteArrayOutputStreamまたは、ストリームとライターを混在させたくない場合に使用できます
標準 Java ライブラリのみを使用する方法を次に示します (ストリームは閉じられていないことに注意してください。マイレージは異なる場合があります)。
static String convertStreamToString(java.io.InputStream is) {
java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
return s.hasNext() ? s.next() : "";
}
このトリックは、 「愚かなスキャナーのトリック」の記事から学びました。これが機能する理由は、Scannerがストリーム内のトークンを反復するためです。この場合、「入力境界の開始」(\A) を使用してトークンを分離し、ストリームのコンテンツ全体に対して 1 つのトークンのみを提供します。
入力ストリームのエンコーディングを特定する必要がある場合は、Scanner使用する文字セットを示す 2 番目の引数をコンストラクターに指定できます (例: "UTF-8")。
ハットチップは、かつて私に上記の記事を指摘してくれたジェイコブにも行きます。
Apache Commonsでは、次のことが可能です。
String myString = IOUtils.toString(myInputStream, "UTF-8");
もちろん、UTF-8以外の文字エンコードを選択することもできます。
参照:(ドキュメント）
ファイルを考慮して、最初にjava.io.Readerインスタンスを取得する必要があります。次に、これを読み取って a に追加できます(複数のスレッドでアクセスしていない場合はStringBuilder必要なく、高速です)。ここでの秘訣は、ブロックで作業するため、他のバッファリング ストリームを必要としないことです。ブロック サイズは、実行時のパフォーマンスを最適化するためにパラメーター化されます。StringBufferStringBuilder
public static String slurp(final InputStream is, final int bufferSize) {
final char[] buffer = new char[bufferSize];
final StringBuilder out = new StringBuilder();
try (Reader in = new InputStreamReader(is, "UTF-8")) {
for (;;) {
int rsz = in.read(buffer, 0, buffer.length);
if (rsz < 0)
break;
out.append(buffer, 0, rsz);
}
}
catch (UnsupportedEncodingException ex) {
/* ... */
}
catch (IOException ex) {
/* ... */
}
return out.toString();
}
使用する：
InputStream in = /* Your InputStream */;
StringBuilder sb = new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String read;
while ((read=br.readLine()) != null) {
//System.out.println(read);
sb.append(read);
}
br.close();
return sb.toString();
Google-Collections/Guava を使用している場合は、次のことができます。
InputStream stream = ...
String content = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
Closeables.closeQuietly(stream);
の 2 番目のパラメーター (つまり、Charsets.UTF_8)InputStreamReaderは必須ではありませんが、一般的には、エンコーディングがわかっている場合は指定することをお勧めします (そうするべきです!)。
これは、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;
}
使用する：
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();
}
これが私がいくつかの実験の後に思いついた最もエレガントで純粋な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();
}
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.
}
}
より簡潔であることを除いて、本質的に他の回答と同じです。
時間は常に重要であるため、いくつかのタイミング テストを実行しました。
レスポンスを 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
アプローチ #3 - #1 より 2.6% 遅い
アプローチ #2 - #1 より 4.3% 遅い
これらのアプローチはいずれも、応答を取得してそこから文字列を作成するための適切なソリューションです。
これは多かれ少なかれ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();
}
冒険好きなら、Scala と Java を混ぜて、次のようにすることもできます。
scala.io.Source.fromInputStream(is).mkString("")
Java と Scala のコードとライブラリを混在させることには利点があります。
ここで完全な説明を参照してください: Scala で InputStream を文字列に変換する慣用的な方法
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);
}
}
ストリーム リーダーを使用する場合は、最後にストリームを閉じてください。
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();
}
}
もう 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が、終了後もストリームを開いたままにします。
これは、サードパーティのライブラリを使用せずに変換InputStreamするための完全な方法です。シングル スレッド環境に使用します。それ以外の場合は を使用しStringます。 StringBuilderStringBuffer
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();
}
バイト配列バッファを使用してJDKだけを使用してそれを行う方法は次のとおりです。これは、実際に commons-ioIOUtils.copy()メソッドがすべて機能する方法です。の代わりにからコピーする場合は、byte[]に置き換えることができます。char[]ReaderInputStream
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);
The easiest way in JDK is with the following code snipplets.
String convertToString(InputStream in){
String resource = new Scanner(in).useDelimiter("\\Z").next();
return resource;
}
これは、新しい Stream APIを使用して からすべての行を収集する私のJava 8ベースのソリューションです。InputStream
public static String toString(InputStream inputStream) {
BufferedReader reader = new BufferedReader(
new InputStreamReader(inputStream));
return reader.lines().collect(Collectors.joining(
System.getProperty("line.separator")));
}
以下のコードは私のために働いた。
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);
available()Javaのドキュメントによると、このメソッドはでは機能しない可能性があります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);
エンコーディングの問題があるかどうかはわかりません。コードに問題がある場合は、コメントしてください。
私はまさにそれを行うクラスを書いたので、それをみんなと共有したいと思いました。ある目的のためだけに Apache Commons を追加したくない場合や、コンテンツを検査しない Scanner よりも馬鹿げたものが必要な場合があります。
使い方は以下の通り
// Read from InputStream
String data = new ReaderSink(inputStream, Charset.forName("UTF-8")).drain();
// Read from File
data = new ReaderSink(file, Charset.forName("UTF-8")).drain();
// Drain input stream to console
new ReaderSink(inputStream, Charset.forName("UTF-8")).drainTo(System.out);
ReaderSink のコードは次のとおりです。
import java.io.*;
import java.nio.charset.Charset;
/**
* A simple sink class that drains a {@link Reader} to a {@link String} or
* to a {@link Writer}.
*
* @author Ben Barkay
* @version 2/20/2014
*/
public class ReaderSink {
/**
* The default buffer size to use if no buffer size was specified.
*/
public static final int DEFAULT_BUFFER_SIZE = 1024;
/**
* The {@link Reader} that will be drained.
*/
private final Reader in;
/**
* Constructs a new {@code ReaderSink} for the specified file and charset.
* @param file The file to read from.
* @param charset The charset to use.
* @throws FileNotFoundException If the file was not found on the filesystem.
*/
public ReaderSink(File file, Charset charset) throws FileNotFoundException {
this(new FileInputStream(file), charset);
}
/**
* Constructs a new {@code ReaderSink} for the specified {@link InputStream}.
* @param in The {@link InputStream} to drain.
* @param charset The charset to use.
*/
public ReaderSink(InputStream in, Charset charset) {
this(new InputStreamReader(in, charset));
}
/**
* Constructs a new {@code ReaderSink} for the specified {@link Reader}.
* @param in The reader to drain.
*/
public ReaderSink(Reader in) {
this.in = in;
}
/**
* Drains the data from the underlying {@link Reader}, returning a {@link String} containing
* all of the read information. This method will use {@link #DEFAULT_BUFFER_SIZE} for
* its buffer size.
* @return A {@link String} containing all of the information that was read.
*/
public String drain() throws IOException {
return drain(DEFAULT_BUFFER_SIZE);
}
/**
* Drains the data from the underlying {@link Reader}, returning a {@link String} containing
* all of the read information.
* @param bufferSize The size of the buffer to use when reading.
* @return A {@link String} containing all of the information that was read.
*/
public String drain(int bufferSize) throws IOException {
StringWriter stringWriter = new StringWriter();
drainTo(stringWriter, bufferSize);
return stringWriter.toString();
}
/**
* Drains the data from the underlying {@link Reader}, writing it to the
* specified {@link Writer}. This method will use {@link #DEFAULT_BUFFER_SIZE} for
* its buffer size.
* @param out The {@link Writer} to write to.
*/
public void drainTo(Writer out) throws IOException {
drainTo(out, DEFAULT_BUFFER_SIZE);
}
/**
* Drains the data from the underlying {@link Reader}, writing it to the
* specified {@link Writer}.
* @param out The {@link Writer} to write to.
* @param bufferSize The size of the buffer to use when reader.
*/
public void drainTo(Writer out, int bufferSize) throws IOException {
char[] buffer = new char[bufferSize];
int read;
while ((read = in.read(buffer)) > -1) {
out.write(buffer, 0, read);
}
}
}
まあ、自分でプログラムできます...複雑ではありません...
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();
}
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));
}
これらの4つのステートメントを試してください..
Fred が思い出したポイントによると、Stringwith演算子を追加することはお勧めしません。なぜなら、新しいオブジェクトが既存のものに追加さ+=れるたびに、新しいオブジェクトが再度作成され、古いオブジェクトがガベージになる間、そのアドレスが割り当てられるからです。charStringStringstst
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;
}
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);
オキオと：
String result = Okio.buffer(Okio.source(inputStream)).readUtf8();
入力ストリームのエンコーディングが ISO-8859-1 または ASCII であることがわかっている場合、これを行う非常に効率的な方法を次に示します。StringWriter(1)の internalに存在する不要な同期を回避しStringBuffer、(2) のオーバーヘッドを回避し、 (3)の内部配列をコピーする必要がInputStreamReaderある回数を最小限に抑えます。StringBuilderchar
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 でエンコードされたストリームには、同じ一般的な戦略を使用できます。
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 でもない場合は、既に存在する他の回答に任せます。
サボテンを使用できます：
String text = new TextOf(inputStream).asString();
UTF-8 エンコーディングがデフォルトです。別のものが必要な場合:
String text = new TextOf(inputStream, "UTF-16").asString();
以下は元の質問ではなく、回答の一部です。
いくつかの応答は、フォームのループを示唆しています
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; ) {
//...
}
また、指定したリソース パスから 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;
}
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();
}
log4j が利用可能だったので、org.apache.log4j.lf5.util.StreamUtils.getBytes を使用してバイトを取得でき、String ctor を使用して文字列に変換できました。
String result = new String(StreamUtils.getBytes(inputStream));
早くて簡単：
String result = (String)new ObjectInputStream( inputStream ).readObject();