UTF - 8 byte [] a cadena

La clase String de Java tiene un constructor integrado para convertir la matriz de bytes en string.

byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};

String value = new String(byteArray, "UTF-8");

Para convertir datos utf-8, no puede asumir una correspondencia 1-1 entre bytes y caracteres. Prueba esto:

String file_string = new String(bytes, "UTF-8");

(Bah. Veo que soy muy lento al presionar el botón Publicar Tu respuesta.)

Para leer un archivo completo como una cadena, haga algo como esto:

public String openFileToString(String fileName) throws IOException
{
    InputStream is = new BufferedInputStream(new FileInputStream(fileName));

    try {
        InputStreamReader rdr = new InputStreamReader(is, "UTF-8");
        StringBuilder contents = new StringBuilder();
        char[] buff = new char[4096];
        int len = rdr.read(buff);
        while (len >= 0) {
            contents.append(buff, 0, len);
        }
        return buff.toString();
    } finally {
        try {
            is.close();
        } catch (Exception e) {
            // log error in closing the file
        }
    }
}

Puedes usar el constructor String(byte[] bytes) para eso. Vea este enlace para más detalles. EDIT También debe considerar el conjunto de caracteres predeterminado de su plataforma según el documento de java:

Construye una nueva cadena decodificando la matriz de bytes especificada usando el conjunto de caracteres predeterminado de la plataforma. La longitud de la nueva cadena es una función del conjunto de caracteres, y por lo tanto puede no ser igual a la longitud de la matriz de bytes. El comportamiento de este constructor cuando los bytes dados no válido en el conjunto de caracteres predeterminado no está especificado. El CharsetDecoder se debe utilizar cuando más control sobre el se requiere un proceso de decodificación.

Puede usar los métodos descritos en esta pregunta (especialmente porque comienza con un flujo de entrada): Leer / convertir un flujo de entrada en una cadena

En particular, si no desea confiar en bibliotecas externas, puede probar esta respuesta , que lee el InputStream a través de un InputStreamReader en un búfer char[] y lo añade a un StringBuilder.

Aquí hay una función simplificada que leerá en bytes y creará una cadena. Asume que probablemente ya sabes en qué codificación está el archivo (y de lo contrario los valores predeterminados).

static final int BUFF_SIZE = 2048;
static final String DEFAULT_ENCODING = "utf-8";

public static String readFileToString(String filePath, String encoding) throws IOException {

    if (encoding == null || encoding.length() == 0)
        encoding = DEFAULT_ENCODING;

    StringBuffer content = new StringBuffer();

    FileInputStream fis = new FileInputStream(new File(filePath));
    byte[] buffer = new byte[BUFF_SIZE];

    int bytesRead = 0;
    while ((bytesRead = fis.read(buffer)) != -1)
        content.append(new String(buffer, 0, bytesRead, encoding));

    fis.close();        
    return content.toString();
}

String tiene un constructor que toma byte [] y charsetname como parámetros:)

Sabiendo que está tratando con una matriz de bytes UTF-8, definitivamente querrá usar el constructor de cadenas que acepta un nombre de conjunto de caracteres. De lo contrario, puede dejarse abierto a algunas vulnerabilidades de seguridad basadas en codificación de conjuntos de caracteres. Tenga en cuenta que lanza UnsupportedEncodingException que tendrás que manejar. Algo como esto:

public String openFileToString(String fileName) {
    String file_string;
    try {
        file_string = new String(_bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        // this should never happen because "UTF-8" is hard-coded.
        throw new IllegalStateException(e);
    }
    return file_string;
}

Esto también implica iterar, pero esto es mucho mejor que concatenar cadenas, ya que son muy, muy costosas.

public String openFileToString(String fileName)
{
    StringBuilder s = new StringBuilder(_bytes.length);

    for(int i = 0; i < _bytes.length; i++)
    {
        s.append((char)_bytes[i]);
    }

    return s.toString();    
}

¿Por qué no obtener lo que está buscando desde el principio y leer una cadena del archivo en lugar de una matriz de bytes? Algo como:

BufferedReader in = new BufferedReader(new InputStreamReader( new FileInputStream( "foo.txt"), Charset.forName( "UTF-8"));

Luego readLine desde adentro hasta que esté hecho.

Yo uso de esta manera

String strIn = new String(_bytes, 0, numBytes);