Comment travailler avec les caractères Unicode en Java

JavaJavaBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Java offre un support solide pour la gestion des caractères Unicode, ce qui en fait un excellent choix pour le développement d'applications internationales. Unicode est une norme d'encodage de caractères universelle qui attribue un numéro unique à chaque caractère, indépendamment de la plateforme, du programme ou de la langue.

Dans ce tutoriel, nous allons explorer comment travailler avec Unicode en Java grâce à des exemples pratiques. Vous apprendrez à représenter les caractères Unicode dans votre code, à les manipuler de manière programmée et à gérer les opérations d'entrée et de sortie de caractères Unicode. À la fin de ce lab (atelier), vous serez en mesure de travailler en toute confiance avec du texte international dans vos applications Java.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java(("Java")) -.-> java/FileandIOManagementGroup(["File and I/O Management"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java/BasicSyntaxGroup -.-> java/operators("Operators") java/StringManipulationGroup -.-> java/strings("Strings") java/FileandIOManagementGroup -.-> java/files("Files") java/FileandIOManagementGroup -.-> java/io("IO") java/FileandIOManagementGroup -.-> java/nio("NIO") java/SystemandDataProcessingGroup -.-> java/object_methods("Object Methods") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/operators -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/strings -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/files -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/io -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/nio -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/object_methods -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} java/string_methods -.-> lab-414959{{"Comment travailler avec les caractères Unicode en Java"}} end

Création de votre premier programme Java utilisant Unicode

Dans cette étape, nous allons créer notre premier programme Java qui utilise des caractères Unicode. Nous allons explorer la façon dont Java gère Unicode et voir comment incorporer des caractères de différentes langues dans notre code.

Comprendre Unicode en Java

Java utilise en interne l'encodage UTF - 16, ce qui signifie que chaque caractère en Java est représenté comme un caractère Unicode de 16 bits. Cela permet à Java de prendre en charge un large éventail de caractères internationaux dès le départ.

Chaque caractère Unicode a un point de code unique, qui est une valeur numérique qui identifie le caractère. Par exemple :

  • La lettre anglaise 'A' a le point de code U+0041
  • Le caractère chinois '中' a le point de code U+4E2D
  • L'emoji '😀' a le point de code U+1F600

Créons un simple programme Java pour démontrer l'utilisation de caractères Unicode.

Création et exécution du programme

  1. Ouvrez le WebIDE et accédez au terminal. Assurez - vous que vous êtes dans le répertoire /home/labex/project.

  2. Créez un nouveau fichier Java nommé UnicodeDemo.java en utilisant l'éditeur du WebIDE. Cliquez sur l'icône "Explorer" dans la barre latérale de gauche, puis cliquez sur l'icône "New File" et nommez - le UnicodeDemo.java.

  3. Ajoutez le code suivant au fichier :

public class UnicodeDemo {
    public static void main(String[] args) {
        // Unicode characters from different languages
        String english = "Hello";
        String spanish = "Hola";
        String french = "Bonjour";
        String chinese = "你好";
        String japanese = "こんにちは";
        String arabic = "مرحبا";
        String russian = "Привет";

        // Print all greetings
        System.out.println("English: " + english);
        System.out.println("Spanish: " + spanish);
        System.out.println("French: " + french);
        System.out.println("Chinese: " + chinese);
        System.out.println("Japanese: " + japanese);
        System.out.println("Arabic: " + arabic);
        System.out.println("Russian: " + russian);

        // Print information about a specific character
        char chineseChar = '中';
        System.out.println("\nInformation about the character '" + chineseChar + "':");
        System.out.println("Unicode code point: " + Integer.toHexString(chineseChar | 0x10000).substring(1).toUpperCase());
        System.out.println("Character type: " + Character.getType(chineseChar));
    }
}
  1. Enregistrez le fichier en appuyant sur Ctrl+S ou en sélectionnant Fichier > Enregistrer dans le menu.

  2. Compilez et exécutez le programme en exécutant les commandes suivantes dans le terminal :

javac UnicodeDemo.java
java UnicodeDemo

Vous devriez voir une sortie similaire à ce qui suit :

English: Hello
Spanish: Hola
French: Bonjour
Chinese: 你好
Japanese: こんにちは
Arabic: مرحبا
Russian: Привет

Information about the character '中':
Unicode code point: 4E2D
Character type: 5

Comprendre la sortie

Le programme affiche avec succès des salutations dans diverses langues, démontrant le support d'Unicode de Java. La valeur de type de caractère "5" correspond à Character.OTHER_LETTER dans la classe Character de Java, indiquant que '中' est classé comme une lettre qui n'est ni en majuscule ni en minuscule.

Cet exemple montre que Java peut gérer des caractères de différents systèmes d'écriture sans aucune configuration spéciale. Les caractères Unicode sont directement inclus dans le code source, et Java les traite et les affiche correctement.

Travailler avec les séquences d'échappement Unicode

Dans cette étape, nous allons apprendre à représenter les caractères Unicode à l'aide de séquences d'échappement en Java. Cela est utile lorsque vous devez inclure des caractères Unicode dans votre code, mais que vous souhaitez garantir la compatibilité avec des éditeurs de texte ou des environnements qui pourraient ne pas prendre en charge l'entrée directe de ces caractères.

Séquences d'échappement Unicode

En Java, vous pouvez représenter n'importe quel caractère Unicode en utilisant la séquence d'échappement \u suivie du point de code hexadécimal à quatre chiffres. Par exemple :

  • \u0041 représente 'A'
  • \u4E2D représente '中'

Pour les caractères au - delà du Plan Multilingue de Base (Basic Multilingual Plane - BMP), qui nécessitent plus de 4 chiffres hexadécimaux, vous pouvez utiliser des paires de substitution ou la syntaxe plus récente \u{...} dans les littéraux de chaîne avec Java 12 ou une version ultérieure.

Créons un nouveau programme pour démontrer les séquences d'échappement Unicode.

Création du programme

  1. Créez un nouveau fichier nommé UnicodeEscapeDemo.java dans le répertoire /home/labex/project.

  2. Ajoutez le code suivant au fichier :

public class UnicodeEscapeDemo {
    public static void main(String[] args) {
        // Unicode escape sequences
        char charA = '\u0041';         // Latin capital 'A'
        char charZ = '\u005A';         // Latin capital 'Z'
        char charCopyright = '\u00A9'; // Copyright symbol ©
        char charEuro = '\u20AC';      // Euro symbol €
        char charChinese = '\u4E2D';   // Chinese character '中'

        System.out.println("Using Unicode escape sequences:");
        System.out.println("\\u0041: " + charA);
        System.out.println("\\u005A: " + charZ);
        System.out.println("\\u00A9: " + charCopyright);
        System.out.println("\\u20AC: " + charEuro);
        System.out.println("\\u4E2D: " + charChinese);

        // Comparing direct characters and escape sequences
        System.out.println("\nComparing direct characters and escape sequences:");
        System.out.println("Direct 'A' == \\u0041: " + ('A' == '\u0041'));
        System.out.println("Direct '©' == \\u00A9: " + ('©' == '\u00A9'));
        System.out.println("Direct '中' == \\u4E2D: " + ('中' == '\u4E2D'));

        // Exploring character properties
        System.out.println("\nExploring properties of Unicode characters:");
        examineCharacter('A');
        examineCharacter('9');
        examineCharacter('©');
        examineCharacter('中');
    }

    private static void examineCharacter(char c) {
        System.out.println("\nCharacter: " + c);
        System.out.println("Unicode code point: \\u" +
            Integer.toHexString(c | 0x10000).substring(1).toUpperCase());
        System.out.println("Is letter? " + Character.isLetter(c));
        System.out.println("Is digit? " + Character.isDigit(c));
        System.out.println("Is whitespace? " + Character.isWhitespace(c));
        System.out.println("Is symbol? " + Character.isISOControl(c));
    }
}
  1. Enregistrez le fichier en appuyant sur Ctrl+S ou en sélectionnant Fichier > Enregistrer dans le menu.

  2. Compilez et exécutez le programme en exécutant les commandes suivantes dans le terminal :

javac UnicodeEscapeDemo.java
java UnicodeEscapeDemo

Vous devriez voir une sortie similaire à ce qui suit :

Using Unicode escape sequences:
\u0041: A
\u005A: Z
\u00A9: ©
\u20AC: €
\u4E2D: 中

Comparing direct characters and escape sequences:
Direct 'A' == \u0041: true
Direct '©' == \u00A9: true
Direct '中' == \u4E2D: true

Exploring properties of Unicode characters:

Character: A
Unicode code point: \u0041
Is letter? true
Is digit? false
Is whitespace? false
Is symbol? false

Character: 9
Unicode code point: \u0039
Is letter? false
Is digit? true
Is whitespace? false
Is symbol? false

Character: ©
Unicode code point: \u00A9
Is letter? false
Is digit? false
Is whitespace? false
Is symbol? false

Character: 中
Unicode code point: \u4E2D
Is letter? true
Is digit? false
Is whitespace? false
Is symbol? false

Comprendre le code

Ce programme démontre plusieurs concepts importants :

  1. Séquences d'échappement Unicode : Nous définissons des caractères à l'aide de leurs séquences d'échappement Unicode (\uXXXX).

  2. Égalité des caractères : Le programme montre qu'un caractère défini directement ('A') est identique au même caractère défini à l'aide d'une séquence d'échappement ('\u0041').

  3. Propriétés des caractères : La méthode examineCharacter utilise la classe Character pour inspecter les propriétés de différents caractères Unicode, comme le fait qu'ils soient des lettres, des chiffres ou des espaces blancs.

L'utilisation de séquences d'échappement Unicode est particulièrement utile lorsque :

  • Votre code doit être traité par des outils qui ne gèrent pas bien l'Unicode
  • Vous souhaitez rendre explicite le point de code exact dans votre code source
  • Vous devez inclure des caractères difficiles à taper ou visuellement similaires à d'autres

Lecture et écriture de caractères Unicode dans des fichiers

Dans cette étape, nous allons apprendre à lire et écrire des caractères Unicode dans des fichiers. Une gestion appropriée des encodages de caractères est cruciale lorsque vous travaillez avec des fichiers, en particulier lorsqu'il s'agit de texte international.

Comprendre les encodages de caractères

Lorsque vous écrivez du texte dans un fichier ou que vous le lisez depuis un fichier, vous devez spécifier l'encodage de caractères. L'encodage le plus courant et recommandé pour le texte Unicode est UTF - 8.

  • UTF - 8 est un encodage à largeur variable qui peut représenter tous les caractères Unicode.
  • Il est rétro - compatible avec ASCII.
  • C'est l'encodage par défaut pour HTML, XML et de nombreux systèmes modernes.

Java fournit la classe java.nio.charset.StandardCharsets, qui contient des constantes pour les jeux de caractères standards tels que UTF - 8, UTF - 16 et ISO - 8859 - 1.

Créons un programme qui démontre la lecture et l'écriture de texte Unicode dans des fichiers.

Création du programme d'écriture de fichier Unicode

  1. Créez un nouveau fichier nommé UnicodeFileDemo.java dans le répertoire /home/labex/project.

  2. Ajoutez le code suivant au fichier :

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;

public class UnicodeFileDemo {
    private static final String FILE_PATH = "unicode_sample.txt";

    public static void main(String[] args) {
        try {
            // Create a list of greetings in different languages
            List<String> greetings = Arrays.asList(
                "English: Hello, World!",
                "Spanish: ¡Hola, Mundo!",
                "French: Bonjour, le Monde!",
                "German: Hallo, Welt!",
                "Chinese: 你好,世界!",
                "Japanese: こんにちは、世界!",
                "Arabic: مرحبا بالعالم!",
                "Russian: Привет, мир!",
                "Greek: Γειά σου, Κόσμε!",
                "Hindi: नमस्ते, दुनिया!",
                "Emoji: 👋🌍!"
            );

            // Write greetings to file
            writeToFile(greetings);
            System.out.println("Successfully wrote Unicode text to " + FILE_PATH);

            // Read and display file contents
            List<String> readLines = readFromFile();
            System.out.println("\nFile contents:");
            for (String line : readLines) {
                System.out.println(line);
            }

            // Display encoding information
            System.out.println("\nEncoding information:");
            System.out.println("Default charset: " + System.getProperty("file.encoding"));
            System.out.println("Is UTF-8 supported? " + StandardCharsets.UTF_8.canEncode());

        } catch (IOException e) {
            System.err.println("Error processing the file: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static void writeToFile(List<String> lines) throws IOException {
        // Write using Files class with UTF-8 encoding
        Files.write(Paths.get(FILE_PATH), lines, StandardCharsets.UTF_8);
    }

    private static List<String> readFromFile() throws IOException {
        // Read using Files class with UTF-8 encoding
        return Files.readAllLines(Paths.get(FILE_PATH), StandardCharsets.UTF_8);
    }
}
  1. Enregistrez le fichier en appuyant sur Ctrl + S ou en sélectionnant Fichier > Enregistrer dans le menu.

  2. Compilez et exécutez le programme en exécutant les commandes suivantes dans le terminal :

javac UnicodeFileDemo.java
java UnicodeFileDemo

Vous devriez voir une sortie similaire à ce qui suit :

Successfully wrote Unicode text to unicode_sample.txt

File contents:
English: Hello, World!
Spanish: ¡Hola, Mundo!
French: Bonjour, le Monde!
German: Hallo, Welt!
Chinese: 你好,世界!
Japanese: こんにちは、世界!
Arabic: مرحبا بالعالم!
Russian: Привет, мир!
Greek: Γειά σου, Κόσμε!
Hindi: नमस्ते, दुनिया!
Emoji: 👋🌍!

Encoding information:
Default charset: UTF-8
Is UTF-8 supported? true

Examiner le fichier de sortie

Jetons un coup d'œil au fichier que nous avons créé :

  1. Utilisez l'explorateur de fichiers du WebIDE pour ouvrir le fichier unicode_sample.txt créé dans le répertoire /home/labex/project.

  2. Vous devriez voir toutes les salutations dans différentes langues, correctement affichées avec leurs caractères Unicode.

Comprendre le code

Ce programme démontre plusieurs points clés concernant le travail avec Unicode dans les fichiers :

  1. Spécification explicite de l'encodage : Nous spécifions explicitement l'encodage UTF - 8 lors de l'écriture et de la lecture du fichier en utilisant StandardCharsets.UTF_8. Cela garantit que les caractères Unicode sont correctement préservés.

  2. E/S de fichiers modernes : Nous utilisons la classe java.nio.file.Files, qui fournit des méthodes pratiques pour lire et écrire des fichiers avec des encodages de caractères spécifiques.

  3. Encodage par défaut : Le programme affiche l'encodage de caractères par défaut du système, qui peut varier en fonction du système d'exploitation et des paramètres régionaux.

  4. Prise en charge des emojis : Le programme inclut un exemple d'emoji (👋🌍) pour démontrer que Java et UTF - 8 peuvent gérer les caractères des plans supplémentaires d'Unicode.

Lorsque vous travaillez avec Unicode dans des fichiers, n'oubliez jamais de :

  • Spécifier explicitement l'encodage (de préférence UTF - 8).
  • Utiliser le même encodage pour la lecture et l'écriture.
  • Gérer les éventuelles IOException qui peuvent se produire lors des opérations sur les fichiers.
  • Être conscient de l'encodage par défaut du système, mais ne pas vous y fier.

Résumé

Dans ce tutoriel, vous avez appris les aspects essentiels du travail avec les caractères Unicode en Java. Voici un récapitulatif de ce que vous avez accompli :

  1. Bases Unicode : Vous avez créé un programme Java de base qui affiche du texte dans plusieurs langues, démontrant le support intégré d'Unicode de Java.

  2. Séquences d'échappement Unicode : Vous avez appris à utiliser les séquences d'échappement Unicode (\uXXXX) pour représenter des caractères et exploré les propriétés des différents types de caractères Unicode.

  3. E/S de fichiers avec Unicode : Vous avez implémenté un programme qui lit et écrit du texte Unicode dans des fichiers, en garantissant un encodage de caractères approprié avec UTF - 8.

En maîtrisant ces concepts, vous êtes maintenant en mesure de développer des applications Java capables de gérer correctement le texte international. Il s'agit d'une compétence cruciale pour créer des logiciels destinés à un public mondial.

Voici quelques points clés à retenir de ce tutoriel :

  • Java utilise l'encodage UTF - 16 en interne pour son type char.
  • Les caractères Unicode peuvent être représentés directement ou à l'aide de séquences d'échappement.
  • Spécifiez toujours l'encodage (de préférence UTF - 8) lors de la lecture ou de l'écriture dans des fichiers.
  • La classe Character fournit des méthodes pour examiner les propriétés des caractères Unicode.
  • Le package NIO (Non - blocking I/O) moderne de Java (java.nio) offre un support solide pour le travail avec Unicode dans les fichiers.

Armé de ces connaissances, vous pouvez créer en toute confiance des applications Java qui fonctionnent parfaitement avec le texte dans n'importe quelle langue.