Guava équivalent pour IOUtils.toString (InputStream)

Apache Commons IO a une méthode pratique IOUtils.toString () pour lire un InputStreamdans une chaîne.

Puisque j'essaye de m'éloigner d'Apache Commons et de Guava : y a-t-il un équivalent dans Guava? J'ai regardé toutes les classes du com.google.common.iopackage et je n'ai rien trouvé d'aussi simple.

Edit: Je comprends et apprécie les problèmes avec les jeux de caractères. Il se trouve que je sais que toutes mes sources sont en ASCII (oui, ASCII, pas ANSI etc.), donc dans ce cas, l'encodage n'est pas un problème pour moi.

Vous avez déclaré dans votre commentaire sur la réponse de Calum que vous alliez utiliser

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

Ce code est problématique car les CharStreams.toString(Readable)états de surcharge :

Ne ferme pas le Readable.

Cela signifie que votre InputStreamReader, et par extension celui InputStreamrenvoyé par supplier.get(), ne sera pas fermé une fois ce code terminé.

Si, par contre, vous tirez parti du fait que vous semblez déjà avoir InputSupplier<InputStream>et utilisé la surcharge CharStreams.toString(InputSupplier<R extends Readable & Closeable>), la toStringméthode gérera à la fois la création et la fermeture de la Reader.

C'est exactement ce que Jon Skeet a suggéré, sauf qu'il n'y a en fait aucune surcharge de ce CharStreams.newReaderSupplierqui prend une InputStreamentrée ... vous devez lui donner un 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);

Le but InputSupplierest de vous faciliter la vie en permettant à Guava de gérer les pièces qui nécessitent un try-finallybloc laid pour s'assurer que les ressources sont correctement fermées.

Edit: Personnellement, je trouve ce qui suit (c'est ainsi que je l'écrirais, je décomposais simplement les étapes du code ci-dessus)

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

pour être beaucoup moins verbeux que cela:

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

C'est plus ou moins ce que vous auriez à écrire pour gérer cela correctement vous-même.

Edit: février 2014

InputSupplieret OutputSupplierles méthodes qui les utilisent sont devenues obsolètes dans Guava 16.0. Leurs remplaçants sont ByteSource, CharSource, ByteSinket CharSink. Étant donné a ByteSource, vous pouvez maintenant obtenir son contenu Stringcomme ceci:

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

Si vous en avez un, Readablevous pouvez utiliser CharStreams.toString(Readable). Vous pouvez donc probablement faire ce qui suit:

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

Vous oblige à spécifier un jeu de caractères, ce que je suppose que vous devriez faire de toute façon.

MISE À JOUR : Avec le recul, je n'aime pas mon ancienne solution. En outre, nous sommes maintenant en 2013 et il existe de meilleures alternatives disponibles maintenant pour Java7. Voici donc ce que j'utilise maintenant:

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

ou si avec InputSupplier

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

Presque. Vous pouvez utiliser quelque chose comme ceci:

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

Personnellement, je ne pense pas que ce IOUtils.toString(InputStream)soit "sympa" - car il utilise toujours l'encodage par défaut de la plate-forme, ce qui n'est presque jamais ce que vous voulez. Il y a une surcharge qui prend le nom de l'encodage, mais utiliser des noms n'est pas une bonne idée IMO. C'est pourquoi j'aime Charsets.*.

EDIT: Non pas que ce qui précède a besoin d'un InputSupplier<InputStream>comme le streamSupplier. Si vous avez déjà le flux, vous pouvez l'implémenter assez facilement:

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

Une autre option consiste à lire les octets de Stream et à créer une chaîne à partir d'eux:

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

Ce n'est pas de la goyave «pure», mais c'est un peu plus court.

Sur la base de la réponse acceptée, voici une méthode utilitaire qui se moque du comportement de IOUtils.toString()(et une version surchargée avec un jeu de caractères). Cette version devrait être sûre, non?

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

Il existe une solution de fermeture automatique beaucoup plus courte dans le cas où le flux d'entrée provient de la ressource classpath:

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

Utilise des ressources de goyave , inspirées par IOExplained .

EDIT (2015): Okio est la meilleure abstraction et les meilleurs outils d'E / S en Java / Android que je connaisse. Je l'utilise tout le temps.

FWIW voici ce que j'utilise.

Si j'ai déjà un flux en main, alors:

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

Si je crée un flux:

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

À titre d'exemple concret, je peux lire un fichier texte Android comme celui-ci:

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

Pour un exemple concret, voici comment lire un fichier texte 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;
}