Unicode is an international character set that encompasses a vast range of characters, symbols, and scripts from many languages across the globe.

Unicode System in Java

Java programming language, being platform-independent, has built-in support for Unicode characters, allowing developers to create applications that can work seamlessly with diverse languages and scripts.

Before Unicode, there were multiple standards to represent character encoding −

• ASCII − for the United States.

• ISO 8859-1 − for Western European Language.

• KOI-8 − for Russian.

• GB18030 and BIG-5 − for Chinese.

So to support multinational application codes, some character was using single byte, some two. An even same code may represent a different character in one language and may represent other characters in another language.

To overcome above shortcoming, the Unicode system was developed where each character is represented by 2 bytes. As Java was developed for multilingual languages it adopted the Unicode system. The lowest value is represented by u0000 and the highest value is represented by uFFFF.

Approaches: Working with Unicode Characters & Values

There are two approaches for working with Unicode characters in Java: Using Unicode Escape Sequences and Directly Storing Unicode Characters.

The first approach involves representing Unicode characters using escape sequences and is useful when the characters cannot be directly typed or displayed in the Java code. The second approach involves directly storing Unicode characters in variables and is more convenient when the characters can be directly typed or displayed.

The choice of approach depends on the specific requirements of the program. However, in general, Approach 2 is simpler and more convenient when the characters can be directly typed or displayed, while Approach 1 is necessary when they cannot.

1. Using Unicode Escape Sequences

One way to store Unicode characters in Java is by using Unicode escape sequences. An escape sequence is a series of characters that represent a special character. In Java, a Unicode escape sequence starts with the characters ”u” followed by four hexadecimal digits that represent the Unicode code point of the desired character.

Example: Use of Unicode Escape Sequences

package com.tutorialspoint;

public class UnicodeCharacterDemo {
   public static void main (String[]args) {   		 
      //Unicode escape sequence
      char unicodeChar = ''u0041'';
      // point for ''A''
      System.out.println("Stored Unicode Character: " + unicodeChar);
   }
}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Character: A

In the above code snippet, the Unicode escape sequence ”u0041” represents the character ”A.” The escape sequence is assigned to the char variable unicodeChar, and the stored character is then printed to the console.

2. Storing Unicode Values Directly

Alternatively, you can directly store a Unicode character in a char variable by enclosing the character in single quotes. However, this approach may not be feasible for characters that cannot be typed directly using a keyboard or are not visible, such as control characters.

Example 1: Assigning Unicode Character to Variable

package com.tutorialspoint;

public class UnicodeCharacterDemo {
   public static void main(String[] args) {
      // Storing Unicode character directly
      char unicodeChar = ''A'';
      // Directly storing the character ''A''
      System.out.println("Stored Unicode Character: " + unicodeChar);
   }
}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Character: A

In this example, the character ”A” is directly enclosed in single quotes and assigned to the char variable unicodeChar. The stored character is then printed to the console.

Example 2: Assigning Unicode Values to Variables

package com.tutorialspoint;

public class UnicodeCharacterDemo {
   public static void main(String[] args) {
      // Storing Unicode characters using escape sequences
      char letterA = ''u0041'';
      char letterSigma = ''u03A3'';
      char copyrightSymbol = ''u00A9'';
      // Storing Unicode characters directly
      char letterZ = ''Z'';
      char letterOmega = ''Ω'';
      char registeredSymbol = ''®'';
      // Printing the stored Unicode characters
      System.out.println("Stored Unicode Characters using Escape Sequences:");
      System.out.println("Letter A: " + letterA);
      System.out.println("Greek Capital Letter Sigma: " + letterSigma);
      System.out.println("Copyright Symbol: " + copyrightSymbol);
      System.out.println("nStored Unicode Characters Directly:");
      System.out.println("Letter Z: " + letterZ);
      System.out.println("Greek Capital Letter Omega: " + letterOmega);
      System.out.println("Registered Symbol: " + registeredSymbol);
   }
}

Compile and run above program. This will produce the following result −

Output

Stored Unicode Characters using Escape Sequences:
Letter A: A
Greek Capital Letter Sigma: Σ
Copyright Symbol: ©

Stored Unicode Characters Directly:
Letter Z: Z
Greek Capital Letter Omega: Ω
Registered Symbol: ®

Example 3: Assigning Unicode Characters and Values to Variables

This example demonstrates how to manipulate the stored Unicode characters. It calculates the difference between the capital letter ”A” and the small letter ”a” and uses that difference to calculate the capital letter ”C.” It then calculates the small letter ”c” by adding 32 to the Unicode code point of the capital letter ”C.” The manipulated Unicode characters are printed to the console.

package com.tutorialspoint;

public class UnicodeCharacterDemo {
   public static void main(String[] args) {
      // Storing Unicode characters using escape sequences
      char letterA = ''u0041'';
      char letterSmallA = ''u0061'';
      // Storing Unicode characters directly
      char letterB = ''B'';

      // Manipulating the stored Unicode characters
      int difference = letterA - letterSmallA;
      char letterC = (char) (letterB + difference);
      char letterSmallC = (char) (letterC + 32);
      // Printing the manipulated Unicode characters
      System.out.println("Manipulated Unicode Characters:");
      System.out.println("Difference between A and a: " + difference);
      System.out.println("Calculated Letter C: " + letterC);
      System.out.println("Calculated Letter c: " + letterSmallC);
   }
}

Compile and run above program. This will produce the following result −

Output

Manipulated Unicode Characters:
Difference between A and a: -32
Calculated Letter C: "
Calculated Letter c: B

Conclusion

In Java, you can store Unicode characters using character literals by employing either Unicode escape sequences or directly enclosing the characters in single quotes. Both approaches have their advantages and limitations. Escape sequences provide a consistent way to represent any Unicode character in the source code, while directly storing characters is more convenient when dealing with characters that can be easily typed or displayed.

This article has provided an algorithm to store Unicode characters in Java, discussed two different approaches for storing these characters, and demonstrated working examples for each approach. Understanding these techniques will help developers create applications that can work seamlessly with diverse languages and scripts, leveraging the power of Unicode in Java programming.