Ekwiwalent guawy dla juty.toString(InputStream)

Jeśli masz Readable możesz użyć CharStreams.toString(Readable). Więc prawdopodobnie możesz wykonać następujące czynności:

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

Zmusza cię do określenia zestawu znaków, co I tak powinieneś robić.

Prawie. Przydałoby się coś takiego:

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

Osobiście ja nie uważam, że IOUtils.toString(InputStream) jest "ładny" - ponieważ zawsze używa domyślnego kodowania platformy, co prawie nigdy nie jest tym, czego chcesz. Jest przeciążenie, które przyjmuje nazwę kodowania, ale używanie nazw nie jest dobrym pomysłem IMO. Dlatego lubię Charsets.*.

EDIT: Nie, żeby powyższe wymagało InputSupplier<InputStream> jako streamSupplier. Jeśli masz już strumień, możesz to łatwo zaimplementować chociaż:

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

UPDATE : patrząc wstecz, nie podoba mi się moje stare rozwiązanie. Poza tym jest 2013 teraz i są lepsze alternatywy dostępne teraz dla Java7. Oto, czego teraz używam:

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

Lub jeśli z InputSupplier

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

Inną opcją jest odczyt bajtów ze strumienia i utworzenie z nich ciągu znaków:

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

W oparciu o zaakceptowaną odpowiedź, oto metoda użytkowa, która wyśmiewa zachowanie IOUtils.toString() (i przeciążoną wersję z charset, jak również). Ta wersja powinna być bezpieczna, prawda?

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

Istnieje znacznie krótsze rozwiązanie autoklozujące w przypadku, gdy strumień wejściowy pochodzi z zasobu classpath:

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

Wykorzystuje zasoby Guava , inspirowane IOExplained .

Edytuj (2015): Okio {[7] } jest najlepszą abstrakcją i narzędziami do I/O w Javie / Android, jakie znam. Używam go cały czas.

FWIW oto czego używam.

Jeśli już mam strumień w ręku, to:

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

Jeśli tworzę strumień:

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

Jako konkretny przykład mogę odczytać plik tekstowy Androida w taki sposób:

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

Dla konkretnego przykładu, Oto Jak mogę odczytać plik tekstowy Androida:

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