Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Converter de windows-1250 para UTF-8 e tratar erros de descodificação

Converte bytes de windows-1250 para UTF-8: primeiro descodifica-os em caracteres Unicode e depois volta a codificá-los. Escolhe como o descodificador reage a cada tipo de erro.

Versão: Java SE 21

Sintaxe

Java SE 21 — java.nio.charset (buffers in java.nio)
Charset.forName(String charsetName) -> Charset
Charset.forName(String charsetName, Charset fallback) -> Charset
charset.newDecoder() -> CharsetDecoder
charset.newEncoder() -> CharsetEncoder
decoder.onMalformedInput(CodingErrorAction action) -> CharsetDecoder
decoder.onUnmappableCharacter(CodingErrorAction action) -> CharsetDecoder
decoder.decode(ByteBuffer in) -> CharBuffer; throws CharacterCodingException
decoder.decode(ByteBuffer in, CharBuffer out, boolean endOfInput) -> CoderResult
encoder.encode(CharBuffer in) -> ByteBuffer; throws CharacterCodingException
encoder.encode(CharBuffer in, ByteBuffer out, boolean endOfInput) -> CoderResult

Em Java SE 21, Charset.forName(String), do pacote java.nio.charset, procura uma codificação pelo nome canónico ou por um alias. Um nome inválido provoca IllegalCharsetNameException; uma codificação não suportada provoca UnsupportedCharsetException. A sobrecarga forName(String, Charset), disponível desde Java 18, devolve o valor alternativo (que pode ser null) em ambos os casos. As duas sobrecargas rejeitam um nome null com IllegalArgumentException.

Usa newDecoder() na codificação de origem para ler bytes como caracteres Unicode, e newEncoder() na codificação de destino para escrever novos bytes. O Oracle JDK 21 suporta windows-1250, mas Java SE não o exige; StandardCharsets.UTF_8 é garantido. Se o conjunto de caracteres não permitir codificar caracteres em bytes, newEncoder() lança UnsupportedOperationException. Os descodificadores e codificadores mantêm estado e não são seguros para uso concorrente.

onMalformedInput(action) trata sequências de bytes que violam as regras da codificação; onUnmappableCharacter(action) trata sequências bem formadas sem correspondência em Unicode. Ambos os métodos alteram e devolvem o mesmo descodificador. Por omissão, REPORT assinala o erro; REPLACE insere texto de substituição (inicialmente U+FFFD); IGNORE descarta os dados incorretos. A substituição e a omissão causam perda de informação. Usa REPORT para evitar erros silenciosos, mas não o tomes como prova de que escolheste a codificação de origem correta. O atalho Charset.decode(...) faz substituições nos dois tipos de erro.

Os métodos de um argumento CharsetDecoder.decode(ByteBuffer) e CharsetEncoder.encode(CharBuffer) leem a entrada restante e devolvem, respetivamente, um novo CharBuffer ou ByteBuffer. Com REPORT, um erro lança MalformedInputException ou UnmappableCharacterException, ambas subclasses de CharacterCodingException. Para processar por blocos, usa a sobrecarga com um buffer de saída e o indicador endOfInput: verifica CoderResult, guarda a entrada não consumida e chama flush(...) depois do último bloco. Não chames a variante de um argumento enquanto essa operação estiver em curso.

Exemplos

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.MalformedInputException;
import java.nio.charset.StandardCharsets;
import java.util.HexFormat;

public class CharsetDemo {
    private static CharsetDecoder decoder(Charset charset, CodingErrorAction action) {
        return charset.newDecoder()
                .onMalformedInput(action)
                .onUnmappableCharacter(action);
    }

    public static void main(String[] args) throws java.nio.charset.CharacterCodingException {
        Charset source = Charset.forName("windows-1250");
        Charset utf8 = StandardCharsets.UTF_8;

        byte[] legacy = {(byte) 0xA5};
        CharBuffer text = decoder(source, CodingErrorAction.REPORT)
                .decode(ByteBuffer.wrap(legacy));
        ByteBuffer encoded = utf8.newEncoder().encode(text);
        byte[] output = new byte[encoded.remaining()];
        encoded.get(output);
        System.out.println("windows-1250 -> UTF-8: "
                + HexFormat.ofDelimiter(" ").withUpperCase().formatHex(output));

        byte[] truncatedUtf8 = {(byte) 0xC3};
        try {
            decoder(utf8, CodingErrorAction.REPORT).decode(ByteBuffer.wrap(truncatedUtf8));
            throw new AssertionError("Expected malformed UTF-8");
        } catch (MalformedInputException expected) {
            System.out.println("REPORT: MalformedInputException");
        }

        CharBuffer repaired = decoder(utf8, CodingErrorAction.REPLACE)
                .decode(ByteBuffer.wrap(truncatedUtf8));
        System.out.printf("REPLACE: U+%04X%n", Character.codePointAt(repaired, 0));
    }
}

Resultado

windows-1250 -> UTF-8: C4 84
REPORT: MalformedInputException
REPLACE: U+FFFD

O byte `A5` em windows-1250 representa `U+0104`, escrito como `C4 84` em UTF-8. Num teste separado, um byte `C3` isolado inicia uma sequência UTF-8 incompleta: `REPORT` lança uma exceção e `REPLACE` produz `U+FFFD`. A saída hexadecimal não depende da forma como o terminal apresenta Unicode.

Lições relacionadas

  • Java · Lição 51 · Avançado · Versão: 2

Fontes