Guida alla codifica dei caratteri

1. Panoramica

In questo tutorial, discuteremo le basi della codifica dei caratteri e come la gestiamo in Java.

2. Importanza della codifica dei caratteri

Spesso abbiamo a che fare con testi appartenenti a più lingue con diversi script di scrittura come il latino o l'arabo. Ogni carattere in ogni lingua deve essere in qualche modo mappato su un insieme di uno e zeri. È davvero sorprendente che i computer possano elaborare correttamente tutte le nostre lingue.

Per farlo correttamente, dobbiamo pensare alla codifica dei caratteri. Non farlo può spesso portare alla perdita di dati e persino a vulnerabilità di sicurezza.

Per capirlo meglio, definiamo un metodo per decodificare un testo in Java:

String decodeText(String input, String encoding) throws IOException { return new BufferedReader( new InputStreamReader( new ByteArrayInputStream(input.getBytes()), Charset.forName(encoding))) .readLine(); }

Nota che il testo di input che forniamo qui utilizza la codifica della piattaforma predefinita.

Se eseguiamo questo metodo con input come "Il modello di facciata è un modello di progettazione software". e codificando come "US-ASCII" , restituirà:

The fa��ade pattern is a software design pattern.

Beh, non esattamente quello che ci aspettavamo.

Cosa potrebbe essere andato storto? Cercheremo di capire e correggere questo problema nel resto di questo tutorial.

3. Fondamenti

Prima di approfondire, tuttavia, esaminiamo rapidamente tre termini: codifica , set di caratteri e punto di codice .

3.1. Codifica

I computer possono comprendere solo rappresentazioni binarie come 1 e 0 . L'elaborazione di qualsiasi altra cosa richiede un qualche tipo di mappatura dal testo del mondo reale alla sua rappresentazione binaria. Questa mappatura è ciò che conosciamo come codifica dei caratteri o semplicemente come codifica .

Ad esempio, la prima lettera del nostro messaggio, "T", in US-ASCII codifica "01010100".

3.2. Set di caratteri

La mappatura dei caratteri alle loro rappresentazioni binarie può variare notevolmente in termini di caratteri che includono. Il numero di caratteri inclusi in una mappatura può variare da pochi a tutti i caratteri nell'uso pratico. Il set di caratteri incluso in una definizione di mappatura è formalmente chiamato set di caratteri .

Ad esempio, ASCII ha un set di caratteri di 128 caratteri.

3.3. Punto codice

Un punto di codice è un'astrazione che separa un carattere dalla sua codifica effettiva. Un punto di codice è un riferimento intero a un carattere particolare.

Possiamo rappresentare l'intero stesso in semplici basi decimali o alternative come esadecimale o ottale. Usiamo basi alternative per la facilità di riferimento di grandi numeri.

Ad esempio, la prima lettera del nostro messaggio, T, in Unicode ha un punto di codice "U + 0054" (o 84 in decimale).

4. Comprensione degli schemi di codifica

Una codifica dei caratteri può assumere varie forme a seconda del numero di caratteri che codifica.

Il numero di caratteri codificati ha una relazione diretta con la lunghezza di ciascuna rappresentazione che tipicamente viene misurata come il numero di byte. Avere più caratteri da codificare significa essenzialmente aver bisogno di rappresentazioni binarie più lunghe.

Esaminiamo oggi alcuni dei popolari schemi di codifica nella pratica.

4.1. Codifica a byte singolo

Uno dei primi schemi di codifica, chiamato ASCII (American Standard Code for Information Exchange) utilizza uno schema di codifica a byte singolo. Ciò significa essenzialmente che ogni carattere in ASCII è rappresentato con numeri binari a sette bit. Questo lascia ancora un bit libero in ogni byte!

Il set di 128 caratteri ASCII copre alfabeti inglesi in lettere maiuscole e minuscole, cifre e alcuni caratteri speciali e di controllo.

Definiamo un metodo semplice in Java per visualizzare la rappresentazione binaria di un carattere sotto un particolare schema di codifica:

String convertToBinary(String input, String encoding) throws UnsupportedEncodingException { byte[] encoded_input = Charset.forName(encoding) .encode(input) .array(); return IntStream.range(0, encoded_input.length) .map(i -> encoded_input[i]) .mapToObj(e -> Integer.toBinaryString(e ^ 255)) .map(e -> String.format("%1$" + Byte.SIZE + "s", e).replace(" ", "0")) .collect(Collectors.joining(" ")); }

Ora, il carattere "T" ha un punto di codice 84 in US-ASCII (ASCII è indicato come US-ASCII in Java).

E se usiamo il nostro metodo di utilità, possiamo vedere la sua rappresentazione binaria:

assertEquals(convertToBinary("T", "US-ASCII"), "01010100");

Questa, come ci aspettavamo, è una rappresentazione binaria a sette bit per il carattere "T".

L'ASCII originale ha lasciato inutilizzato il bit più significativo di ogni byte. Allo stesso tempo, ASCII aveva lasciato molti caratteri non rappresentati, specialmente per le lingue diverse dall'inglese.

Ciò ha portato a uno sforzo per utilizzare quel bit inutilizzato e includere altri 128 caratteri.

Ci sono state diverse varianti dello schema di codifica ASCII proposto e adottato nel tempo. Questi vagamente sono stati denominati "estensioni ASCII".

Molte delle estensioni ASCII hanno avuto diversi livelli di successo, ma ovviamente questo non è stato sufficiente per un'adozione più ampia poiché molti caratteri non erano ancora rappresentati.

Una delle estensioni ASCII più popolari era ISO-8859-1 , denominata anche "ISO Latin 1".

4.2. Codifica multibyte

Con la crescita della necessità di accogliere sempre più caratteri, schemi di codifica a byte singolo come ASCII non erano sostenibili.

Ciò ha dato origine a schemi di codifica multibyte che hanno una capacità molto migliore anche se a costo di maggiori requisiti di spazio.

BIG5 e SHIFT-JIS sono esempi di schemi di codifica dei caratteri multibyte che hanno iniziato a utilizzare uno o due byte per rappresentare set di caratteri più ampi . La maggior parte di questi sono stati creati per la necessità di rappresentare script cinesi e simili che hanno un numero di caratteri significativamente maggiore.

Chiamiamo ora il metodo convertToBinary con input come "語", un carattere cinese e codifica "Big5":

assertEquals(convertToBinary("語", "Big5"), "10111011 01111001");

L'output sopra mostra che la codifica Big5 utilizza due byte per rappresentare il carattere "語".

Un elenco completo delle codifiche dei caratteri, insieme ai loro alias, è mantenuto dall'International Number Authority.

5. Unicode

Non è difficile capire che mentre la codifica è importante, la decodifica è altrettanto vitale per dare un senso alle rappresentazioni. Ciò è possibile in pratica solo se viene ampiamente utilizzato uno schema di codifica coerente o compatibile.

Diversi schemi di codifica sviluppati isolatamente e praticati nelle aree geografiche locali hanno iniziato a diventare impegnativi.

Questa sfida ha dato origine a un singolare standard di codifica chiamato Unicode che ha la capacità per ogni possibile carattere nel mondo . Ciò include i personaggi che sono in uso e anche quelli che sono defunti!

Well, that must require several bytes to store each character? Honestly yes, but Unicode has an ingenious solution.

Unicode as a standard defines code points for every possible character in the world. The code point for character ‘T' in Unicode is 84 in decimal. We generally refer to this as “U+0054” in Unicode which is nothing but U+ followed by the hexadecimal number.

We use hexadecimal as the base for code points in Unicode as there are 1,114,112 points, which is a pretty large number to communicate conveniently in decimal!

How these code points are encoded into bits is left to specific encoding schemes within Unicode. We will cover some of these encoding schemes in the sub-sections below.

5.1. UTF-32

UTF-32 is an encoding scheme for Unicode that employs four bytes to represent every code point defined by Unicode. Obviously, it is space inefficient to use four bytes for every character.

Let's see how a simple character like ‘T' is represented in UTF-32. We will use the method convertToBinary introduced earlier:

assertEquals(convertToBinary("T", "UTF-32"), "00000000 00000000 00000000 01010100");

The output above shows the usage of four bytes to represent the character ‘T' where the first three bytes are just wasted space.

5.2. UTF-8

UTF-8 is another encoding scheme for Unicode which employs a variable length of bytes to encode. While it uses a single byte to encode characters generally, it can use a higher number of bytes if needed, thus saving space.

Let's again call the method convertToBinary with input as ‘T' and encoding as “UTF-8”:

assertEquals(convertToBinary("T", "UTF-8"), "01010100");

The output is exactly similar to ASCII using just a single byte. In fact, UTF-8 is completely backward compatible with ASCII.

Let's again call the method convertToBinary with input as ‘語' and encoding as “UTF-8”:

assertEquals(convertToBinary("語", "UTF-8"), "11101000 10101010 10011110");

As we can see here UTF-8 uses three bytes to represent the character ‘語'. This is known as variable-width encoding.

UTF-8, due to its space efficiency, is the most common encoding used on the web.

6. Encoding Support in Java

Java supports a wide array of encodings and their conversions to each other. The class Charset defines a set of standard encodings which every implementation of Java platform is mandated to support.

This includes US-ASCII, ISO-8859-1, UTF-8, and UTF-16 to name a few. A particular implementation of Java may optionally support additional encodings.

There are some subtleties in the way Java picks up a charset to work with. Let's go through them in more details.

6.1. Default Charset

The Java platform depends heavily on a property called the default charset. The Java Virtual Machine (JVM) determines the default charset during start-up.

This is dependent on the locale and the charset of the underlying operating system on which JVM is running. For example on MacOS, the default charset is UTF-8.

Let's see how we can determine the default charset:

Charset.defaultCharset().displayName();

If we run this code snippet on a Windows machine the output we get:

windows-1252

Now, “windows-1252” is the default charset of the Windows platform in English, which in this case has determined the default charset of JVM which is running on Windows.

6.2. Who Uses the Default Charset?

Many of the Java APIs make use of the default charset as determined by the JVM. To name a few:

  • InputStreamReader and FileReader
  • OutputStreamWriter and FileWriter
  • Formatter and Scanner
  • URLEncoder and URLDecoder

So, this means that if we'd run our example without specifying the charset:

new BufferedReader(new InputStreamReader(new ByteArrayInputStream(input.getBytes()))).readLine();

then it would use the default charset to decode it.

And there are several APIs that make this same choice by default.

The default charset hence assumes an importance which we can not safely ignore.

6.3. Problems With the Default Charset

As we have seen that the default charset in Java is determined dynamically when the JVM starts. This makes the platform less reliable or error-prone when used across different operating systems.

For example, if we run

new BufferedReader(new InputStreamReader(new ByteArrayInputStream(input.getBytes()))).readLine();

on macOS, it will use UTF-8.

If we try the same snippet on Windows, it will use Windows-1252 to decode the same text.

Or, imagine writing a file on a macOS, and then reading that same file on Windows.

It's not difficult to understand that because of different encoding schemes, this may lead to data loss or corruption.

6.4. Can We Override the Default Charset?

The determination of the default charset in Java leads to two system properties:

  • file.encoding: The value of this system property is the name of the default charset
  • sun.jnu.encoding: The value of this system property is the name of the charset used when encoding/decoding file paths

Now, it's intuitive to override these system properties through command line arguments:

-Dfile.encoding="UTF-8" -Dsun.jnu.encoding="UTF-8"

However, it is important to note that these properties are read-only in Java. Their usage as above is not present in the documentation. Overriding these system properties may not have desired or predictable behavior.

Hence, we should avoid overriding the default charset in Java.

6.5. Why Is Java Not Solving This?

There is a Java Enhancement Proposal (JEP) which prescribes using “UTF-8” as the default charset in Java instead of basing it on locale and operating system charset.

This JEP is in a draft state as of now and when it (hopefully!) goes through it will solve most of the issues we discussed earlier.

Note that the newer APIs like those in java.nio.file.Files do not use the default charset. The methods in these APIs read or write character streams with charset as UTF-8 rather than the default charset.

6.6. Solving This Problem in Our Programs

We should normally choose to specify a charset when dealing with text instead of relying on the default settings. We can explicitly declare the encoding we want to use in classes which deal with character-to-byte conversions.

Luckily, our example is already specifying the charset. We just need to select the right one and let Java do the rest.

We should realize by now that accented characters like ‘ç' are not present in the encoding schema ASCII and hence we need an encoding which includes them. Perhaps, UTF-8?

Let's try that, we will now run the method decodeText with the same input but encoding as “UTF-8”:

The façade pattern is a software-design pattern.

Bingo! We can see the output we were hoping to see now.

Here we have set the encoding we think best suits our need in the constructor of InputStreamReader. This is usually the safest method of dealing with characters and byte conversions in Java.

Similarly, OutputStreamWriter and many other APIs supports setting an encoding scheme through their constructor.

6.7. MalformedInputException

When we decode a byte sequence, there exist cases in which it's not legal for the given Charset, or else it's not a legal sixteen-bit Unicode. In other words, the given byte sequence has no mapping in the specified Charset.

There are three predefined strategies (or CodingErrorAction) when the input sequence has malformed input:

  • IGNORE will ignore malformed characters and resume coding operation
  • REPLACE will replace the malformed characters in the output buffer and resume the coding operation
  • REPORT will throw a MalformedInputException

The default malformedInputAction for the CharsetDecoder is REPORT, and the default malformedInputAction of the default decoder in InputStreamReader is REPLACE.

Let's define a decoding function that receives a specified Charset, a CodingErrorAction type, and a string to be decoded:

String decodeText(String input, Charset charset, CodingErrorAction codingErrorAction) throws IOException { CharsetDecoder charsetDecoder = charset.newDecoder(); charsetDecoder.onMalformedInput(codingErrorAction); return new BufferedReader( new InputStreamReader( new ByteArrayInputStream(input.getBytes()), charsetDecoder)).readLine(); }

So, if we decode “The façade pattern is a software design pattern.” with US_ASCII, the output for each strategy would be different. First, we use CodingErrorAction.IGNORE which skips illegal characters:

Assertions.assertEquals( "The faade pattern is a software design pattern.", CharacterEncodingExamples.decodeText( "The façade pattern is a software design pattern.", StandardCharsets.US_ASCII, CodingErrorAction.IGNORE));

For the second test, we use CodingErrorAction.REPLACE that puts � instead of the illegal characters:

Assertions.assertEquals( "The fa��ade pattern is a software design pattern.", CharacterEncodingExamples.decodeText( "The façade pattern is a software design pattern.", StandardCharsets.US_ASCII, CodingErrorAction.REPLACE));

For the third test, we use CodingErrorAction.REPORT which leads to throwing MalformedInputException:

Assertions.assertThrows( MalformedInputException.class, () -> CharacterEncodingExamples.decodeText( "The façade pattern is a software design pattern.", StandardCharsets.US_ASCII, CodingErrorAction.REPORT));

7. Other Places Where Encoding Is Important

We don't just need to consider character encoding while programming. Texts can go wrong terminally at many other places.

The most common cause of problems in these cases is the conversion of text from one encoding scheme to another, thereby possibly introducing data loss.

Let's quickly go through a few places where we may encounter issues when encoding or decoding text.

7.1. Text Editors

In most of the cases, a text editor is where texts originate. There are numerous text editors in popular choice including vi, Notepad, and MS Word. Most of these text editors allow for us to select the encoding scheme. Hence, we should always make sure they are appropriate for the text we are handling.

7.2. File System

After we create texts in an editor, we need to store them in some file system. The file system depends on the operating system on which it is running. Most operating systems have inherent support for multiple encoding schemes. However, there may still be cases where an encoding conversion leads to data loss.

7.3. Network

Texts when transferred over a network using a protocol like File Transfer Protocol (FTP) also involve conversion between character encodings. For anything encoded in Unicode, it's safest to transfer over as binary to minimize the risk of loss in conversion. However, transferring text over a network is one of the less frequent causes of data corruption.

7.4. Databases

Most of the popular databases like Oracle and MySQL support the choice of the character encoding scheme at the installation or creation of databases. We must choose this in accordance with the texts we expect to store in the database. This is one of the more frequent places where the corruption of text data happens due to encoding conversions.

7.5. Browsers

Finally, in most web applications, we create texts and pass them through different layers with the intention to view them in a user interface, like a browser. Here as well it is imperative for us to choose the right character encoding which can display the characters properly. Most popular browsers like Chrome, Edge allow choosing the character encoding through their settings.

8. Conclusion

In this article, we discussed how encoding can be an issue while programming.

We further discussed the fundamentals including encoding and charsets. Moreover, we went through different encoding schemes and their uses.

We also picked up an example of incorrect character encoding usage in Java and saw how to get that right. Finally, we discussed some other common error scenarios related to character encoding.

Come sempre, il codice per gli esempi è disponibile su GitHub.