Conversione di array di byte in String (Java)

Sto scrivendo un'applicazione web in Google app Engine. Consente alle persone di modificare sostanzialmente il codice html che viene archiviato come .htmlfile nel blobstore.

Sto usando fetchData per restituire uno byte[]di tutti i caratteri nel file. Sto cercando di stampare su un html in modo che l'utente possa modificare il codice html. Tutto funziona alla grande!

Ecco il mio unico problema ora:

L'array di byte presenta alcuni problemi durante la riconversione in una stringa. Citazioni intelligenti e un paio di personaggi stanno uscendo con un aspetto funky. (? o simboli giapponesi, ecc.) In particolare, vedo diversi byte che hanno valori negativi che causano il problema.

Le virgolette intelligenti stanno tornando come -108e -109nell'array di byte. Perché questo e come posso decodificare i byte negativi per mostrare la codifica dei caratteri corretta?

L'array di byte contiene caratteri in una codifica speciale (che dovresti conoscere). Il modo per convertirlo in una stringa è:

String decoded = new String(bytes, "UTF-8");  // example for one encoding type

A proposito: i byte grezzi possono apparire come decimali negativi solo perché il tipo di dati java byteè firmato, copre l'intervallo da -128 a 127.

-109 = 0x93: Control Code "Set Transmit State"

Il valore (-109) è un carattere di controllo non stampabile in UNICODE. Quindi UTF-8 non è la codifica corretta per quel flusso di caratteri.

0x93in "Windows-1252" è la "citazione intelligente" che stai cercando, quindi il nome Java di quella codifica è "Cp1252". La riga successiva fornisce un codice di prova:

System.out.println(new String(new byte[]{-109}, "Cp1252")); 

Java 7 e versioni successive

Puoi anche passare la codifica desiderata al Stringcostruttore come Charsetcostante da StandardCharsets . Questo può essere più sicuro che passare la codifica come a String, come suggerito nelle altre risposte.

Ad esempio, per la codifica UTF-8

String bytesAsString = new String(bytes, StandardCharsets.UTF_8);

Puoi provare questo.

String s = new String(bytearray);

public class Main {

    /**
     * Example method for converting a byte to a String.
     */
    public void convertByteToString() {

        byte b = 65;

        //Using the static toString method of the Byte class
        System.out.println(Byte.toString(b));

        //Using simple concatenation with an empty String
        System.out.println(b + "");

        //Creating a byte array and passing it to the String constructor
        System.out.println(new String(new byte[] {b}));

    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        new Main().convertByteToString();
    }
}

Produzione

65
65
A

public static String readFile(String fn)   throws IOException 
{
    File f = new File(fn);

    byte[] buffer = new byte[(int)f.length()];
    FileInputStream is = new FileInputStream(fn);
    is.read(buffer);
    is.close();

    return  new String(buffer, "UTF-8"); // use desired encoding
}

suggerisco Arrays.toString(byte_array);

Dipende dal tuo scopo. Ad esempio, volevo salvare un array di byte esattamente come il formato che puoi vedere al momento del debug che è qualcosa del genere: [1, 2, 3]se vuoi salvare esattamente lo stesso valore senza convertire i byte in formato carattere, Arrays.toString (byte_array)fa questo. Ma se vuoi salvare caratteri invece di byte, dovresti usare String s = new String(byte_array). In questo caso, sè uguale all'equivalente di [1, 2, 3]in formato di carattere.

La risposta precedente di Andreas_D è buona. Aggiungerò solo che ovunque si visualizzi l'output ci saranno un font e una codifica dei caratteri e potrebbe non supportare alcuni caratteri.

Per capire se il problema è Java o il tuo display, procedi come segue:

    for(int i=0;i<str.length();i++) {
        char ch = str.charAt(i);
        System.out.println(i+" : "+ch+" "+Integer.toHexString(ch)+((ch=='\ufffd') ? " Unknown character" : ""));
    }

Java avrà mappato tutti i caratteri che non può comprendere in 0xfffd il carattere ufficiale per i caratteri sconosciuti. Se vedi un "?" nell'output, ma non è mappato a 0xfffd, il problema è il carattere o la codifica del display, non Java.