Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Konwersja windows-1250 do UTF-8 i obsługa błędów dekodowania

Przekonwertuj bajty z windows-1250 na UTF-8, dekodując je do znaków Unicode, a następnie kodując ponownie. Ustal osobno, jak dekoder ma reagować na każdy rodzaj błędu.

Wersja: Java SE 21

Składnia

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

W Java SE 21 Charset.forName(String) z pakietu java.nio.charset wyszukuje kodowanie według nazwy kanonicznej lub aliasu. Niepoprawna nazwa powoduje IllegalCharsetNameException, nieobsługiwana — UnsupportedCharsetException. Wariant forName(String, Charset) dostępny od Javy 18 zwraca wartość zapasową (może to być null) przy niepoprawnej lub nieobsługiwanej nazwie. Oba warianty odrzucają nazwę null przez IllegalArgumentException.

Najpierw użyj newDecoder() kodowania źródłowego, aby odczytać bajty jako znaki Unicode, a potem newEncoder() kodowania docelowego, aby zapisać je jako nowe bajty. Oracle JDK 21 obsługuje windows-1250, ale Java SE go nie gwarantuje; StandardCharsets.UTF_8 jest gwarantowane. Jeżeli dane kodowanie nie obsługuje kodowania znaków, newEncoder() zgłasza UnsupportedOperationException. Dekodery i kodery przechowują stan i nie są bezpieczne wątkowo.

onMalformedInput(action) dotyczy sekwencji bajtów niezgodnych z regułami kodowania; onUnmappableCharacter(action) — sekwencji poprawnych strukturalnie, ale bez odwzorowania na znaki Unicode. Obie metody zmieniają i zwracają ten sam dekoder. Domyślne REPORT zgłasza błąd, REPLACE wstawia tekst zastępczy (początkowo U+FFFD), a IGNORE pomija błędne dane. Zastępowanie i pomijanie powodują utratę informacji. Gdy błędy są niedopuszczalne, użyj REPORT, ale pamiętaj, że nie potwierdza ono poprawności wyboru kodowania źródłowego. Skrót Charset.decode(...) zastępuje oba rodzaje błędów.

Jednoargumentowe CharsetDecoder.decode(ByteBuffer) i CharsetEncoder.encode(CharBuffer) odczytują pozostałą zawartość wejścia i zwracają odpowiednio nowy CharBuffer i ByteBuffer. W trybie REPORT błąd powoduje MalformedInputException lub UnmappableCharacterException (obie dziedziczą po CharacterCodingException). Do przetwarzania porcjami użyj przeciążenia z buforem wyjściowym i flagą endOfInput: sprawdzaj CoderResult, zachowuj niezużyte dane wejściowe i po ostatniej porcji wywołaj flush(...). Nie wywołuj wariantu jednoargumentowego w trakcie takiej operacji.

Przykłady

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

Wynik

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

Bajt `A5` w windows-1250 oznacza `U+0104`, zapisywany w UTF-8 jako `C4 84`. W osobnym teście samotny bajt `C3` jest początkiem niedokończonej sekwencji UTF-8: `REPORT` powoduje wyjątek, a `REPLACE` daje `U+FFFD`. Zapis szesnastkowy nie zależy od tego, jak terminal wyświetla znaki Unicode.

Powiązane lekcje

  • Java · Lekcja 51 · Zaawansowany · Wersja: 2

Źródła