/* * Copyright (c) 1996, 2022, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions.
*/
/* * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved * * The original version of this source code and documentation * is copyrighted and owned by Taligent, Inc., a wholly-owned * subsidiary of IBM. These materials are provided under terms * of a License Agreement between Taligent and Sun. This technology * is protected by multiple US and International patents. * * This notice and attribution to Taligent may not be removed. * Taligent is a registered trademark of Taligent, Inc. *
*/
/** * A {@code Locale} object represents a specific geographical, political, * or cultural region. An operation that requires a {@code Locale} to perform * its task is called <em>locale-sensitive</em> and uses the {@code Locale} * to tailor information for the user. For example, displaying a number * is a locale-sensitive operation— the number should be formatted * according to the customs and conventions of the user's native country, * region, or culture. * * <p> The {@code Locale} class implements IETF BCP 47 which is composed of * <a href="https://tools.ietf.org/html/rfc4647">RFC 4647 "Matching of Language * Tags"</a> and <a href="https://tools.ietf.org/html/rfc5646">RFC 5646 "Tags * for Identifying Languages"</a> with support for the LDML (UTS#35, "Unicode * Locale Data Markup Language") BCP 47-compatible extensions for locale data * exchange. * * <p> A {@code Locale} object logically consists of the fields * described below. * * <dl> * <dt><a id="def_language"><b>language</b></a></dt> * * <dd>ISO 639 alpha-2 or alpha-3 language code, or registered * language subtags up to 8 alpha letters (for future enhancements). * When a language has both an alpha-2 code and an alpha-3 code, the * alpha-2 code must be used. You can find a full list of valid * language codes in the IANA Language Subtag Registry (search for * "Type: language"). The language field is case insensitive, but * {@code Locale} always canonicalizes to lower case.</dd> * * <dd>Well-formed language values have the form * <code>[a-zA-Z]{2,8}</code>. Note that this is not the full * BCP47 language production, since it excludes extlang. They are * not needed since modern three-letter language codes replace * them.</dd> * * <dd>Example: "en" (English), "ja" (Japanese), "kok" (Konkani)</dd> * * <dt><a id="def_script"><b>script</b></a></dt> * * <dd>ISO 15924 alpha-4 script code. You can find a full list of * valid script codes in the IANA Language Subtag Registry (search * for "Type: script"). The script field is case insensitive, but * {@code Locale} always canonicalizes to title case (the first * letter is upper case and the rest of the letters are lower * case).</dd> * * <dd>Well-formed script values have the form * <code>[a-zA-Z]{4}</code></dd> * * <dd>Example: "Latn" (Latin), "Cyrl" (Cyrillic)</dd> * * <dt><a id="def_region"><b>country (region)</b></a></dt> * * <dd>ISO 3166 alpha-2 country code or UN M.49 numeric-3 area code. * You can find a full list of valid country and region codes in the * IANA Language Subtag Registry (search for "Type: region"). The * country (region) field is case insensitive, but * {@code Locale} always canonicalizes to upper case.</dd> * * <dd>Well-formed country/region values have * the form <code>[a-zA-Z]{2} | [0-9]{3}</code></dd> * * <dd>Example: "US" (United States), "FR" (France), "029" * (Caribbean)</dd> * * <dt><a id="def_variant"><b>variant</b></a></dt> * * <dd>Any arbitrary value used to indicate a variation of a * {@code Locale}. Where there are two or more variant values * each indicating its own semantics, these values should be ordered * by importance, with most important first, separated by * underscore('_'). The variant field is case sensitive.</dd> * * <dd>Note: IETF BCP 47 places syntactic restrictions on variant * subtags. Also BCP 47 subtags are strictly used to indicate * additional variations that define a language or its dialects that * are not covered by any combinations of language, script and * region subtags. You can find a full list of valid variant codes * in the IANA Language Subtag Registry (search for "Type: variant"). * * <p>However, the variant field in {@code Locale} has * historically been used for any kind of variation, not just * language variations. For example, some supported variants * available in Java SE Runtime Environments indicate alternative * cultural behaviors such as calendar type or number script. In * BCP 47 this kind of information, which does not identify the * language, is supported by extension subtags or private use * subtags.</dd> * * <dd>Well-formed variant values have the form <code>SUBTAG * (('_'|'-') SUBTAG)*</code> where <code>SUBTAG = * [0-9][0-9a-zA-Z]{3} | [0-9a-zA-Z]{5,8}</code>. (Note: BCP 47 only * uses hyphen ('-') as a delimiter, this is more lenient).</dd> * * <dd>Example: "polyton" (Polytonic Greek), "POSIX"</dd> * * <dt><a id="def_extensions"><b>extensions</b></a></dt> * * <dd>A map from single character keys to string values, indicating * extensions apart from language identification. The extensions in * {@code Locale} implement the semantics and syntax of BCP 47 * extension subtags and private use subtags. The extensions are * case insensitive, but {@code Locale} canonicalizes all * extension keys and values to lower case. Note that extensions * cannot have empty values.</dd> * * <dd>Well-formed keys are single characters from the set * {@code [0-9a-zA-Z]}. Well-formed values have the form * {@code SUBTAG ('-' SUBTAG)*} where for the key 'x' * <code>SUBTAG = [0-9a-zA-Z]{1,8}</code> and for other keys * <code>SUBTAG = [0-9a-zA-Z]{2,8}</code> (that is, 'x' allows * single-character subtags).</dd> * * <dd>Example: key="u"/value="ca-japanese" (Japanese Calendar), * key="x"/value="java-1-7"</dd> * </dl> * * <b>Note:</b> Although BCP 47 requires field values to be registered * in the IANA Language Subtag Registry, the {@code Locale} class * does not provide any validation features. The {@code Builder} * only checks if an individual field satisfies the syntactic * requirement (is well-formed), but does not validate the value * itself. See {@link Builder} for details. * * <h2><a id="def_locale_extension">Unicode locale/language extension</a></h2> * * <p>UTS#35, "Unicode Locale Data Markup Language" defines optional * attributes and keywords to override or refine the default behavior * associated with a locale. A keyword is represented by a pair of * key and type. For example, "nu-thai" indicates that Thai local * digits (value:"thai") should be used for formatting numbers * (key:"nu"). * * <p>The keywords are mapped to a BCP 47 extension value using the * extension key 'u' ({@link #UNICODE_LOCALE_EXTENSION}). The above * example, "nu-thai", becomes the extension "u-nu-thai". * * <p>Thus, when a {@code Locale} object contains Unicode locale * attributes and keywords, * {@code getExtension(UNICODE_LOCALE_EXTENSION)} will return a * String representing this information, for example, "nu-thai". The * {@code Locale} class also provides {@link * #getUnicodeLocaleAttributes}, {@link #getUnicodeLocaleKeys}, and * {@link #getUnicodeLocaleType} which allow you to access Unicode * locale attributes and key/type pairs directly. When represented as * a string, the Unicode Locale Extension lists attributes * alphabetically, followed by key/type sequences with keys listed * alphabetically (the order of subtags comprising a key's type is * fixed when the type is defined) * * <p>A well-formed locale key has the form * <code>[0-9a-zA-Z]{2}</code>. A well-formed locale type has the * form <code>"" | [0-9a-zA-Z]{3,8} ('-' [0-9a-zA-Z]{3,8})*</code> (it * can be empty, or a series of subtags 3-8 alphanums in length). A * well-formed locale attribute has the form * <code>[0-9a-zA-Z]{3,8}</code> (it is a single subtag with the same * form as a locale type subtag). * * <p>The Unicode locale extension specifies optional behavior in * locale-sensitive services. Although the LDML specification defines * various keys and values, actual locale-sensitive service * implementations in a Java Runtime Environment might not support any * particular Unicode locale attributes or key/type pairs. * * <h3><a id="ObtainingLocale">Obtaining a Locale</a></h3> * * <p>There are several ways to obtain a {@code Locale} * object. * * <h4>Builder</h4> * * <p>Using {@link Builder} you can construct a {@code Locale} object * that conforms to BCP 47 syntax. * * <h4>Factory Methods</h4> * * <p>The method {@link #forLanguageTag} obtains a {@code Locale} * object for a well-formed BCP 47 language tag. The method * {@link #of(String, String, String)} and its overloads obtain a * {@code Locale} object from given {@code language}, {@code country}, * and/or {@code variant} defined above. * * <h4>Locale Constants</h4> * * <p>The {@code Locale} class provides a number of convenient constants * that you can use to obtain {@code Locale} objects for commonly used * locales. For example, {@code Locale.US} is the {@code Locale} object * for the United States. * * <h3><a id="LocaleMatching">Locale Matching</a></h3> * * <p>If an application or a system is internationalized and provides localized * resources for multiple locales, it sometimes needs to find one or more * locales (or language tags) which meet each user's specific preferences. Note * that a term "language tag" is used interchangeably with "locale" in this * locale matching documentation. * * <p>In order to do matching a user's preferred locales to a set of language * tags, <a href="https://tools.ietf.org/html/rfc4647">RFC 4647 Matching of * Language Tags</a> defines two mechanisms: filtering and lookup. * <em>Filtering</em> is used to get all matching locales, whereas * <em>lookup</em> is to choose the best matching locale. * Matching is done case-insensitively. These matching mechanisms are described * in the following sections. * * <p>A user's preference is called a <em>Language Priority List</em> and is * expressed as a list of language ranges. There are syntactically two types of * language ranges: basic and extended. See * {@link Locale.LanguageRange Locale.LanguageRange} for details. * * <h4>Filtering</h4> * * <p>The filtering operation returns all matching language tags. It is defined * in RFC 4647 as follows: * "In filtering, each language range represents the least specific language * tag (that is, the language tag with fewest number of subtags) that is an * acceptable match. All of the language tags in the matching set of tags will * have an equal or greater number of subtags than the language range. Every * non-wildcard subtag in the language range will appear in every one of the * matching language tags." * * <p>There are two types of filtering: filtering for basic language ranges * (called "basic filtering") and filtering for extended language ranges * (called "extended filtering"). They may return different results by what * kind of language ranges are included in the given Language Priority List. * {@link Locale.FilteringMode} is a parameter to specify how filtering should * be done. * * <h4>Lookup</h4> * * <p>The lookup operation returns the best matching language tags. It is * defined in RFC 4647 as follows: * "By contrast with filtering, each language range represents the most * specific tag that is an acceptable match. The first matching tag found, * according to the user's priority, is considered the closest match and is the * item returned." * * <p>For example, if a Language Priority List consists of two language ranges, * {@code "zh-Hant-TW"} and {@code "en-US"}, in prioritized order, lookup * method progressively searches the language tags below in order to find the * best matching language tag. * <blockquote> * <pre> * 1. zh-Hant-TW * 2. zh-Hant * 3. zh * 4. en-US * 5. en * </pre> * </blockquote> * If there is a language tag which matches completely to a language range * above, the language tag is returned. * * <p>{@code "*"} is the special language range, and it is ignored in lookup. * * <p>If multiple language tags match as a result of the subtag {@code '*'} * included in a language range, the first matching language tag returned by * an {@link Iterator} over a {@link Collection} of language tags is treated as * the best matching one. * * <h3>Use of Locale</h3> * * <p>Once you've obtained a {@code Locale} you can query it for information * about itself. Use {@code getCountry} to get the country (or region) * code and {@code getLanguage} to get the language code. * You can use {@code getDisplayCountry} to get the * name of the country suitable for displaying to the user. Similarly, * you can use {@code getDisplayLanguage} to get the name of * the language suitable for displaying to the user. Interestingly, * the {@code getDisplayXXX} methods are themselves locale-sensitive * and have two versions: one that uses the default * {@link Locale.Category#DISPLAY DISPLAY} locale and one * that uses the locale specified as an argument. * * <p>The Java Platform provides a number of classes that perform locale-sensitive * operations. For example, the {@code NumberFormat} class formats * numbers, currency, and percentages in a locale-sensitive manner. Classes * such as {@code NumberFormat} have several convenience methods * for creating a default object of that type. For example, the * {@code NumberFormat} class provides these three convenience methods * for creating a default {@code NumberFormat} object: * <blockquote> * <pre> * NumberFormat.getInstance() * NumberFormat.getCurrencyInstance() * NumberFormat.getPercentInstance() * </pre> * </blockquote> * Each of these methods has two variants; one with an explicit locale * and one without; the latter uses the default * {@link Locale.Category#FORMAT FORMAT} locale: * <blockquote> * <pre> * NumberFormat.getInstance(myLocale) * NumberFormat.getCurrencyInstance(myLocale) * NumberFormat.getPercentInstance(myLocale) * </pre> * </blockquote> * A {@code Locale} is the mechanism for identifying the kind of object * ({@code NumberFormat}) that you would like to get. The locale is * <STRONG>just</STRONG> a mechanism for identifying objects, * <STRONG>not</STRONG> a container for the objects themselves. * * <h3>Compatibility</h3> * * <p>In order to maintain compatibility, Locale's * constructors retain their behavior prior to the Java Runtime * Environment version 1.7. The same is largely true for the * {@code toString} method. Thus Locale objects can continue to * be used as they were. In particular, clients who parse the output * of toString into language, country, and variant fields can continue * to do so (although this is strongly discouraged), although the * variant field will have additional information in it if script or * extensions are present. * * <p>In addition, BCP 47 imposes syntax restrictions that are not * imposed by Locale's constructors. This means that conversions * between some Locales and BCP 47 language tags cannot be made without * losing information. Thus {@code toLanguageTag} cannot * represent the state of locales whose language, country, or variant * do not conform to BCP 47. * * <p>Because of these issues, it is recommended that clients migrate * away from constructing non-conforming locales and use the * {@code forLanguageTag} and {@code Locale.Builder} APIs instead. * Clients desiring a string representation of the complete locale can * then always rely on {@code toLanguageTag} for this purpose. * * <h4><a id="special_cases_constructor">Special cases</a></h4> * * <p>For compatibility reasons, two * non-conforming locales are treated as special cases. These are * <b>{@code ja_JP_JP}</b> and <b>{@code th_TH_TH}</b>. These are ill-formed * in BCP 47 since the variants are too short. To ease migration to BCP 47, * these are treated specially during construction. These two cases (and only * these) cause a constructor to generate an extension, all other values behave * exactly as they did prior to Java 7. * * <p>Java has used {@code ja_JP_JP} to represent Japanese as used in * Japan together with the Japanese Imperial calendar. This is now * representable using a Unicode locale extension, by specifying the * Unicode locale key {@code ca} (for "calendar") and type * {@code japanese}. When the Locale constructor is called with the * arguments "ja", "JP", "JP", the extension "u-ca-japanese" is * automatically added. * * <p>Java has used {@code th_TH_TH} to represent Thai as used in * Thailand together with Thai digits. This is also now representable using * a Unicode locale extension, by specifying the Unicode locale key * {@code nu} (for "number") and value {@code thai}. When the Locale * constructor is called with the arguments "th", "TH", "TH", the * extension "u-nu-thai" is automatically added. * * <h4>Serialization</h4> * * <p>During serialization, writeObject writes all fields to the output * stream, including extensions. * * <p>During deserialization, readResolve adds extensions as described * in <a href="#special_cases_constructor">Special Cases</a>, only * for the two cases th_TH_TH and ja_JP_JP. * * <h4><a id="legacy_language_codes">Legacy language codes</a></h4> * * <p>Locale's constructor has always converted three language codes to * their earlier, obsoleted forms: {@code he} maps to {@code iw}, * {@code yi} maps to {@code ji}, and {@code id} maps to * {@code in}. Since Java SE 17, this is no longer the case. Each * language maps to its new form; {@code iw} maps to {@code he}, {@code ji} * maps to {@code yi}, and {@code in} maps to {@code id}. * * <p>For the backward compatible behavior, the system property * {@systemProperty java.locale.useOldISOCodes} reverts the behavior * back to that of before Java SE 17. If the system property is set to * {@code true}, those three current language codes are mapped to their * backward compatible forms. The property is only read at Java runtime * startup and subsequent calls to {@code System.setProperty()} will * have no effect. * * <p>The APIs added in 1.7 map between the old and new language codes, * maintaining the mapped codes internal to Locale (so that * {@code getLanguage} and {@code toString} reflect the mapped * code, which depends on the {@code java.locale.useOldISOCodes} system * property), but using the new codes in the BCP 47 language tag APIs (so * that {@code toLanguageTag} reflects the new one). This * preserves the equivalence between Locales no matter which code or * API is used to construct them. Java's default resource bundle * lookup mechanism also implements this mapping, so that resources * can be named using either convention, see {@link ResourceBundle.Control}. * * <h4>Three-letter language/country(region) codes</h4> * * <p>The Locale constructors have always specified that the language * and the country param be two characters in length, although in * practice they have accepted any length. The specification has now * been relaxed to allow language codes of two to eight characters and * country (region) codes of two to three characters, and in * particular, three-letter language codes and three-digit region * codes as specified in the IANA Language Subtag Registry. For * compatibility, the implementation still does not impose a length * constraint. * * @see Builder * @see ResourceBundle * @see java.text.Format * @see java.text.NumberFormat * @see java.text.Collator * @author Mark Davis * @since 1.1
*/ publicfinalclass Locale implements Cloneable, Serializable {
/** Useful constant for language.
*/ publicstaticfinal Locale ENGLISH;
/** Useful constant for language.
*/ publicstaticfinal Locale FRENCH;
/** Useful constant for language.
*/ publicstaticfinal Locale GERMAN;
/** Useful constant for language.
*/ publicstaticfinal Locale ITALIAN;
/** Useful constant for language.
*/ publicstaticfinal Locale JAPANESE;
/** Useful constant for language.
*/ publicstaticfinal Locale KOREAN;
/** Useful constant for language.
*/ publicstaticfinal Locale CHINESE;
/** Useful constant for language.
*/ publicstaticfinal Locale SIMPLIFIED_CHINESE;
/** Useful constant for language.
*/ publicstaticfinal Locale TRADITIONAL_CHINESE;
/** Useful constant for country.
*/ publicstaticfinal Locale FRANCE;
/** Useful constant for country.
*/ publicstaticfinal Locale GERMANY;
/** Useful constant for country.
*/ publicstaticfinal Locale ITALY;
/** Useful constant for country.
*/ publicstaticfinal Locale JAPAN;
/** Useful constant for country.
*/ publicstaticfinal Locale KOREA;
/** Useful constant for country.
*/ publicstaticfinal Locale UK;
/** Useful constant for country.
*/ publicstaticfinal Locale US;
/** Useful constant for country.
*/ publicstaticfinal Locale CANADA;
/** Useful constant for country.
*/ publicstaticfinal Locale CANADA_FRENCH;
/** * Useful constant for the root locale. The root locale is the locale whose * language, country, and variant are empty ("") strings. This is regarded * as the base locale of all locales, and is used as the language/country * neutral locale for the locale sensitive operations. * * @since 1.6
*/ publicstaticfinal Locale ROOT;
privatestaticfinal Map<BaseLocale, Locale> CONSTANT_LOCALES = new HashMap<>();
static {
ENGLISH = createConstant(BaseLocale.ENGLISH);
FRENCH = createConstant(BaseLocale.FRENCH);
GERMAN = createConstant(BaseLocale.GERMAN);
ITALIAN = createConstant(BaseLocale.ITALIAN);
JAPANESE = createConstant(BaseLocale.JAPANESE);
KOREAN = createConstant(BaseLocale.KOREAN);
CHINESE = createConstant(BaseLocale.CHINESE);
SIMPLIFIED_CHINESE = createConstant(BaseLocale.SIMPLIFIED_CHINESE);
TRADITIONAL_CHINESE = createConstant(BaseLocale.TRADITIONAL_CHINESE);
FRANCE = createConstant(BaseLocale.FRANCE);
GERMANY = createConstant(BaseLocale.GERMANY);
ITALY = createConstant(BaseLocale.ITALY);
JAPAN = createConstant(BaseLocale.JAPAN);
KOREA = createConstant(BaseLocale.KOREA);
UK = createConstant(BaseLocale.UK);
US = createConstant(BaseLocale.US);
CANADA = createConstant(BaseLocale.CANADA);
CANADA_FRENCH = createConstant(BaseLocale.CANADA_FRENCH);
ROOT = createConstant(BaseLocale.ROOT);
}
/** Useful constant for country.
*/ publicstaticfinal Locale CHINA = SIMPLIFIED_CHINESE;
/** * This method must be called only for creating the Locale.* * constants due to making shortcuts.
*/ privatestatic Locale createConstant(byte baseType) {
BaseLocale base = BaseLocale.constantBaseLocales[baseType];
Locale locale = new Locale(base, null);
CONSTANT_LOCALES.put(base, locale); return locale;
}
/** * The key for the private use extension ('x'). * * @see #getExtension(char) * @see Builder#setExtension(char, String) * @since 1.7
*/ publicstaticfinalchar PRIVATE_USE_EXTENSION = 'x';
/** serialization ID
*/
@java.io.Serial staticfinallong serialVersionUID = 9149081749638150636L;
/** * Enum for specifying the type defined in ISO 3166. This enum is used to * retrieve the two-letter ISO3166-1 alpha-2, three-letter ISO3166-1 * alpha-3, four-letter ISO3166-3 country codes. * * @see #getISOCountries(Locale.IsoCountryCode) * @since 9
*/ publicstaticenum IsoCountryCode { /** * PART1_ALPHA2 is used to represent the ISO3166-1 alpha-2 two letter * country codes.
*/
PART1_ALPHA2 {
@Override
Set<String> createCountryCodeSet() { return Set.of(Locale.getISOCountries());
}
},
/** * * PART1_ALPHA3 is used to represent the ISO3166-1 alpha-3 three letter * country codes.
*/
PART1_ALPHA3 {
@Override
Set<String> createCountryCodeSet() { return LocaleISOData.computeISO3166_1Alpha3Countries();
}
},
/** * PART3 is used to represent the ISO3166-3 four letter country codes.
*/
PART3 {
@Override
Set<String> createCountryCodeSet() { return Set.of(LocaleISOData.ISO3166_3);
}
};
/** * Concrete implementation of this method attempts to compute value * for iso3166CodesMap for each IsoCountryCode type key.
*/ abstract Set<String> createCountryCodeSet();
/** * Map to hold country codes for each ISO3166 part.
*/ privatestaticfinal Map<IsoCountryCode, Set<String>> iso3166CodesMap = new ConcurrentHashMap<>();
/** * This method is called from Locale class to retrieve country code set * for getISOCountries(type)
*/ static Set<String> retrieveISOCountryCodes(IsoCountryCode type) { return iso3166CodesMap.computeIfAbsent(type, IsoCountryCode::createCountryCodeSet);
}
}
/** * Display types for retrieving localized names from the name providers.
*/ privatestaticfinalint DISPLAY_LANGUAGE = 0; privatestaticfinalint DISPLAY_COUNTRY = 1; privatestaticfinalint DISPLAY_VARIANT = 2; privatestaticfinalint DISPLAY_SCRIPT = 3; privatestaticfinalint DISPLAY_UEXT_KEY = 4; privatestaticfinalint DISPLAY_UEXT_TYPE = 5;
/** * Construct a locale from language, country and variant. * This constructor normalizes the language value to lowercase and * the country value to uppercase. * @implNote * <ul> * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * <li>For backward compatibility reasons, this constructor does not make * any syntactic checks on the input. * <li>The two cases ("ja", "JP", "JP") and ("th", "TH", "TH") are handled specially, * see <a href="#special_cases_constructor">Special Cases</a> for more information. * </ul> * * @deprecated Locale constructors have been deprecated. See <a href ="#ObtainingLocale"> * Obtaining a Locale</a> for other options. * * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag * up to 8 characters in length. See the {@code Locale} class description about * valid language values. * @param country An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. * See the {@code Locale} class description about valid country values. * @param variant Any arbitrary value used to indicate a variation of a {@code Locale}. * See the {@code Locale} class description for the details. * @throws NullPointerException thrown if any argument is null.
*/
@Deprecated(since="19") public Locale(String language, String country, String variant) { if (language == null || country == null || variant == null) { thrownew NullPointerException();
}
baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), "", country, variant);
localeExtensions = getCompatibilityExtensions(language, "", country, variant);
}
/** * Construct a locale from language and country. * This constructor normalizes the language value to lowercase and * the country value to uppercase. * @implNote * <ul> * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * <li>For backward compatibility reasons, this constructor does not make * any syntactic checks on the input. * </ul> * * @deprecated Locale constructors have been deprecated. See <a href="#ObtainingLocale"> * Obtaining a Locale</a> for other options. * * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag * up to 8 characters in length. See the {@code Locale} class description about * valid language values. * @param country An ISO 3166 alpha-2 country code or a UN M.49 numeric-3 area code. * See the {@code Locale} class description about valid country values. * @throws NullPointerException thrown if either argument is null.
*/
@Deprecated(since="19") public Locale(String language, String country) { this(language, country, "");
}
/** * Construct a locale from a language code. * This constructor normalizes the language value to lowercase. * @implNote * <ul> * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * <li>For backward compatibility reasons, this constructor does not make * any syntactic checks on the input. * </ul> * * @deprecated Locale constructors have been deprecated. See <a href="#ObtainingLocale"> * Obtaining a Locale</a> for other options. * * @param language An ISO 639 alpha-2 or alpha-3 language code, or a language subtag * up to 8 characters in length. See the {@code Locale} class description about * valid language values. * @throws NullPointerException thrown if argument is null. * @since 1.4
*/
@Deprecated(since="19") public Locale(String language) { this(language, "", "");
}
/** * Obtains a locale from language, country and variant. * This method normalizes the language value to lowercase and * the country value to uppercase. * @implNote * <ul> * <li>This method does not make any syntactic checks on the input. * Use {@link Locale.Builder} for full syntactic checks with BCP47. * <li>The two cases ("ja", "JP", "JP") and ("th", "TH", "TH") are handled specially, * see <a href="#special_cases_constructor">Special Cases</a> for more information. * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * </ul> * * @param language A language code. See the {@code Locale} class description of * <a href="#def_language">language</a> values. * @param country A country code. See the {@code Locale} class description of * <a href="#def_region">country</a> values. * @param variant Any arbitrary value used to indicate a variation of a {@code Locale}. * See the {@code Locale} class description of <a href="#def_variant">variant</a> values. * @throws NullPointerException thrown if any argument is null. * @return A {@code Locale} object * @since 19
*/ publicstatic Locale of(String language, String country, String variant) { return getInstance(language, "", country, variant, null);
}
/** * Obtains a locale from language and country. * This method normalizes the language value to lowercase and * the country value to uppercase. * @implNote * <ul> * <li>This method does not make any syntactic checks on the input. * Use {@link Locale.Builder} for full syntactic checks with BCP47. * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * </ul> * * @param language A language code. See the {@code Locale} class description of * <a href="#def_language">language</a> values. * @param country A country code. See the {@code Locale} class description of * <a href="#def_region">country</a> values. * @throws NullPointerException thrown if either argument is null. * @return A {@code Locale} object * @since 19
*/ publicstatic Locale of(String language, String country) { return getInstance(language, "", country, "", null);
}
/** * Obtains a locale from a language code. * This method normalizes the language value to lowercase. * @implNote * <ul> * <li>This method does not make any syntactic checks on the input. * Use {@link Locale.Builder} for full syntactic checks with BCP47. * <li>Obsolete ISO 639 codes ("iw", "ji", and "in") are mapped to * their current forms. See <a href="#legacy_language_codes">Legacy language * codes</a> for more information. * </ul> * * @param language A language code. See the {@code Locale} class description of * <a href="#def_language">language</a> values. * @throws NullPointerException thrown if argument is null. * @return A {@code Locale} object * @since 19
*/ publicstatic Locale of(String language) { return getInstance(language, "", "", "", null);
}
/** * Returns a {@code Locale} constructed from the given * {@code language}, {@code country} and * {@code variant}. If the same {@code Locale} instance * is available in the cache, then that instance is * returned. Otherwise, a new {@code Locale} instance is * created and cached. * * @param language lowercase 2 to 8 language code. * @param country uppercase two-letter ISO-3166 code and numeric-3 UN M.49 area code. * @param variant vendor and browser specific code. See class description. * @return the {@code Locale} instance requested * @throws NullPointerException if any argument is null.
*/ static Locale getInstance(String language, String country, String variant) { return getInstance(language, "", country, variant, null);
}
/** * Gets the current value of the default locale for this instance * of the Java Virtual Machine. * <p> * 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 * {@link #setDefault(java.util.Locale) setDefault} method. * * @return the default locale for this instance of the Java Virtual Machine
*/ publicstatic Locale getDefault() { // do not synchronize this method - see 4071298 return defaultLocale;
}
/** * Gets the current value of the default locale for the specified Category * for this instance of the Java Virtual Machine. * <p> * 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. * * @param category the specified category to get the default locale * @throws NullPointerException if category is null * @return the default locale for the specified Category for this instance * of the Java Virtual Machine * @see #setDefault(Locale.Category, Locale) * @since 1.7
*/ publicstatic Locale getDefault(Locale.Category category) { // do not synchronize this method - see 4071298
Objects.requireNonNull(category); if (category == Category.DISPLAY) {
Locale loc = defaultDisplayLocale; // volatile read if (loc == null) {
loc = getDisplayLocale();
} return loc;
} else { assert category == Category.FORMAT : "Unknown category";
Locale loc = defaultFormatLocale; // volatile read if (loc == null) {
loc = getFormatLocale();
} return loc;
}
}
privatestaticsynchronized Locale getDisplayLocale() {
Locale loc = defaultDisplayLocale; if (loc == null) {
loc = defaultDisplayLocale = initDefault(Category.DISPLAY);
} return loc;
}
privatestaticsynchronized Locale getFormatLocale() {
Locale loc = defaultFormatLocale; if (loc == null) {
loc = defaultFormatLocale = initDefault(Category.FORMAT);
} return loc;
}
privatestatic Locale initDefault() {
String language, region, script, country, variant;
Properties props = GetPropertyAction.privilegedGetProperties();
language = props.getProperty("user.language", "en"); // for compatibility, check for old user.region property
region = props.getProperty("user.region"); if (region != null) { // region can be of form country, country_variant, or _variant int i = region.indexOf('_'); if (i >= 0) {
country = region.substring(0, i);
variant = region.substring(i + 1);
} else {
country = region;
variant = "";
}
script = "";
} else {
script = props.getProperty("user.script", "");
country = props.getProperty("user.country", "");
variant = props.getProperty("user.variant", "");
}
LocaleExtensions exts = null; try {
exts = new InternalLocaleBuilder()
.setExtensions(extensionsProp)
.getLocaleExtensions();
} catch (LocaleSyntaxException e) { // just ignore this incorrect property
}
return Optional.ofNullable(exts);
}
/** * Sets the default locale for this instance of the Java Virtual Machine. * This does not affect the host locale. * <p> * If there is a security manager, its {@code checkPermission} * method is called with a {@code PropertyPermission("user.language", "write")} * permission before the default locale is changed. * <p> * 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. * <p> * 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. * <p> * By setting the default locale with this method, all of the default * locales for each Category are also set to the specified default locale. * * @throws SecurityException * if a security manager exists and its * {@code checkPermission} method doesn't allow the operation. * @throws NullPointerException if {@code newLocale} is null * @param newLocale the new default locale * @see SecurityManager#checkPermission * @see java.util.PropertyPermission
*/ publicstaticsynchronizedvoid setDefault(Locale newLocale) {
setDefault(Category.DISPLAY, newLocale);
setDefault(Category.FORMAT, newLocale);
defaultLocale = newLocale;
}
/** * Sets the default locale for the specified Category for this instance * of the Java Virtual Machine. This does not affect the host locale. * <p> * If there is a security manager, its checkPermission method is called * with a PropertyPermission("user.language", "write") permission before * the default locale is changed. * <p> * 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. * <p> * 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. * * @param category the specified category to set the default locale * @param newLocale the new default locale * @throws SecurityException if a security manager exists and its * checkPermission method doesn't allow the operation. * @throws NullPointerException if category and/or newLocale is null * @see SecurityManager#checkPermission(java.security.Permission) * @see PropertyPermission * @see #getDefault(Locale.Category) * @since 1.7
*/ publicstaticsynchronizedvoid setDefault(Locale.Category category,
Locale newLocale) { if (category == null) thrownew NullPointerException("Category cannot be NULL"); if (newLocale == null) thrownew NullPointerException("Can't set default locale to NULL");
@SuppressWarnings("removal")
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: assertfalse: "Unknown Category";
}
}
/** * Returns an array of all installed locales. * The returned array represents the union of locales supported * by the Java runtime environment and by installed * {@link java.util.spi.LocaleServiceProvider LocaleServiceProvider} * implementations. At a minimum, the returned array must contain a * {@code Locale} instance equal to {@link Locale#ROOT Locale.ROOT} and * a {@code Locale} instance equal to {@link Locale#US Locale.US}. * * @return An array of installed locales.
*/ publicstatic Locale[] getAvailableLocales() { return LocaleServiceProviderPool.getAllAvailableLocales();
}
/** * Returns a list of all 2-letter country codes defined in ISO 3166. * Can be used to obtain Locales. * This method is equivalent to {@link #getISOCountries(Locale.IsoCountryCode type)} * with {@code type} {@link IsoCountryCode#PART1_ALPHA2}. * <p> * <b>Note:</b> The {@code 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 obtain Locales. * <p> * Note that this method does not return obsolete 2-letter country codes. * ISO3166-3 codes which designate country codes for those obsolete codes, * can be retrieved from {@link #getISOCountries(Locale.IsoCountryCode type)} with * {@code type} {@link IsoCountryCode#PART3}. * @return An array of ISO 3166 two-letter country codes.
*/ publicstatic 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 {@code Set} of ISO3166 country codes for the specified type. * * @param type {@link Locale.IsoCountryCode} specified ISO code type. * @see java.util.Locale.IsoCountryCode * @throws NullPointerException if type is null * @return a {@code Set} of ISO country codes for the specified type. * @since 9
*/ publicstatic Set<String> getISOCountries(IsoCountryCode type) {
Objects.requireNonNull(type); return IsoCountryCode.retrieveISOCountryCodes(type);
}
/** * Returns a list of all 2-letter language codes defined in ISO 639. * Can be used to obtain Locales. * <p> * <b>Note:</b> * <ul> * <li>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. * <li>The {@code 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 obtain Locales. * </ul> * * @return An array of ISO 639 two-letter language codes.
*/ publicstatic String[] getISOLanguages() {
String[] languages = Locale.isoLanguages; if (languages == null) {
Locale.isoLanguages = languages = getISO2Table(LocaleISOData.isoLanguageTable);
}
String[] result = new String[languages.length];
System.arraycopy(languages, 0, result, 0, languages.length); return result;
}
privatestatic String[] getISO2Table(String table) { int len = table.length() / 5;
String[] isoTable = new String[len]; for (int i = 0, j = 0; i < len; i++, j += 5) {
isoTable[i] = table.substring(j, j + 2);
} return isoTable;
}
/** * Returns the language code of this Locale. * * @implNote This method returns the new forms for the obsolete ISO 639 * codes ("iw", "ji", and "in"). See <a href="#legacy_language_codes"> * Legacy language codes</a> for more information. * * @return The language code, or the empty string if none is defined. * @see #getDisplayLanguage
*/ public String getLanguage() { return baseLocale.getLanguage();
}
/** * 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'. * * @return The script code, or the empty string if none is defined. * @see #getDisplayScript * @since 1.7
*/ public String getScript() { return baseLocale.getScript();
}
/** * 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. * * @return The country/region code, or the empty string if none is defined. * @see #getDisplayCountry
*/ public String getCountry() { return baseLocale.getRegion();
}
/** * Returns the variant code for this locale. * * @return The variant code, or the empty string if none is defined. * @see #getDisplayVariant
*/ public String getVariant() { return baseLocale.getVariant();
}
/** * Returns {@code true} if this {@code Locale} has any <a href="#def_extensions"> * extensions</a>. * * @return {@code true} if this {@code Locale} has any extensions * @since 1.8
*/ publicboolean hasExtensions() { return localeExtensions != null;
}
/** * Returns a copy of this {@code Locale} with no <a href="#def_extensions"> * extensions</a>. If this {@code Locale} has no extensions, this {@code Locale} * is returned. * * @return a copy of this {@code Locale} with no extensions, or {@code this} * if {@code this} has no extensions * @since 1.8
*/ public Locale stripExtensions() { return hasExtensions() ? Locale.getInstance(baseLocale, null) : this;
}
/** * 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 {@code [0-9A-Za-z]}. Keys are case-insensitive, so * for example 'z' and 'Z' represent the same extension. * * @param key the extension key * @return The extension, or null if this locale defines no * extension for the specified key. * @throws IllegalArgumentException if key is not well-formed * @see #PRIVATE_USE_EXTENSION * @see #UNICODE_LOCALE_EXTENSION * @since 1.7
*/ public String getExtension(char key) { if (!LocaleExtensions.isValidKey(key)) { thrownew IllegalArgumentException("Ill-formed extension key: " + key);
} return hasExtensions() ? localeExtensions.getExtensionValue(key) : null;
}
/** * 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. * * @return The set of extension keys, or the empty set if this locale has * no extensions. * @since 1.7
*/ public Set<Character> getExtensionKeys() { if (!hasExtensions()) { return Collections.emptySet();
} return localeExtensions.getKeys();
}
/** * 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. * * @return The set of attributes. * @since 1.7
*/ public Set<String> getUnicodeLocaleAttributes() { if (!hasExtensions()) { return Collections.emptySet();
} return localeExtensions.getUnicodeLocaleAttributes();
}
/** * 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. * * @param key the Unicode locale key * @return The Unicode locale type associated with the key, or null if the * locale does not define the key. * @throws IllegalArgumentException if the key is not well-formed * @throws NullPointerException if {@code key} is null * @since 1.7
*/ public String getUnicodeLocaleType(String key) { if (!isUnicodeExtensionKey(key)) { thrownew IllegalArgumentException("Ill-formed Unicode locale key: " + key);
} return hasExtensions() ? localeExtensions.getUnicodeLocaleType(key) : null;
}
/** * 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. * * @return The set of Unicode locale keys, or the empty set if this locale has * no Unicode locale keywords. * @since 1.7
*/ public Set<String> getUnicodeLocaleKeys() { if (localeExtensions == null) { return Collections.emptySet();
} return localeExtensions.getUnicodeLocaleKeys();
}
/** * Package locale method returning the Locale's BaseLocale, * used by ResourceBundle * @return base locale of this Locale
*/
BaseLocale getBaseLocale() { return baseLocale;
}
/** * Package private method returning the Locale's LocaleExtensions, * used by ResourceBundle. * @return locale extensions of this Locale, * or {@code null} if no extensions are defined
*/
LocaleExtensions getLocaleExtensions() { return localeExtensions;
}
/** * Returns a string representation of this {@code Locale} * object, consisting of language, country, variant, script, * and extensions as below: * <blockquote> * language + "_" + country + "_" + (variant + "_#" | "#") + script + "_" + extensions * </blockquote> * * 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 {@link #toLanguageTag}. * * <p>When the locale has neither script nor extensions, the result is the same as in * Java 6 and prior. * * <p>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). * * <p>If script or extensions are present and variant is missing, no underscore is * added before the "#". * * <p>This behavior is designed to support debugging and to be compatible with * previous uses of {@code toString} that expected language, country, and variant * fields only. To represent a Locale as a String for interchange purposes, use * {@link #toLanguageTag}. * * <p>Examples: <ul> * <li>{@code en}</li> * <li>{@code de_DE}</li> * <li>{@code _GB}</li> * <li>{@code en_US_WIN}</li> * <li>{@code de__POSIX}</li> * <li>{@code zh_CN_#Hans}</li> * <li>{@code zh_TW_#Hant_x-java}</li> * <li>{@code th_TH_TH_#u-nu-thai}</li></ul> * * @return A string representation of the Locale, for debugging. * @see #getDisplayName * @see #toLanguageTag
*/
@Override publicfinal String toString() { boolean l = !baseLocale.getLanguage().isEmpty(); boolean s = !baseLocale.getScript().isEmpty(); boolean r = !baseLocale.getRegion().isEmpty(); boolean v = !baseLocale.getVariant().isEmpty(); boolean e = localeExtensions != null && !localeExtensions.getID().isEmpty();
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 well-formed IETF BCP 47 language tag representing * this locale. * * <p>If this {@code 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: * * <p><b>Language:</b> If language is empty, or not <a * href="#def_language" >well-formed</a> (for example "a" or * "e2"), it will be emitted as "und" (Undetermined). * * <p><b>Country:</b> If country is not <a * href="#def_region">well-formed</a> (for example "12" or "USA"), * it will be omitted. * * <p><b>Variant:</b> If variant <b>is</b> <a * href="#def_variant">well-formed</a>, each sub-segment * (delimited by '-' or '_') is emitted as a subtag. Otherwise: * <ul> * * <li>if all sub-segments match <code>[0-9a-zA-Z]{1,8}</code> * (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". * * <li>if any sub-segment does not match * <code>[0-9a-zA-Z]{1,8}</code>, 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".</li></ul> * * <p><b>Special Conversions:</b> Java supports some old locale * representations, including deprecated ISO language codes, * for compatibility. This method performs the following * conversions: * <ul> * * <li>Deprecated ISO language codes "iw", "ji", and "in" are * converted to "he", "yi", and "id", respectively. * * <li>A locale with language "no", country "NO", and variant * "NY", representing Norwegian Nynorsk (Norway), is converted * to a language tag "nn-NO".</li></ul> * * <p><b>Note:</b> Although the language tag obtained 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, * <pre> * Locale.forLanguageTag("xx-YY").toLanguageTag();</pre> * * 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. * * @return a BCP47 language tag representing the locale * @see #forLanguageTag(String) * @since 1.7
*/ public String toLanguageTag() {
String lTag = this.languageTag; if (lTag != null) { return lTag;
}
LanguageTag tag = LanguageTag.parseLocale(baseLocale, localeExtensions);
StringBuilder buf = new StringBuilder();
String subtag = tag.getLanguage(); if (!subtag.isEmpty()) {
buf.append(LanguageTag.canonicalizeLanguage(subtag));
}
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.53Bemerkung:
Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
