Note: The Locale class does not provide any syntactic restrictions on variant, while BCP 47 requires each variant subtag to be 5 to 8 alphanumerics or a single numeric followed by 3 alphanumerics. The method setVariant throws IllformedLocaleException for a variant that does not satisfy this restriction. If it is necessary to support such a variant, use a Locale constructor. However, keep in mind that a Locale object created this way might lose the variant information when transformed to a BCP 47 language tag.

The following example shows how to create a Locale object with the Builder.

    Locale aLocale = new Builder().setLanguage("sr").setScript("Latn").setRegion("RS").build();

Builders can be reused; clear() resets all fields to their default values. 

since: 1.6 -

Also see:

getExtension(char)
Builder#setExtension(char, String)
since: 1.7 -

Also see:

getExtension(char)
Builder#setExtension(char, String)
since: 1.7 -

 public Locale(String language) 
{
        this(language, "", "");
}

Construct a locale from a language code. This constructor normalizes the language value to lowercase.

Note:

• ISO 639 is not a stable standard; some of the language codes it defines (specifically "iw", "ji", and "in") have changed. This constructor accepts both the old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other API on Locale will return only the OLD codes.
• For backward compatibility reasons, this constructor does not make any syntactic checks on the input.

Parameters:

language - An ISO 639 alpha-2 or alpha-3 language code, or a language subtag up to 8 characters in length. See the Locale class description about valid language values.

Throws:

NullPointerException - thrown if argument is null.

exception: NullPointerException - thrown if argument is null.

since: 1.4 -

 public Locale(String language,
    String country) 
{
        this(language, country, "");
}

Construct a locale from language and country. This constructor normalizes the language value to lowercase and the country value to uppercase.

Note:

• ISO 639 is not a stable standard; some of the language codes it defines (specifically "iw", "ji", and "in") have changed. This constructor accepts both the old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other API on Locale will return only the OLD codes.
• For backward compatibility reasons, this constructor does not make any syntactic checks on the input.

Parameters:

language - An ISO 639 alpha-2 or alpha-3 language code, or a language subtag up to 8 characters in length. See the Locale class description about valid language values.

country - An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. See the Locale class description about valid country values.

Throws:

NullPointerException - thrown if either argument is null.

exception: NullPointerException - thrown if either argument is null.

 public Locale(String language,
    String country,
    String variant) 
{
        if (language== null || country == null || variant == null) {
            throw new NullPointerException();
        }
        baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), "", country, variant);
        localeExtensions = getCompatibilityExtensions(language, "", country, variant);
}

Construct a locale from language, country and variant. This constructor normalizes the language value to lowercase and the country value to uppercase.

Note:

• ISO 639 is not a stable standard; some of the language codes it defines (specifically "iw", "ji", and "in") have changed. This constructor accepts both the old codes ("iw", "ji", and "in") and the new codes ("he", "yi", and "id"), but all other API on Locale will return only the OLD codes.
• For backward compatibility reasons, this constructor does not make any syntactic checks on the input.
• The two cases ("ja", "JP", "JP") and ("th", "TH", "TH") are handled specially, see Special Cases for more information.

Parameters:

language - An ISO 639 alpha-2 or alpha-3 language code, or a language subtag up to 8 characters in length. See the Locale class description about valid language values.

country - An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. See the Locale class description about valid country values.

variant - Any arbitrary value used to indicate a variation of a Locale. See the Locale class description for the details.

Throws:

NullPointerException - thrown if any argument is null.

exception: NullPointerException - thrown if any argument is null.

 public Object clone() 
{
        try {
            Locale that = (Locale)super.clone();
            return that;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
}

Overrides Cloneable.

 public boolean equals(Object obj) 
{
        if (this == obj)                      // quick check
            return true;
        if (!(obj instanceof Locale))
            return false;
        BaseLocale otherBase = ((Locale)obj).baseLocale;
        if (!baseLocale.equals(otherBase)) {
            return false;
        }
        if (localeExtensions == null) {
            return ((Locale)obj).localeExtensions == null;
        }
        return localeExtensions.equals(((Locale)obj).localeExtensions);
}

Returns true if this Locale is equal to another object. A Locale is deemed equal to another Locale with identical language, script, country, variant and extensions, and unequal to all other objects.

 public static Locale forLanguageTag(String languageTag) 
{
        LanguageTag tag = LanguageTag.parse(languageTag, null);
        InternalLocaleBuilder bldr = new InternalLocaleBuilder();
        bldr.setLanguageTag(tag);
        BaseLocale base = bldr.getBaseLocale();
        LocaleExtensions exts = bldr.getLocaleExtensions();
        if (exts == null && base.getVariant().length()  > 0) {
            exts = getCompatibilityExtensions(base.getLanguage(), base.getScript(),
                                              base.getRegion(), base.getVariant());
        }
        return getInstance(base, exts);
}

Returns a locale for the specified IETF BCP 47 language tag string.

If the specified language tag contains any ill-formed subtags, the first such subtag and all following subtags are ignored. Compare to Locale.Builder#setLanguageTag which throws an exception in this case.

The following conversions are performed:

• The language code "und" is mapped to language "".
• The language codes "he", "yi", and "id" are mapped to "iw", "ji", and "in" respectively. (This is the same canonicalization that's done in Locale's constructors.)
• The portion of a private use subtag prefixed by "lvariant", if any, is removed and appended to the variant field in the result locale (without case normalization). If it is then empty, the private use subtag is discarded:

      Locale loc;
      loc = Locale.forLanguageTag("en-US-x-lvariant-POSIX");
      loc.getVariant(); // returns "POSIX"
      loc.getExtension('x'); // returns null
  
      loc = Locale.forLanguageTag("de-POSIX-x-URP-lvariant-Abc-Def");
      loc.getVariant(); // returns "POSIX_Abc_Def"
      loc.getExtension('x'); // returns "urp"
  

• When the languageTag argument contains an extlang subtag, the first such subtag is used as the language, and the primary language subtag and other extlang subtags are ignored:

      Locale.forLanguageTag("ar-aao").getLanguage(); // returns "aao"
      Locale.forLanguageTag("en-abc-def-us").toString(); // returns "abc_US"
  

• Case is normalized except for variant tags, which are left unchanged. Language is normalized to lower case, script to title case, country to upper case, and extensions to lower case.
• If, after processing, the locale would exactly match either ja_JP_JP or th_TH_TH with no extensions, the appropriate extensions are added as though the constructor had been called:

     Locale.forLanguageTag("ja-JP-x-lvariant-JP").toLanguageTag();
     // returns "ja-JP-u-ca-japanese-x-lvariant-JP"
     Locale.forLanguageTag("th-TH-x-lvariant-TH").toLanguageTag();
     // returns "th-TH-u-nu-thai-x-lvariant-TH"
  

This implements the 'Language-Tag' production of BCP47, and so supports grandfathered (regular and irregular) as well as private use language tags. Stand alone private use tags are represented as empty language and extension 'x-whatever', and grandfathered tags are converted to their canonical replacements where they exist.

Grandfathered tags with canonical replacements are as follows:

grandfathered tag		modern replacement
art-lojban		jbo
i-ami		ami
i-bnn		bnn
i-hak		hak
i-klingon		tlh
i-lux		lb
i-navajo		nv
i-pwn		pwn
i-tao		tao
i-tay		tay
i-tsu		tsu
no-bok		nb
no-nyn		nn
sgn-BE-FR		sfb
sgn-BE-NL		vgt
sgn-CH-DE		sgg
zh-guoyu		cmn
zh-hakka		hak
zh-min-nan		nan
zh-xiang		hsn

Grandfathered tags with no modern replacement will be converted as follows:

grandfathered tag		converts to
cel-gaulish		xtg-x-cel-gaulish
en-GB-oed		en-GB-x-oed
i-default		en-x-i-default
i-enochian		und-x-i-enochian
i-mingo		see-x-i-mingo
zh-min		nan-x-zh-min

For a list of all grandfathered tags, see the IANA Language Subtag Registry (search for "Type: grandfathered").

Note: there is no guarantee that toLanguageTag and forLanguageTag will round-trip.

 public static Locale[] getAvailableLocales() 
{
        return LocaleServiceProviderPool.getAllAvailableLocales();
}

Returns an array of all installed locales. The returned array represents the union of locales supported by the Java runtime environment and by installed LocaleServiceProvider implementations. It must contain at least a Locale instance equal to Locale.US .

 BaseLocale getBaseLocale() 
{
        return baseLocale;
}

Package locale method returning the Locale's BaseLocale, used by ResourceBundle

 public String getCountry() 
{
        return baseLocale.getRegion();
}

Returns the country/region code for this locale, which should either be the empty string, an uppercase ISO 3166 2-letter code, or a UN M.49 3-digit code.

 public static Locale getDefault() 
{
        // do not synchronize this method - see 4071298
        // it's OK if more than one default locale happens to be created
        if (defaultLocale == null) {
            initDefault();
        }
        return defaultLocale;
}

Gets the current value of the default locale for this instance of the Java Virtual Machine.

The Java Virtual Machine sets the default locale during startup based on the host environment. It is used by many locale-sensitive methods if no locale is explicitly specified. It can be changed using the setDefault method.

 public static Locale getDefault(Category category) 
{
        // do not synchronize this method - see 4071298
        // it's OK if more than one default locale happens to be created
        switch (category) {
        case DISPLAY:
            if (defaultDisplayLocale == null) {
                initDefault(category);
            }
            return defaultDisplayLocale;
        case FORMAT:
            if (defaultFormatLocale == null) {
                initDefault(category);
            }
            return defaultFormatLocale;
        default:
            assert false: "Unknown Category";
        }
        return getDefault();
}

Gets the current value of the default locale for the specified Category for this instance of the Java Virtual Machine.

The Java Virtual Machine sets the default locale during startup based on the host environment. It is used by many locale-sensitive methods if no locale is explicitly specified. It can be changed using the setDefault(Locale.Category, Locale) method.

 public final String getDisplayCountry() 
{
        return getDisplayCountry(getDefault(Category.DISPLAY));
}

Returns a name for the locale's country that is appropriate for display to the user. If possible, the name returned will be localized for the default locale. For example, if the locale is fr_FR and the default locale is en_US, getDisplayCountry() will return "France"; if the locale is en_US and the default locale is fr_FR, getDisplayCountry() will return "Etats-Unis". If the name returned cannot be localized for the default locale, (say, we don't have a Japanese name for Croatia), this function falls back on the English name, and uses the ISO code as a last-resort value. If the locale doesn't specify a country, this function returns the empty string.

 public String getDisplayCountry(Locale inLocale) 
{
        return getDisplayString(baseLocale.getRegion(), inLocale, DISPLAY_COUNTRY);
}

Returns a name for the locale's country that is appropriate for display to the user. If possible, the name returned will be localized according to inLocale. For example, if the locale is fr_FR and inLocale is en_US, getDisplayCountry() will return "France"; if the locale is en_US and inLocale is fr_FR, getDisplayCountry() will return "Etats-Unis". If the name returned cannot be localized according to inLocale. (say, we don't have a Japanese name for Croatia), this function falls back on the English name, and finally on the ISO code as a last-resort value. If the locale doesn't specify a country, this function returns the empty string.

 public final String getDisplayLanguage() 
{
        return getDisplayLanguage(getDefault(Category.DISPLAY));
}

Returns a name for the locale's language that is appropriate for display to the user. If possible, the name returned will be localized for the default locale. For example, if the locale is fr_FR and the default locale is en_US, getDisplayLanguage() will return "French"; if the locale is en_US and the default locale is fr_FR, getDisplayLanguage() will return "anglais". If the name returned cannot be localized for the default locale, (say, we don't have a Japanese name for Croatian), this function falls back on the English name, and uses the ISO code as a last-resort value. If the locale doesn't specify a language, this function returns the empty string.

 public String getDisplayLanguage(Locale inLocale) 
{
        return getDisplayString(baseLocale.getLanguage(), inLocale, DISPLAY_LANGUAGE);
}

Returns a name for the locale's language that is appropriate for display to the user. If possible, the name returned will be localized according to inLocale. For example, if the locale is fr_FR and inLocale is en_US, getDisplayLanguage() will return "French"; if the locale is en_US and inLocale is fr_FR, getDisplayLanguage() will return "anglais". If the name returned cannot be localized according to inLocale, (say, we don't have a Japanese name for Croatian), this function falls back on the English name, and finally on the ISO code as a last-resort value. If the locale doesn't specify a language, this function returns the empty string.

 public final String getDisplayName() 
{
        return getDisplayName(getDefault(Category.DISPLAY));
}

Returns a name for the locale that is appropriate for display to the user. This will be the values returned by getDisplayLanguage(), getDisplayScript(), getDisplayCountry(), and getDisplayVariant() assembled into a single string. The the non-empty values are used in order, with the second and subsequent names in parentheses. For example:

language (script, country, variant)
language (country)
language (variant)
script (country)
country


depending on which fields are specified in the locale. If the language, sacript, country, and variant fields are all empty, this function returns the empty string.

 public String getDisplayName(Locale inLocale) 
{
        OpenListResourceBundle bundle = LocaleData.getLocaleNames(inLocale);
        String languageName = getDisplayLanguage(inLocale);
        String scriptName = getDisplayScript(inLocale);
        String countryName = getDisplayCountry(inLocale);
        String[] variantNames = getDisplayVariantArray(bundle, inLocale);
        // Get the localized patterns for formatting a display name.
        String displayNamePattern = null;
        String listPattern = null;
        String listCompositionPattern = null;
        try {
            displayNamePattern = bundle.getString("DisplayNamePattern");
            listPattern = bundle.getString("ListPattern");
            listCompositionPattern = bundle.getString("ListCompositionPattern");
        } catch (MissingResourceException e) {
        }
        // The display name consists of a main name, followed by qualifiers.
        // Typically, the format is "MainName (Qualifier, Qualifier)" but this
        // depends on what pattern is stored in the display locale.
        String   mainName       = null;
        String[] qualifierNames = null;
        // The main name is the language, or if there is no language, the script,
        // then if no script, the country. If there is no language/script/country
        // (an anomalous situation) then the display name is simply the variant's
        // display name.
        if (languageName.length() == 0 && scriptName.length() == 0 && countryName.length() == 0) {
            if (variantNames.length == 0) {
                return "";
            } else {
                return formatList(variantNames, listPattern, listCompositionPattern);
            }
        }
        ArrayList< String > names = new ArrayList<  >(4);
        if (languageName.length() != 0) {
            names.add(languageName);
        }
        if (scriptName.length() != 0) {
            names.add(scriptName);
        }
        if (countryName.length() != 0) {
            names.add(countryName);
        }
        if (variantNames.length != 0) {
            for (String var : variantNames) {
                names.add(var);
            }
        }
        // The first one in the main name
        mainName = names.get(0);
        // Others are qualifiers
        int numNames = names.size();
        qualifierNames = (numNames  > 1) ?
                names.subList(1, numNames).toArray(new String[numNames - 1]) : new String[0];
        // Create an array whose first element is the number of remaining
        // elements.  This serves as a selector into a ChoiceFormat pattern from
        // the resource.  The second and third elements are the main name and
        // the qualifier; if there are no qualifiers, the third element is
        // unused by the format pattern.
        Object[] displayNames = {
            new Integer(qualifierNames.length != 0 ? 2 : 1),
            mainName,
            // We could also just call formatList() and have it handle the empty
            // list case, but this is more efficient, and we want it to be
            // efficient since all the language-only locales will not have any
            // qualifiers.
            qualifierNames.length != 0 ? formatList(qualifierNames, listPattern, listCompositionPattern) : null
        };
        if (displayNamePattern != null) {
            return new MessageFormat(displayNamePattern).format(displayNames);
        }
        else {
            // If we cannot get the message format pattern, then we use a simple
            // hard-coded pattern.  This should not occur in practice unless the
            // installation is missing some core files (FormatData etc.).
            StringBuilder result = new StringBuilder();
            result.append((String)displayNames[1]);
            if (displayNames.length  > 2) {
                result.append(" (");
                result.append((String)displayNames[2]);
                result.append(')');
            }
            return result.toString();
        }
}

Returns a name for the locale that is appropriate for display to the user. This will be the values returned by getDisplayLanguage(), getDisplayScript(),getDisplayCountry(), and getDisplayVariant() assembled into a single string. The non-empty values are used in order, with the second and subsequent names in parentheses. For example:

language (script, country, variant)
language (country)
language (variant)
script (country)
country


depending on which fields are specified in the locale. If the language, script, country, and variant fields are all empty, this function returns the empty string.

 public String getDisplayScript() 
{
        return getDisplayScript(getDefault());
}

Returns a name for the the locale's script that is appropriate for display to the user. If possible, the name will be localized for the default locale. Returns the empty string if this locale doesn't specify a script code.

 public String getDisplayScript(Locale inLocale) 
{
        return getDisplayString(baseLocale.getScript(), inLocale, DISPLAY_SCRIPT);
}

Returns a name for the locale's script that is appropriate for display to the user. If possible, the name will be localized for the given locale. Returns the empty string if this locale doesn't specify a script code.

 public final String getDisplayVariant() 
{
        return getDisplayVariant(getDefault(Category.DISPLAY));
}

Returns a name for the locale's variant code that is appropriate for display to the user. If possible, the name will be localized for the default locale. If the locale doesn't specify a variant code, this function returns the empty string.

 public String getDisplayVariant(Locale inLocale) 
{
        if (baseLocale.getVariant().length() == 0)
            return "";
        OpenListResourceBundle bundle = LocaleData.getLocaleNames(inLocale);
        String names[] = getDisplayVariantArray(bundle, inLocale);
        // Get the localized patterns for formatting a list, and use
        // them to format the list.
        String listPattern = null;
        String listCompositionPattern = null;
        try {
            listPattern = bundle.getString("ListPattern");
            listCompositionPattern = bundle.getString("ListCompositionPattern");
        } catch (MissingResourceException e) {
        }
        return formatList(names, listPattern, listCompositionPattern);
}

Returns a name for the locale's variant code that is appropriate for display to the user. If possible, the name will be localized for inLocale. If the locale doesn't specify a variant code, this function returns the empty string.

 public String getExtension(char key) 
{
        if (!LocaleExtensions.isValidKey(key)) {
            throw new IllegalArgumentException("Ill-formed extension key: " + key);
        }
        return (localeExtensions == null) ? null : localeExtensions.getExtensionValue(key);
}

Returns the extension (or private use) value associated with the specified key, or null if there is no extension associated with the key. To be well-formed, the key must be one of [0-9A-Za-z]. Keys are case-insensitive, so for example 'z' and 'Z' represent the same extension.

 public Set<Character> getExtensionKeys() 
{
        if (localeExtensions == null) {
            return Collections.emptySet();
        }
        return localeExtensions.getKeys();
}

Returns the set of extension keys associated with this locale, or the empty set if it has no extensions. The returned set is unmodifiable. The keys will all be lower-case.

 public String getISO3Country() throws MissingResourceException 
{
        String country3 = getISO3Code(baseLocale.getRegion(), LocaleISOData.isoCountryTable);
        if (country3 == null) {
            throw new MissingResourceException("Couldn't find 3-letter country code for "
                    + baseLocale.getRegion(), "FormatData_" + toString(), "ShortCountry");
        }
        return country3;
}

Returns a three-letter abbreviation for this locale's country. If the country matches an ISO 3166-1 alpha-2 code, the corresponding ISO 3166-1 alpha-3 uppercase code is returned. If the locale doesn't specify a country, this will be the empty string.

The ISO 3166-1 codes can be found on-line.

 public String getISO3Language() throws MissingResourceException 
{
        String lang = baseLocale.getLanguage();
        if (lang.length() == 3) {
            return lang;
        }
        String language3 = getISO3Code(lang, LocaleISOData.isoLanguageTable);
        if (language3 == null) {
            throw new MissingResourceException("Couldn't find 3-letter language code for "
                    + lang, "FormatData_" + toString(), "ShortLanguage");
        }
        return language3;
}

Returns a three-letter abbreviation of this locale's language. If the language matches an ISO 639-1 two-letter code, the corresponding ISO 639-2/T three-letter lowercase code is returned. The ISO 639-2 language codes can be found on-line, see "Codes for the Representation of Names of Languages Part 2: Alpha-3 Code". If the locale specifies a three-letter language, the language is returned as is. If the locale does not specify a language the empty string is returned.

 public static String[] getISOCountries() 
{
        if (isoCountries == null) {
            isoCountries = getISO2Table(LocaleISOData.isoCountryTable);
        }
        String[] result = new String[isoCountries.length];
        System.arraycopy(isoCountries, 0, result, 0, isoCountries.length);
        return result;
}

Returns a list of all 2-letter country codes defined in ISO 3166. Can be used to create Locales.

Note: The Locale class also supports other codes for country (region), such as 3-letter numeric UN M.49 area codes. Therefore, the list returned by this method does not contain ALL valid codes that can be used to create Locales.

 public static String[] getISOLanguages() 
{
        if (isoLanguages == null) {
            isoLanguages = getISO2Table(LocaleISOData.isoLanguageTable);
        }
        String[] result = new String[isoLanguages.length];
        System.arraycopy(isoLanguages, 0, result, 0, isoLanguages.length);
        return result;
}

Returns a list of all 2-letter language codes defined in ISO 639. Can be used to create Locales.

Note:

• ISO 639 is not a stable standard— some languages' codes have changed. The list this function returns includes both the new and the old codes for the languages whose codes have changed.
• The Locale class also supports language codes up to 8 characters in length. Therefore, the list returned by this method does not contain ALL valid codes that can be used to create Locales.

 static Locale getInstance(BaseLocale baseloc,
    LocaleExtensions extensions) 
{
        LocaleKey key = new LocaleKey(baseloc, extensions);
        return LOCALECACHE.get(key);
}

 static Locale getInstance(String language,
    String country,
    String variant) 
{
        return getInstance(language, "", country, variant, null);
}

Returns a Locale constructed from the given language, country and variant. If the same Locale instance is available in the cache, then that instance is returned. Otherwise, a new Locale instance is created and cached.

 static Locale getInstance(String language,
    String script,
    String country,
    String variant,
    LocaleExtensions extensions) 
{
        if (language== null || script == null || country == null || variant == null) {
            throw new NullPointerException();
        }
        if (extensions == null) {
            extensions = getCompatibilityExtensions(language, script, country, variant);
        }
        BaseLocale baseloc = BaseLocale.getInstance(language, script, country, variant);
        return getInstance(baseloc, extensions);
}

 public String getLanguage() 
{
        return baseLocale.getLanguage();
}

Returns the language code of this Locale.

Note: ISO 639 is not a stable standard— some languages' codes have changed. Locale's constructor recognizes both the new and the old codes for the languages whose codes have changed, but this function always returns the old code. If you want to check for a specific language whose code has changed, don't do

if (locale.getLanguage().equals("he")) // BAD!
   ...

Instead, do

if (locale.getLanguage().equals(new Locale("he").getLanguage()))
   ...

 LocaleExtensions getLocaleExtensions() 
{
         return localeExtensions;
}

Package private method returning the Locale's LocaleExtensions, used by ResourceBundle.

 public String getScript() 
{
        return baseLocale.getScript();
}

Returns the script for this locale, which should either be the empty string or an ISO 15924 4-letter script code. The first letter is uppercase and the rest are lowercase, for example, 'Latn', 'Cyrl'.

 public Set<String> getUnicodeLocaleAttributes() 
{
        if (localeExtensions == null) {
            return Collections.emptySet();
        }
        return localeExtensions.getUnicodeLocaleAttributes();
}

Returns the set of unicode locale attributes associated with this locale, or the empty set if it has no attributes. The returned set is unmodifiable.

 public Set<String> getUnicodeLocaleKeys() 
{
        if (localeExtensions == null) {
            return Collections.emptySet();
        }
        return localeExtensions.getUnicodeLocaleKeys();
}

Returns the set of Unicode locale keys defined by this locale, or the empty set if this locale has none. The returned set is immutable. Keys are all lower case.

 public String getUnicodeLocaleType(String key) 
{
        if (!UnicodeLocaleExtension.isKey(key)) {
            throw new IllegalArgumentException("Ill-formed Unicode locale key: " + key);
        }
        return (localeExtensions == null) ? null : localeExtensions.getUnicodeLocaleType(key);
}

Returns the Unicode locale type associated with the specified Unicode locale key for this locale. Returns the empty string for keys that are defined with no type. Returns null if the key is not defined. Keys are case-insensitive. The key must be two alphanumeric characters ([0-9a-zA-Z]), or an IllegalArgumentException is thrown.

 public String getVariant() 
{
        return baseLocale.getVariant();
}

Returns the variant code for this locale.

 public int hashCode() 
{
        int hc = hashCodeValue;
        if (hc == 0) {
            hc = baseLocale.hashCode();
            if (localeExtensions != null) {
                hc ^= localeExtensions.hashCode();
            }
            hashCodeValue = hc;
        }
        return hc;
}

Override hashCode. Since Locales are often used in hashtables, caches the value for speed.

 public static synchronized  void setDefault(Locale newLocale) 
{
        setDefault(Category.DISPLAY, newLocale);
        setDefault(Category.FORMAT, newLocale);
        defaultLocale = newLocale;
}

Sets the default locale for this instance of the Java Virtual Machine. This does not affect the host locale.

If there is a security manager, its checkPermission method is called with a PropertyPermission("user.language", "write") permission before the default locale is changed.

The Java Virtual Machine sets the default locale during startup based on the host environment. It is used by many locale-sensitive methods if no locale is explicitly specified.

Since changing the default locale may affect many different areas of functionality, this method should only be used if the caller is prepared to reinitialize locale-sensitive code running within the same Java Virtual Machine.

By setting the default locale with this method, all of the default locales for each Category are also set to the specified default locale.

 public static synchronized  void setDefault(Category category,
    Locale newLocale) 
{
        if (category == null)
            throw new NullPointerException("Category cannot be NULL");
        if (newLocale == null)
            throw new NullPointerException("Can't set default locale to NULL");
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) sm.checkPermission(new PropertyPermission
                        ("user.language", "write"));
        switch (category) {
        case DISPLAY:
            defaultDisplayLocale = newLocale;
            break;
        case FORMAT:
            defaultFormatLocale = newLocale;
            break;
        default:
            assert false: "Unknown Category";
        }
}

Sets the default locale for the specified Category for this instance of the Java Virtual Machine. This does not affect the host locale.

If there is a security manager, its checkPermission method is called with a PropertyPermission("user.language", "write") permission before the default locale is changed.

The Java Virtual Machine sets the default locale during startup based on the host environment. It is used by many locale-sensitive methods if no locale is explicitly specified.

Since changing the default locale may affect many different areas of functionality, this method should only be used if the caller is prepared to reinitialize locale-sensitive code running within the same Java Virtual Machine.

 public String toLanguageTag() 
{
        LanguageTag tag = LanguageTag.parseLocale(baseLocale, localeExtensions);
        StringBuilder buf = new StringBuilder();
        String subtag = tag.getLanguage();
        if (subtag.length()  > 0) {
            buf.append(LanguageTag.canonicalizeLanguage(subtag));
        }
        subtag = tag.getScript();
        if (subtag.length()  > 0) {
            buf.append(LanguageTag.SEP);
            buf.append(LanguageTag.canonicalizeScript(subtag));
        }
        subtag = tag.getRegion();
        if (subtag.length()  > 0) {
            buf.append(LanguageTag.SEP);
            buf.append(LanguageTag.canonicalizeRegion(subtag));
        }
        List< String >subtags = tag.getVariants();
        for (String s : subtags) {
            buf.append(LanguageTag.SEP);
            // preserve casing
            buf.append(s);
        }
        subtags = tag.getExtensions();
        for (String s : subtags) {
            buf.append(LanguageTag.SEP);
            buf.append(LanguageTag.canonicalizeExtension(s));
        }
        subtag = tag.getPrivateuse();
        if (subtag.length()  > 0) {
            if (buf.length()  > 0) {
                buf.append(LanguageTag.SEP);
            }
            buf.append(LanguageTag.PRIVATEUSE).append(LanguageTag.SEP);
            // preserve casing
            buf.append(subtag);
        }
        return buf.toString();
}

Returns a well-formed IETF BCP 47 language tag representing this locale.

If this Locale has a language, country, or variant that does not satisfy the IETF BCP 47 language tag syntax requirements, this method handles these fields as described below:

Language: If language is empty, or not well-formed (for example "a" or "e2"), it will be emitted as "und" (Undetermined).

Country: If country is not well-formed (for example "12" or "USA"), it will be omitted.

Variant: If variant is well-formed, each sub-segment (delimited by '-' or '_') is emitted as a subtag. Otherwise:

• if all sub-segments match [0-9a-zA-Z]{1,8} (for example "WIN" or "Oracle_JDK_Standard_Edition"), the first ill-formed sub-segment and all following will be appended to the private use subtag. The first appended subtag will be "lvariant", followed by the sub-segments in order, separated by hyphen. For example, "x-lvariant-WIN", "Oracle-x-lvariant-JDK-Standard-Edition".
• if any sub-segment does not match [0-9a-zA-Z]{1,8}, the variant will be truncated and the problematic sub-segment and all following sub-segments will be omitted. If the remainder is non-empty, it will be emitted as a private use subtag as above (even if the remainder turns out to be well-formed). For example, "Solaris_isjustthecoolestthing" is emitted as "x-lvariant-Solaris", not as "solaris".

Special Conversions: Java supports some old locale representations, including deprecated ISO language codes, for compatibility. This method performs the following conversions:

• Deprecated ISO language codes "iw", "ji", and "in" are converted to "he", "yi", and "id", respectively.
• A locale with language "no", country "NO", and variant "NY", representing Norwegian Nynorsk (Norway), is converted to a language tag "nn-NO".

Note: Although the language tag created by this method is well-formed (satisfies the syntax requirements defined by the IETF BCP 47 specification), it is not necessarily a valid BCP 47 language tag. For example,

  new Locale("xx", "YY").toLanguageTag();

will return "xx-YY", but the language subtag "xx" and the region subtag "YY" are invalid because they are not registered in the IANA Language Subtag Registry.

 public final String toString() 
{
        boolean l = (baseLocale.getLanguage().length() != 0);
        boolean s = (baseLocale.getScript().length() != 0);
        boolean r = (baseLocale.getRegion().length() != 0);
        boolean v = (baseLocale.getVariant().length() != 0);
        boolean e = (localeExtensions != null && localeExtensions.getID().length() != 0);
        StringBuilder result = new StringBuilder(baseLocale.getLanguage());
        if (r || (l && (v || s || e))) {
            result.append('_')
                .append(baseLocale.getRegion()); // This may just append '_'
        }
        if (v && (l || r)) {
            result.append('_')
                .append(baseLocale.getVariant());
        }
        if (s && (l || r)) {
            result.append("_#")
                .append(baseLocale.getScript());
        }
        if (e && (l || r)) {
            result.append('_');
            if (!s) {
                result.append('#');
            }
            result.append(localeExtensions.getID());
        }
        return result.toString();
}

Returns a string representation of this Locale object, consisting of language, country, variant, script, and extensions as below:

language + "_" + country + "_" + (variant + "_#" | "#") + script + "-" + extensions

Language is always lower case, country is always upper case, script is always title case, and extensions are always lower case. Extensions and private use subtags will be in canonical order as explained in #toLanguageTag .

When the locale has neither script nor extensions, the result is the same as in Java 6 and prior.

If both the language and country fields are missing, this function will return the empty string, even if the variant, script, or extensions field is present (you can't have a locale with just a variant, the variant must accompany a well-formed language or country code).

If script or extensions are present and variant is missing, no underscore is added before the "#".

This behavior is designed to support debugging and to be compatible with previous uses of toString that expected language, country, and variant fields only. To represent a Locale as a String for interchange purposes, use #toLanguageTag .

Examples:

• en
• de_DE
• _GB
• en_US_WIN
• de__POSIX
• zh_CN_#Hans
• zh_TW_#Hant-x-java
• th_TH_TH_#u-nu-thai