Odpowiednik guawy dla IOUtils.toString (InputStream)

Apache Commons IO ma wygodną metodę IOUtils.toString () do odczytywania ciągu znakówInputStream .

Ponieważ próbuję odejść od Apache Commons i przenieść się do Guawy : czy istnieje odpowiednik w guawie? Przejrzałem wszystkie klasy w com.google.common.iopakiecie i nie mogłem znaleźć nic tak prostego.

Edycja: rozumiem i doceniam problemy z zestawami znaków. Tak się składa, że ​​wiem, że wszystkie moje źródła są w ASCII (tak, ASCII, nie ANSI itp.), Więc w tym przypadku kodowanie nie jest dla mnie problemem.

W swoim komentarzu do odpowiedzi Caluma stwierdziłeś, że zamierzasz użyć

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

Ten kod jest problematyczny, ponieważ przeciążenie CharStreams.toString(Readable)stwierdza:

Nie zamyka Readable.

Oznacza to, że Twoje InputStreamReaderi przez rozszerzenie InputStreamzwrócone przez supplier.get()nie zostaną zamknięte po zakończeniu tego kodu.

Jeśli, z drugiej strony, wykorzystasz fakt, że wydaje się, że masz już InputSupplier<InputStream>przeciążenie i wykorzystałeś jeCharStreams.toString(InputSupplier<R extends Readable & Closeable> ), toStringmetoda zajmie się zarówno utworzeniem, jak i zamknięciemReader .

To jest dokładnie to, co zasugerował Jon Skeet, z wyjątkiem tego, że w rzeczywistości nie ma żadnego przeciążenia, CharStreams.newReaderSupplierktóre pobiera InputStreamjako dane wejściowe ... musisz podać mu 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);

Punkt InputSupplier to, aby ułatwić sobie życie, umożliwiając guawie obsługę części, które wymagają brzydkiego try-finallybloku, aby zapewnić prawidłowe zamknięcie zasobów.

Edycja: Osobiście uważam, że następujące (tak naprawdę to napisałbym, po prostu rozbijały kroki w powyższym kodzie)

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

być znacznie mniej szczegółowym niż to:

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

To mniej więcej tyle, ile trzeba by napisać, żeby samemu sobie z tym poradzić.

Edycja: luty 2014

InputSuppliera OutputSuppliermetody, które ich używają, zostały uznane za przestarzałe w Guava 16.0. Ich zamienniki są ByteSource, CharSource, ByteSinki CharSink. Biorąc pod uwagę ByteSource, możesz teraz pobrać jego zawartość w następujący sposób String:

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

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 chyba i tak powinieneś zrobić.

AKTUALIZACJA : Patrząc wstecz, nie podoba mi się moje stare rozwiązanie. Poza tym jest rok 2013 i są dostępne lepsze alternatywy 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);
    }

Prawie. Możesz użyć czegoś takiego:

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

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

EDIT: Nie, że powyższe należy przedsięwziąć InputSupplier<InputStream>jak streamSupplier. Jeśli masz już strumień, możesz to łatwo zaimplementować:

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

Inną opcją jest odczytanie bajtów ze Stream i utworzenie z nich ciągu:

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

To nie jest „czysta” guawa, ale jest trochę krótsza.

Opierając się na zaakceptowanej odpowiedzi, oto metoda narzędziowa, która kpi z zachowania IOUtils.toString()(a także przeciążonej wersji z zestawem znaków). 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 autozamykania 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 guawy , zainspirowane IOExplained .

EDYCJA (2015): Okio to najlepsza abstrakcja i narzędzia do I / O w Javie / Androidzie, jakie znam. Używam go cały czas.

Oto czego używam FWIW.

Jeśli mam już 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ć zasób pliku tekstowego Androida w następujący 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));

Aby uzyskać konkretny przykład, oto jak mogę odczytać zasób pliku tekstowego 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;
}