io to string - ¿Cómo leer / convertir un InputStream en una cadena en Java?





15 Answers

Aquí hay una forma de usar solo la biblioteca estándar de Java (tenga en cuenta que la secuencia no está cerrada, YMMV).

static String convertStreamToString(java.io.InputStream is) {
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

Aprendí este truco del artículo "Trucos del escáner estúpido" . La razón por la que funciona es porque el Scanner itera sobre tokens en el flujo, y en este caso separamos los tokens utilizando el "inicio del límite de entrada" (\ A), por lo que nos da solo un token para todo el contenido del flujo.

Tenga en cuenta que si necesita ser específico acerca de la codificación de la secuencia de entrada, puede proporcionar el segundo argumento al constructor del Scanner que indica qué conjunto de caracteres debe usar (por ejemplo, "UTF-8").

La punta del sombrero también va a Jacob, quien una vez me señaló el artículo mencionado.

EDITADO: Gracias a una sugerencia de Patrick , hizo que la función fuera más robusta al manejar un flujo de entrada vacío. Una edición más: probada / atrapada, la manera de Patrick es más lacónica.

c# print console

Si tiene un objeto java.io.InputStream , ¿cómo debería procesar ese objeto y producir una String ?

Supongamos que tengo un InputStream que contiene datos de texto y quiero convertirlo en una String , así que, por ejemplo, puedo escribir eso en un archivo de registro.

¿Cuál es la forma más fácil de tomar InputStream y convertirlo en una String ?

public String convertStreamToString(InputStream is) { 
    // ???
}



Apache Commons permite:

String myString = IOUtils.toString(myInputStream, "UTF-8");

Por supuesto, puedes elegir otras codificaciones de caracteres además de UTF-8.

Véase también: ( Docs )




¿Qué tal esto?

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



Esta es mi solución pura de Java y Android, funciona bien ...

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



Aquí está la solución más elegante, pura de Java (sin biblioteca) que se me ocurrió después de algunos experimentos:

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



Usaría algunos trucos de 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.
    }
}

Esencialmente lo mismo que algunas otras respuestas excepto las más sucintas.




La solución Java pura usando Stream s, funciona desde Java 8.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

// ...
public static String inputStreamToString(InputStream is) throws IOException {
    try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
        return br.lines().collect(Collectors.joining(System.lineSeparator()));
    }
}

Como lo menciona Christoffer Hammarström debajo de otra respuesta , es más seguro especificar explícitamente el conjunto de Charset . Es decir, el constructor InputStreamReader se puede cambiar de la siguiente manera:

new InputStreamReader(is, Charset.forName("UTF-8"))



Aquí está más o menos la respuesta de Sampath, limpiado un poco y representado como una función:

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



Si no puede usar Commons IO (FileUtils / IOUtils / CopyUtils), aquí hay un ejemplo que utiliza un BufferedReader para leer el archivo línea por línea:

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

o si quieres una velocidad bruta, te propondría una variación de lo que sugirió Paul de Vrieze (que evita el uso de un StringWriter (que usa un StringBuffer internamente):

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



Asegúrate de cerrar las transmisiones al final si usas Stream Readers

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

EDITAR: En JDK 7+, puede usar la construcción 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();
    }
}



A continuación, se explica cómo hacerlo utilizando solo el JDK utilizando buffers de matrices de bytes. Así es como funcionan los IOUtils.copy()métodos commons-io . Puede reemplazar byte[]con char[]si está copiando desde un archivo en Readerlugar de un archivo InputStream.

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



Los usuarios de Kotlin simplemente hacen:

println(InputStreamReader(is).readText())

mientras

readText()

Es el método de extensión incorporado de la biblioteca estándar de Kotlin.




Este es bueno porque:

  • Seguridad de las manos el conjunto de caracteres.
  • Usted controla el tamaño del buffer de lectura.
  • Puede aprovisionar la longitud del constructor y no puede ser exactamente.
  • Está libre de dependencias de la biblioteca.
  • Es para Java 7 o superior.

¿Para qué?

public static String convertStreamToString(InputStream is) {
   if (is == null) return null;
   StringBuilder sb = new StringBuilder(2048); // Define a size if you have an idea of it.
   char[] read = new char[128]; // Your buffer size.
   try (InputStreamReader ir = new InputStreamReader(is, StandardCharsets.UTF_8)) {
     for (int i; -1 != (i = ir.read(read)); sb.append(read, 0, i));
   } catch (Throwable t) {}
   return sb.toString();
}



La forma más fácil en JDK es con los siguientes recortes de código.

String convertToString(InputStream in){
    String resource = new Scanner(in).useDelimiter("\\Z").next();
    return resource;
}



Nota: Esto probablemente no es una buena idea. Este método utiliza la recursión:

public String read (InputStream is) {
    byte next = is.read();
    return next == -1 ? "" : next + read(is); // Recursive part: reads next byte recursively
}

Por favor, no descargues esto solo porque es una mala elección de usar; esto fue en su mayoría creativo :)






Related