Jambu biji setara untuk IOUtils.toString (InputStream)

Apache Commons IO memiliki metode kemudahan yang bagus IOUtils.toString () untuk membaca InputStreamke sebuah String.

Karena saya mencoba beralih dari Apache Commons dan ke Guava : apakah ada padanannya di Guava? Saya melihat semua kelas dalam com.google.common.iopaket dan saya tidak dapat menemukan sesuatu yang sesederhana itu.

Sunting: Saya memahami dan menghargai masalah dengan charsets. Kebetulan saya tahu bahwa semua sumber saya dalam ASCII (ya, ASCII, bukan ANSI dll.), Jadi dalam kasus ini, pengkodean bukan masalah bagi saya.

Anda menyatakan dalam komentar Anda atas jawaban Calum yang akan Anda gunakan

CharStreams.toString(new InputStreamReader(supplier.get(), Charsets.UTF_8))

Kode ini bermasalah karena kelebihan beban CharStreams.toString(Readable)menyatakan:

Tidak menutup Readable.

Ini berarti Anda InputStreamReader, dan dengan ekstensi yang InputStreamdikembalikan oleh supplier.get(), tidak akan ditutup setelah kode ini selesai.

Sebaliknya, jika Anda memanfaatkan fakta bahwa Anda tampaknya sudah memiliki InputSupplier<InputStream>dan menggunakan kelebihan beban CharStreams.toString(InputSupplier<R extends Readable & Closeable>), toStringmetode ini akan menangani pembuatan dan penutupan Readeruntuk Anda.

Ini persis seperti yang disarankan Jon Skeet, kecuali bahwa sebenarnya tidak ada kelebihan beban CharStreams.newReaderSupplieryang membutuhkan InputStreammasukan ... Anda harus memberikannya InputSupplier:

InputSupplier<? extends InputStream> supplier = ...
InputSupplier<InputStreamReader> readerSupplier = 
    CharStreams.newReaderSupplier(supplier, Charsets.UTF_8);

// InputStream and Reader are both created and closed in this single call
String text = CharStreams.toString(readerSupplier);

Intinya InputSupplieradalah untuk membuat hidup Anda lebih mudah dengan mengizinkan Jambu untuk menangani bagian-bagian yang membutuhkan try-finallyblok jelek untuk memastikan bahwa sumber daya ditutup dengan benar.

Sunting: Secara pribadi, saya menemukan yang berikut (begitulah sebenarnya saya menulisnya, baru saja memecah langkah-langkah dalam kode di atas)

String text = CharStreams.toString(
    CharStreams.newReaderSupplier(supplier, Charsets.UTF_8));

menjadi jauh lebih verbose dari ini:

String text;
InputStreamReader reader = new InputStreamReader(supplier.get(), 
    Charsets.UTF_8);
boolean threw = true;
try {
  text = CharStreams.toString(reader);
  threw = false;
}
finally {
  Closeables.close(reader, threw);
}

Kurang lebih apa yang harus Anda tulis untuk menangani ini sendiri dengan benar.

Edit: Februari 2014

InputSupplierdan OutputSupplierdan metode yang menggunakannya sudah tidak digunakan lagi di Guava 16.0. Pengganti mereka ByteSource, CharSource, ByteSinkdan CharSink. Diberikan ByteSource, Anda sekarang bisa mendapatkan isinya Stringseperti ini:

ByteSource source = ...
String text = source.asCharSource(Charsets.UTF_8).read();

Jika Anda punya, ReadableAnda bisa menggunakan CharStreams.toString(Readable). Jadi, Anda mungkin dapat melakukan hal berikut:

String string = CharStreams.toString( new InputStreamReader( inputStream, "UTF-8" ) );

Memaksa Anda untuk menentukan himpunan karakter, yang menurut saya harus Anda lakukan.

UPDATE : Melihat ke belakang, saya tidak suka solusi lama saya. Selain itu sekarang sudah 2013 dan sekarang ada alternatif yang lebih baik untuk Java7. Jadi inilah yang saya gunakan sekarang:

InputStream fis = ...;
String text;
try (  InputStreamReader reader = new InputStreamReader(fis, Charsets.UTF_8)){
        text = CharStreams.toString(reader);
}

atau jika dengan InputSupplier

InputSupplier<InputStreamReader> spl = ...
try (  InputStreamReader reader = spl.getInput()){
        text = CharStreams.toString(reader);
    }

Hampir. Anda bisa menggunakan sesuatu seperti ini:

InputSupplier<InputStreamReader> readerSupplier = CharStreams.newReaderSupplier
    (streamSupplier, Charsets.UTF_8);
String text = CharStreams.toString(readerSupplier);

Secara pribadi saya tidak berpikir itu IOUtils.toString(InputStream)"bagus" - karena selalu menggunakan pengkodean default platform, yang hampir tidak pernah Anda inginkan. Ada kelebihan beban yang mengambil nama penyandian, tetapi menggunakan nama bukanlah ide yang bagus IMO. Itu sebabnya saya suka Charsets.*.

EDIT: Bukan berarti di atas membutuhkan InputSupplier<InputStream>sebagai streamSupplier. Jika Anda sudah memiliki streaming, Anda dapat menerapkannya dengan cukup mudah:

InputSupplier<InputStream> supplier = new InputSupplier<InputStream>() {
    @Override public InputStream getInput() {
        return stream;
    }
};

Pilihan lainnya adalah membaca byte dari Stream dan membuat String darinya:

new String(ByteStreams.toByteArray(inputStream))
new String(ByteStreams.toByteArray(inputStream), Charsets.UTF_8)

Ini bukan Jambu Biji 'murni', tapi sedikit lebih pendek.

Berdasarkan jawaban yang diterima, berikut adalah metode utilitas yang meniru perilaku IOUtils.toString()(dan versi yang kelebihan beban dengan charset, juga). Versi ini seharusnya aman, bukan?

public static String toString(final InputStream is) throws IOException{
    return toString(is, Charsets.UTF_8);
}


public static String toString(final InputStream is, final Charset cs)
throws IOException{
    Closeable closeMe = is;
    try{
        final InputStreamReader isr = new InputStreamReader(is, cs);
        closeMe = isr;
        return CharStreams.toString(isr);
    } finally{
        Closeables.closeQuietly(closeMe);
    }
}

Ada solusi penutupan otomatis yang jauh lebih pendek jika aliran input berasal dari resource classpath:

URL resource = classLoader.getResource(path);
byte[] bytes = Resources.toByteArray(resource);
String text = Resources.toString(resource, StandardCharsets.UTF_8);

Menggunakan Sumber Jambu Biji , terinspirasi oleh IOExplained .

EDIT (2015): Okio adalah abstraksi dan alat terbaik untuk I / O di Java / Android yang saya ketahui. Saya menggunakannya sepanjang waktu.

FWIW inilah yang saya gunakan.

Jika saya sudah memiliki aliran di tangan, maka:

final InputStream stream; // this is received from somewhere
String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return stream;
    }
}, Charsets.UTF_8));

Jika saya membuat aliran:

String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return <expression creating the stream>;
    }
}, Charsets.UTF_8));

Sebagai contoh konkret, saya bisa membaca aset file teks Android seperti ini:

final Context context = ...;
String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return context.getAssets().open("my_asset.txt");
    }
}, Charsets.UTF_8));

Untuk contoh konkret, berikut ini cara saya membaca aset file teks Android:

public static String getAssetContent(Context context, String file) {
    InputStreamReader reader = null;
    InputStream stream = null;
    String output = "";

    try {
        stream = context.getAssets().open(file);
        reader = new InputStreamReader(stream, Charsets.UTF_8);
        output = CharStreams.toString(reader);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (stream != null) {
            try {
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    return output;
}