convertir - Convirtiendo UTF-8 a ISO-8859-1 en Java: cómo mantenerlo como un solo byte

convertir a utf8 java

Question

Estoy tratando de convertir una cadena codificada en java en UTF-8 a ISO-8859-1. Digamos, por ejemplo, en la cadena "âabcd '''' â ''se representa en ISO-8859-1 como E2. En UTF-8 se representa como dos bytes. C3 A2, creo. Cuando hago un getbytes (codificación) y luego creo una nueva cadena con los bytes en la codificación ISO-8859-1, obtengo dos caracteres diferentes. Ã ¢. ¿Hay alguna otra manera de hacer esto para mantener al personaje igual, es decir, ''abcd''?

Answer 1

Además de la respuesta de Adam Rosenfield, me gustaría añadir que ByteBuffer.array() devuelve la matriz de bytes subyacente del búfer, que no necesariamente se "recorta" hasta el último carácter. Se necesitará manipulación adicional, como las que se mencionan en this respuesta; en particular:

byte[] b = new byte[bb.remaining()]
bb.get(b);

Answer 2

Comenzando con un conjunto de bytes que codifica una cadena usando UTF-8, crea una cadena a partir de esos datos, luego obtenga algunos bytes que codifiquen la cadena en una codificación diferente:

    byte[] utf8bytes = { (byte)0xc3, (byte)0xa2, 0x61, 0x62, 0x63, 0x64 };
    Charset utf8charset = Charset.forName("UTF-8");
    Charset iso88591charset = Charset.forName("ISO-8859-1");

    String string = new String ( utf8bytes, utf8charset );

    System.out.println(string);

    // "When I do a getbytes(encoding) and "
    byte[] iso88591bytes = string.getBytes(iso88591charset);

    for ( byte b : iso88591bytes )
        System.out.printf("%02x ", b);

    System.out.println();

    // "then create a new string with the bytes in ISO-8859-1 encoding"
    String string2 = new String ( iso88591bytes, iso88591charset );

    // "I get a two different chars"
    System.out.println(string2);

esto envía cadenas y los iso88591 bytes correctamente:

âabcd 
e2 61 62 63 64 
âabcd

Por lo tanto, su matriz de bytes no estaba emparejada con la codificación correcta:

    String failString = new String ( utf8bytes, iso88591charset );

    System.out.println(failString);

Salidas

âabcd

(o bien, o simplemente escribió los bytes utf8 en un archivo y los leyó en otro lugar como iso88591)

Answer 3

Desalojar caracteres que no sean ISO-8859-1, se reemplazarán por ''?'' (antes de enviar a una base de datos ISO-8859-1 por ejemplo):

utf8String = new String (utf8String.getBytes (), "ISO-8859-1");

Answer 4

Esto es lo que necesitaba:

public static byte[] encode(byte[] arr, String fromCharsetName) {
    return encode(arr, Charset.forName(fromCharsetName), Charset.forName("UTF-8"));
}

public static byte[] encode(byte[] arr, String fromCharsetName, String targetCharsetName) {
    return encode(arr, Charset.forName(fromCharsetName), Charset.forName(targetCharsetName));
}

public static byte[] encode(byte[] arr, Charset sourceCharset, Charset targetCharset) {

    ByteBuffer inputBuffer = ByteBuffer.wrap( arr );

    CharBuffer data = sourceCharset.decode(inputBuffer);

    ByteBuffer outputBuffer = targetCharset.encode(data);
    byte[] outputData = outputBuffer.array();

    return outputData;
}

Answer 5

Para archivos que codifican ...

public class FRomUtf8ToIso {
        static File input = new File("C:/Users/admin/Desktop/pippo.txt");
        static File output = new File("C:/Users/admin/Desktop/ciccio.txt");


    public static void main(String[] args) throws IOException {

        BufferedReader br = null;

        FileWriter fileWriter = new FileWriter(output);
        try {

            String sCurrentLine;

            br = new BufferedReader(new FileReader( input ));

            int i= 0;
            while ((sCurrentLine = br.readLine()) != null) {
                byte[] isoB =  encode( sCurrentLine.getBytes() );
                fileWriter.write(new String(isoB, Charset.forName("ISO-8859-15") ) );
                fileWriter.write("/n");
                System.out.println( i++ );
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.flush();
                fileWriter.close();
                if (br != null)br.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }


    static byte[] encode(byte[] arr){
        Charset utf8charset = Charset.forName("UTF-8");
        Charset iso88591charset = Charset.forName("ISO-8859-15");

        ByteBuffer inputBuffer = ByteBuffer.wrap( arr );

        // decode UTF-8
        CharBuffer data = utf8charset.decode(inputBuffer);

        // encode ISO-8559-1
        ByteBuffer outputBuffer = iso88591charset.encode(data);
        byte[] outputData = outputBuffer.array();

        return outputData;
    }

}

Answer 6

Si tiene la codificación correcta en la cadena, no necesita hacer más para obtener los bytes para otra codificación.

public static void main(String[] args) throws Exception {
    printBytes("â");
    System.out.println(
            new String(new byte[] { (byte) 0xE2 }, "ISO-8859-1"));
    System.out.println(
            new String(new byte[] { (byte) 0xC3, (byte) 0xA2 }, "UTF-8"));
}

private static void printBytes(String str) {
    System.out.println("Bytes in " + str + " with ISO-8859-1");
    for (byte b : str.getBytes(StandardCharsets.ISO_8859_1)) {
        System.out.printf("%3X", b);
    }
    System.out.println();
    System.out.println("Bytes in " + str + " with UTF-8");
    for (byte b : str.getBytes(StandardCharsets.UTF_8)) {
        System.out.printf("%3X", b);
    }
    System.out.println();
}

Salida:

Bytes in â with ISO-8859-1
 E2
Bytes in â with UTF-8
 C3 A2
â
â

Answer 7

Si está tratando con codificaciones de caracteres que no sean UTF-16, no debería usar java.lang.String o la primitiva char : solo debería usar matrices byte[] u objetos ByteBuffer . Luego, puedes usar java.nio.charset.Charset para convertir codificaciones:

Charset utf8charset = Charset.forName("UTF-8");
Charset iso88591charset = Charset.forName("ISO-8859-1");

ByteBuffer inputBuffer = ByteBuffer.wrap(new byte[]{(byte)0xC3, (byte)0xA2});

// decode UTF-8
CharBuffer data = utf8charset.decode(inputBuffer);

// encode ISO-8559-1
ByteBuffer outputBuffer = iso88591charset.encode(data);
byte[] outputData = outputBuffer.array();

Answer 8

byte[] iso88591Data = theString.getBytes("ISO-8859-1");

Hará el truco. Según su descripción, parece que intenta "almacenar una cadena ISO-8859-1". Los objetos de cadena en Java siempre están codificados implícitamente en UTF-16. No hay forma de cambiar esa codificación.

Lo que puede hacer, ''aunque es obtener los bytes que constituyen alguna otra codificación de la misma (utilizando el método .getBytes () como se muestra arriba).