Supported Locales (original) (raw)

| Java | | | | ---------------------------------------------------------------------- | | |

The set of supported locales varies between different implementations of the Java 2 platform as well as between different areas of functionality.

This page documents locale support in Sun's J2SE Development Kit 5.0 (JDK), and J2SE Runtime Environment 5.0 (JRE) in the following areas:

  1. Enabled Locales for java.util and java.text Functionality
  2. Enabled Writing Systems for Java Foundation Classes
    1. Overview
    2. Text Input
    3. Text Rendering
    4. Drag and Drop
  3. User Interface Translation

Sun's J2SE Runtime Environment 5.0 for Windows may be installed as a complete international version or as a European languages version. The JRE installer by default installs a European languages version if it recognizes that the host operating system only supports European languages. If the installer recognizes that any other language is needed, or if the user requests support for non-European languages in a customized installation, a complete international version is installed. The JRE for Solaris and Linux and the JDK for any platform are always installed as complete international versions.


1. Enabled Locales for java.util and java.text Functionality

The support for locale-sensitive behavior in the java.util and java.text packages is almost entirely platform independent, so all locales are supported in the same way and simultaneously, independent of the host operating system and its localization. The only platform dependent functionality is the setting of the initial default locale and the initial default time zone based on the host operating system's locale and time zone.

Sun's J2SE Development Kit 5.0 and the international versions of the J2SE Runtime Environment 5.0 support all locales shown below. The European languages version of the J2SE Runtime Environment 5.0 supports all locales for the following languages: Albanian, Belorussian, Bulgarian, Catalan, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Icelandic, Italian, Latvian, Lithuanian, Macedonian, Norwegian, Polish, Portuguese, Romanian, Russian, Slovak, Slovenian, Spanish, Swedish, Turkish, Ukrainian.

Fully Supported Locales

Language Country Locale ID
Arabic Saudi Arabia ar_SA
Chinese (Simplified) China zh_CN
Chinese (Traditional) Taiwan zh_TW
Dutch Netherlands nl_NL
English Australia en_AU
English Canada en_CA
English United Kingdom en_GB
English United States en_US
French Canada fr_CA
French France fr_FR
German Germany de_DE
Hebrew Israel iw_IL
Hindi India hi_IN
Italian Italy it_IT
Japanese Japan ja_JP
Korean South Korea ko_KR
Portuguese Brazil pt_BR
Spanish Spain es_ES
Swedish Sweden sv_SE
Thai (Western digits) Thailand th_TH
Thai (Thai digits) Thailand th_TH_TH

Also Provided, but not Tested

Language Country Locale ID
Albanian Albania sq_AL
Arabic Algeria ar_DZ
Arabic Bahrain ar_BH
Arabic Egypt ar_EG
Arabic Iraq ar_IQ
Arabic Jordan ar_JO
Arabic Kuwait ar_KW
Arabic Lebanon ar_LB
Arabic Libya ar_LY
Arabic Morocco ar_MA
Arabic Oman ar_OM
Arabic Qatar ar_QA
Arabic Sudan ar_SD
Arabic Syria ar_SY
Arabic Tunisia ar_TN
Arabic United Arab Emirates ar_AE
Arabic Yemen ar_YE
Belorussian Belorussia be_BY
Bulgarian Bulgaria bg_BG
Catalan Spain ca_ES
Chinese Hong Kong zh_HK
Croatian Croatia hr_HR
Czech Czech Republic cs_CZ
Danish Denmark da_DK
Dutch Belgium nl_BE
English India en_IN
English Ireland en_IE
English New Zealand en_NZ
English South Africa en_ZA
Estonian Estonia et_EE
Finnish Finland fi_FI
French Belgium fr_BE
French Luxembourg fr_LU
French Switzerland fr_CH
German Austria de_AT
German Luxembourg de_LU
German Switzerland de_CH
Greek Greece el_GR
Hungarian Hungary hu_HU
Icelandic Iceland is_IS
Italian Switzerland it_CH
Latvian Latvia lv_LV
Lithuanian Lithuania lt_LT
Macedonian Macedonia mk_MK
Norwegian (Bokmål) Norway no_NO
Norwegian (Nynorsk) Norway no_NO_NY
Polish Poland pl_PL
Portuguese Portugal pt_PT
Romanian Romania ro_RO
Russian Russia ru_RU
Slovak Slovakia sk_SK
Slovenian Slovenia sl_SI
Spanish Argentina es_AR
Spanish Bolivia es_BO
Spanish Chile es_CL
Spanish Colombia es_CO
Spanish Costa Rica es_CR
Spanish Dominican Republic es_DO
Spanish Ecuador es_EC
Spanish El Salvador es_SV
Spanish Guatemala es_GT
Spanish Honduras es_HN
Spanish Mexico es_MX
Spanish Nicaragua es_NI
Spanish Panama es_PA
Spanish Paraguay es_PY
Spanish Peru es_PE
Spanish Puerto Rico es_PR
Spanish Uruguay es_UY
Spanish Venezuela es_VE
Turkish Turkey tr_TR
Ukrainian Ukraine uk_UA
Vietnamese Vietnam vi_VN

2. Enabled Writing Systems for Java Foundation Classes

2.1 Overview

For the Java Foundation Classes (AWT, Swing, 2D, input method framework, drag and drop), locales can generally be characterized by just the writing system; there are no country or language specific distinctions. Writing system support in the JFC depends to some extent on the host operating system, and full support for simultaneous use of multiple languages is not always possible.

We consider a writing system supported by JFC if all functionality provided by JFC works adequately for this writing system in the following situations:

Sun's J2SE Development Kit 5.0 and the international version of the J2SE Runtime Environment 5.0 support all writing systems shown below. The European languages version of the J2SE Runtime Environment 5.0 supports only the Cyrillic, Greek, and Latin writing systems. Peered AWT components are only supported for a subset of the writing systems - see the last column.

Details on various areas of functionality are provided in the sections below.

Fully Supported Writing Systems

Writing System Languages Windows Encodings Solaris Encodings Linux Encodings Peered AWT Components
Arabic Arabic 1256 8859-6 UTF-8(4) unsupported
Chinese (Simplified) Chinese 936, GB18030 gb2312, UTF-8, GBK, gb18030 GBK(2)(3), GB18030(2)(3)(4)(5)(7), UTF-8(2)(3) supported
Chinese (Traditional) Chinese 950, HKSCS cns11643, UTF-8, BIG5, BIG5HK Big5(2)(3)(4)(5), Big5-HKSCS(2)(3), x-EUC-TW(2)(3), UTF-8(2)(3) supported
Devanagari Hindi UTF-8 UTF-8 unsupported unsupported
Hebrew Hebrew 1255 8859-8 UTF-8(4) unsupported
Japanese Japanese 932 eucJP(1), UTF-8, PCK eucJP(1)(2)(3)(4)(5)(7), UTF-8(2)(3) supported
Korean Korean 949 5601, UTF-8 EUC-KR(3)(4)(5), UTF-8(3) supported
Latin - Western European subset English, French, German, Italian, Spanish, Swedish, etc. 1252 8859-1, 8859-15 UTF-8(2)(3)(4)(5), ISO-8859-1(6) supported
Thai Thai 874 TIS620.2533, UTF-8 unsupported unsupported

(1) eucJP on Solaris supports the JIS character sets X 0201, X 0208, and X 0212; eucJP on Linux only X 0201 and X 0208.
(2) on Sun Java Desktop System 2003.
(3) on Sun Java Desktop System Release 2.
(4) on Red Hat Linux 9.0.
(5) on Red Hat Enterprise Linux AS 3.0.
(6) on SuSE Linux 9.0, SuSE Linux Enterprise Server 8.
(7) on Turbolinux 10 Desktop.

Also Provided, but not Tested

Writing System Languages Windows Code Page Solaris Encodings Linux Encodings Peered AWT Components
Chinese (Simplified) Chinese (see above) (see above) GB2312(3)(4), GBK (4), GB18030(2)(4), UTF-8(4) supported
Chinese (Traditional) Chinese (see above) (see above) Big5(2)(3)(4), Big5-HKSCS(4), UTF-8(4) supported
Cyrillic Belorussian, Russian etc. 1251 8859-5, KOI8-R, ANSI1251 unsupported supported
Greek Greek 1253 8859-7 unsupported supported
Japanese Japanese (see above) (see above) eucJP(1)(2)(3)(4), UTF-8(4) supported
Korean Korean (see above) (see above) EUC-KR(2)(3) supported
Latin - Baltic subset Latvian, Lithuanian 1257 8859-13 unsupported supported
Latin - Central European subset Czech, Hungarian, Polish, etc. 1250 8859-2 unsupported supported
Latin - Turkic subset Turkish etc. 1254 8859-9 unsupported supported
Latin - Western European subset English, French, German, Italian, Spanish, Swedish, etc. (see above) (see above) ISO-8859-1(3), UTF-8(2) supported

(1) eucJP on Solaris supports the JIS character sets X 0201, X 0208, and X 0212; eucJP on Linux only X 0201 and X 0208.
(2) on Red Hat Linux 8.0.
(3) on Red Hat Enterprise Linux AS 2.1.
(4) on Turbolinux 8 Workstation.

2.2 Text Input

Support for text input consists of two parts: interpretation of keyboard layouts, and text composition using input methods. For interpretation of keyboard layouts, the Java 2 platform relies entirely on the host operating system. For text composition using input methods, Java 2 platform supports native input methods using the host operating system's input method manager as well as input methods developed in the Java programming language.

Locale support in input methods implemented in the Java programming language depends solely on the set of installed input methods, not on the host operating system and its localization. However, support for the use of input methods implemented in the Java programming language with peered components is implementation dependent - see below.

Support for keyboard layouts and and native input methods varies between platforms.

Windows

On Windows 98 and ME, the JRE supports use of any keyboard layout or IMM-based input method that can be installed into a particular localized version of the host operating system.

On Windows 2000, XP, and 2003, the JRE supports use of any keyboard layout or IMM-based input method.

Global IME is not supported.

Input methods implemented in the Java programming language are supported in all components on all versions of Windows.

Solaris and Linux

The JRE supports use of any keyboard layout or input method that can be used with a particular Solaris or Linux locale.

Input methods implemented in the Java programming language are supported in lightweight components (such as Swing text components), but not in peered components (such as AWT text components).

2.3 Text Rendering

Applications have two options for selecting fonts:

Text Rendering in Lightweight Components

When using logical font names, text in at least the writing system of the host locale and the Western European subset of the Latin writing system is supported.

When using physical fonts, we need to distinguish between simple and complex writing systems. Simple writing systems have a one-to-one mapping from characters to glyphs, and glyphs are placed on the baseline continuously from left to right. Complex writing systems may use different glyphs for the same character based on context, may for ligatures, may be written from right to left, and may reorder glyphs during line layout, or may have other rules for placing glyphs (in particular for combining marks).

The 2D text rendering system supports any combination of simple writing systems and the complex writing systems listed in thetable above. Within these limitations, the range of supported writing systems is determined by the font. A single TrueType font might provide glyphs covering the entire Unicode character set and a Unicode based character-to-glyph mapping. Given such a font, 2D can support all simple writing systems as well as the complex writing systems shown in the table above. Other complex writing systems are not supported.

Text Rendering in Peered Components

When using logical font names, text in at least the writing system of the host operating system's locale is supported.

Physical fonts are not supported in peered components.

Text Rendering in Printing

There are three printing APIs:

Text rendering using the AWT and 2D printing API works to the same extent as text rendering on the screen. Text rendering using the pluggable services printing API depends on the printing service used; the services provided by the JRE work to the same extent as text rendering on the screen.

2.4 Drag and Drop

On Windows 98 and ME, text in the writing system of the host operating system's localization can be transferred between applications.

On Windows 2000, XP, and 2003, arbitrary Unicode text can be transferred between applications.

On Solaris and Linux, text in the character encoding of the host operating system's locale can be transferred between applications.

Applications that need to transfer arbitrary Unicode text independent of the host operating system, can do so using serialization: Create a Transferable which supports only one flavor: DataFlavor.stringFlavor. This flavor represents the serialized representation of a String. Make sure that the target supports stringFlavor as well. When the transfer occurs, the AWT will serialize out the String on one end and deserialize on the other. This is much slower than a native platform text transfer, but it will succeed where native transfers may not.


3. User Interface Translation

Java 2 Runtime Environment

The user interface elements provided by the J2SE Runtime Environment 5.0, include Swing dialogs, messages written by the runtime environment to the standard output and standard error streams, as well as messages produced by the tools provided with the JRE. These user interface elements are localized into the following languages:

Language Locale ID
Chinese (Simplified) zh_CN
Chinese (Traditional) zh_TW
English en
French fr
German de
Italian it
Japanese ja
Korean ko
Spanish es
Swedish sv

Java 2 Software Development Kit

The user interface elements provided by the J2SE Development Kit 5.0, include messages produced by the tools that are only part of the JDK in addition to the elements provided by the JRE. The additional user interface elements are localized into the following languages:

Language Locale ID
English en
Japanese ja

Copyright © 2004 Sun Microsystems, Inc. All rights reserved. Contact us Sun