The UCharacter class provides extensions to the {@link java.lang.Character} class. * These extensions provide support for more Unicode properties. * Each ICU release supports the latest version of Unicode available at that time. * *
For some time before Java 5 added support for supplementary Unicode code points, * The ICU UCharacter class and many other ICU classes already supported them. * Some UCharacter methods and constants were widened slightly differently than * how the Character class methods and constants were widened later. * In particular, {@link Character#MAX_VALUE} is still a char with the value U+FFFF, * while the {@link UCharacter#MAX_VALUE} is an int with the value U+10FFFF. * *
Code points are represented in these API using ints. While it would be * more convenient in Java to have a separate primitive datatype for them, * ints suffice in the meantime. * *
Aside from the additions for UTF-16 support, and the updated Unicode * properties, the main differences between UCharacter and Character are: *
* In addition to Java compatibility functions, which calculate derived properties, * this API provides low-level access to the Unicode Character Database. *
* Unicode assigns each code point (not just assigned character) values for * many properties. * Most of them are simple boolean flags, or constants from a small enumerated list. * For some properties, values are strings or other relatively more complex types. *
* For more information see * "About the Unicode Character Database" * (http://www.unicode.org/ucd/) * and the ICU * User Guide chapter on Properties * (http://www.icu-project.org/userguide/properties.html). *
* There are also functions that provide easy migration from C/POSIX functions * like isblank(). Their use is generally discouraged because the C/POSIX * standards do not define their semantics beyond the ASCII range, which means * that different implementations exhibit very different behavior. * Instead, Unicode properties should be used directly. *
* There are also only a few, broad C/POSIX character classes, and they tend * to be used for conflicting purposes. For example, the "isalpha()" class * is sometimes used to determine word boundaries, while a more sophisticated * approach would at least distinguish initial letters from continuation * characters (the latter including combining marks). * (In ICU, BreakIterator is the most sophisticated API for word boundaries.) * Another example: There is no "istitle()" class for titlecase characters. *
* ICU 3.4 and later provides API access for all twelve C/POSIX character classes. * ICU implements them according to the Standard Recommendations in * Annex C: Compatibility Properties of UTS #18 Unicode Regular Expressions * (http://www.unicode.org/reports/tr18/#Compatibility_Properties). *
* API access for C/POSIX character classes is as follows: *
{@code
* - alpha: isUAlphabetic(c) or hasBinaryProperty(c, UProperty.ALPHABETIC)
* - lower: isULowercase(c) or hasBinaryProperty(c, UProperty.LOWERCASE)
* - upper: isUUppercase(c) or hasBinaryProperty(c, UProperty.UPPERCASE)
* - punct: ((1<
*
* The C/POSIX character classes are also available in UnicodeSet patterns,
* using patterns like [:graph:] or \p{graph}.
*
*
{@icunote} There are several ICU (and Java) whitespace functions.
* Comparison:
* - isUWhiteSpace=UCHAR_WHITE_SPACE: Unicode White_Space property;
* most of general categories "Z" (separators) + most whitespace ISO controls
* (including no-break spaces, but excluding IS1..IS4 and ZWSP)
*
- isWhitespace: Java isWhitespace; Z + whitespace ISO controls but excluding no-break spaces
*
- isSpaceChar: just Z (including no-break spaces)
*
*
* This class is not subclassable.
*
* @author Syn Wee Quek
* @stable ICU 2.1
* @see com.ibm.icu.lang.UCharacterEnums
*/
--
# Remove ICU class docs that refer to provisional methods.
--type:android.icu.util.IslamicCalendar
/**
* IslamicCalendar is a subclass of Calendar
* that that implements the Islamic civil and religious calendars. It
* is used as the civil calendar in most of the Arab world and the
* liturgical calendar of the Islamic faith worldwide. This calendar
* is also known as the "Hijri" calendar, since it starts at the time
* of Mohammed's emigration (or "hijra") to Medinah on Thursday,
* July 15, 622 AD (Julian).
*
* The Islamic calendar is strictly lunar, and thus an Islamic year of twelve
* lunar months does not correspond to the solar year used by most other
* calendar systems, including the Gregorian. An Islamic year is, on average,
* about 354 days long, so each successive Islamic year starts about 11 days
* earlier in the corresponding Gregorian year.
*
* Each month of the calendar starts when the new moon's crescent is visible
* at sunset. However, in order to keep the time fields in this class
* synchronized with those of the other calendars and with local clock time,
* we treat days and months as beginning at midnight,
* roughly 6 hours after the corresponding sunset.
*
* There are three main variants of the Islamic calendar in existence. The first
* is the civil calendar, which uses a fixed cycle of alternating 29-
* and 30-day months, with a leap day added to the last month of 11 out of
* every 30 years. This calendar is easily calculated and thus predictable in
* advance, so it is used as the civil calendar in a number of Arab countries.
* This is the default behavior of a newly-created IslamicCalendar
* object.
*
* The Islamic religious calendar and Saudi Arabia's Umm al-Qura
* calendar, however, are based on the observation of the crescent moon.
* It is thus affected by the position at which the
* observations are made, seasonal variations in the time of sunset, the
* eccentricities of the moon's orbit, and even the weather at the observation
* site. This makes it impossible to calculate in advance, and it causes the
* start of a month in the religious calendar to differ from the civil calendar
* by up to three days.
*
* Using astronomical calculations for the position of the sun and moon, the
* moon's illumination, and other factors, it is possible to determine the start
* of a lunar month with a fairly high degree of certainty. However, these
* calculations are extremely complicated and thus slow, so most algorithms,
* including the one used here, are only approximations of the true astronomical
* calculations. At present, the approximations used in this class are fairly
* simplistic; they will be improved in later versions of the code.
*
* Like the Islamic religious calendar, Umm al-Qura is also based
* on the sighting method of the crescent moon but is standardized by Saudi Arabia.
*
* The fixed-cycle civil calendar is used.
*
* This class should not be subclassed.
*
* IslamicCalendar usually should be instantiated using
* {@link com.ibm.icu.util.Calendar#getInstance(ULocale)} passing in a ULocale
* with the tag "@calendar=islamic" or "@calendar=islamic-civil"
* or "@calendar=islamic-umalqura".
*
* @see com.ibm.icu.util.GregorianCalendar
* @see com.ibm.icu.util.Calendar
*
* @author Laura Werner
* @author Alan Liu
* @stable ICU 2.8
*/
--
# Remove @see reference to non-public class TimeUnitAmount.
--type:android.icu.util.TimeUnit
/**
* Measurement unit for time units.
* @see TimeUnit
* @author markdavis
* @stable ICU 4.0
*/
--
# Remove references to setDefault* methods that are hidden on Android.
--type:android.icu.util.TimeZone
/**
* {@icuenhanced java.util.TimeZone}.{@icu _usage_}
*
* TimeZone represents a time zone offset, and also computes daylight
* savings.
*
*
Typically, you get a TimeZone using {@link #getDefault()}
* which creates a TimeZone based on the time zone where the program
* is running. For example, for a program running in Japan, getDefault
* creates a TimeZone object based on Japanese Standard Time.
*
*
You can also get a TimeZone using {@link #getTimeZone(String)}
* along with a time zone ID. For instance, the time zone ID for the
* U.S. Pacific Time zone is "America/Los_Angeles". So, you can get a
* U.S. Pacific Time TimeZone object with:
*
*
*
* TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
*
*
* You can use the {@link #getAvailableIDs()} method to iterate through
* all the supported time zone IDs, or getCanonicalID method to check
* if a time zone ID is supported or not. You can then choose a
* supported ID to get a TimeZone.
* If the time zone you want is not represented by one of the
* supported IDs, then you can create a custom time zone ID with
* the following syntax:
*
*
*
* GMT[+|-]hh[[:]mm]
*
*
*
* For example, you might specify GMT+14:00 as a custom
* time zone ID. The TimeZone that is returned
* when you specify a custom time zone ID uses the specified
* offset from GMT(=UTC) and does not observe daylight saving
* time. For example, you might specify GMT+14:00 as a custom
* time zone ID to create a TimeZone representing 14 hours ahead
* of GMT (with no daylight saving time). In addition,
* getCanonicalID can also be used to
* normalize a custom time zone ID.
*
* For compatibility with JDK 1.1.x, some other three-letter time zone IDs
* (such as "PST", "CTT", "AST") are also supported. However, their
* use is deprecated because the same abbreviation is often used
* for multiple time zones (for example, "CST" could be U.S. "Central Standard
* Time" and "China Standard Time"), and the Java platform can then only
* recognize one of them.
*
* @see Calendar
* @see GregorianCalendar
* @see SimpleTimeZone
* @author Mark Davis, Deborah Goldsmith, Chen-Lieh Huang, Alan Liu
* @stable ICU 2.0
*/
--
# Remove references to {get,set}DefaultTimezoneType methods that are hidden on Android.
--field:android.icu.util.TimeZone#TIMEZONE_ICU
/**
* [icu] A time zone implementation type indicating ICU's own TimeZone used by
* getTimeZone.
*/
--
# Remove references to {get,set}DefaultTimezoneType methods that are hidden on Android.
--field:android.icu.util.TimeZone#TIMEZONE_JDK
/**
* [icu] A time zone implementation type indicating the {@link java.util.TimeZone}
* used by getTimeZone.
*/
--
# Remove ICU class docs that refer to provisional methods.
--type:android.icu.util.ULocale
/**
* {@icuenhanced java.util.Locale}.{@icu _usage_}
*
* A class analogous to {@link java.util.Locale} that provides additional
* support for ICU protocol. In ICU 3.0 this class is enhanced to support
* RFC 3066 language identifiers.
*
*
Many classes and services in ICU follow a factory idiom, in
* which a factory method or object responds to a client request with
* an object. The request includes a locale (the requested
* locale), and the returned object is constructed using data for that
* locale. The system may lack data for the requested locale, in
* which case the locale fallback mechanism will be invoked until a
* populated locale is found (the valid locale). Furthermore,
* even when a populated locale is found (the valid locale),
* further fallback may be required to reach a locale containing the
* specific data required by the service (the actual locale).
*
*
ULocale performs 'normalization' and 'canonicalization' of locale ids.
* Normalization 'cleans up' ICU locale ids as follows:
*
* - language, script, country, variant, and keywords are properly cased
* (lower, title, upper, upper, and lower case respectively)
* - hyphens used as separators are converted to underscores
* - three-letter language and country ids are converted to two-letter
* equivalents where available
* - surrounding spaces are removed from keywords and values
* - if there are multiple keywords, they are put in sorted order
*
* Canonicalization additionally performs the following:
*
* - POSIX ids are converted to ICU format IDs
* - 'grandfathered' 3066 ids are converted to ICU standard form
* - 'PREEURO' and 'EURO' variants are converted to currency keyword form,
* with the currency
* id appropriate to the country of the locale (for PREEURO) or EUR (for EURO).
*
* All ULocale constructors automatically normalize the locale id. To handle
* POSIX ids, canonicalize can be called to convert the id
* to canonical form, or the canonicalInstance factory method
* can be called.
*
* Note: The actual locale is returned correctly, but the valid
* locale is not, in most cases.
*
* @see java.util.Locale
* @author weiv
* @author Alan Liu
* @author Ram Viswanadha
* @stable ICU 2.8
*/
--
# Remove the reference to ULocale.setDefault() and remove system properties information.
--method:android.icu.util.ULocale#getDefault()
/**
* Returns the current default ULocale.
*
* The default ULocale is synchronized to the default Java Locale. This method checks
* the current default Java Locale and returns an equivalent ULocale.
*
* @return the default ULocale.
* @stable ICU 2.8
*/
--
# Removal of sentence containing link to class that is not exposed in Android API
--type:android.icu.text.UnicodeFilter
/**
* UnicodeFilter defines a protocol for selecting a
* subset of the full range (U+0000 to U+FFFF) of Unicode characters.
* @stable ICU 2.0
*/
--
# Document that collation rules are omitted.
--method:android.icu.text.RuleBasedCollator#getRules()
/**
* Gets the collation tailoring rules for this RuleBasedCollator.
* Equivalent to String getRules(false).
*
*
On Android, the returned string will be empty unless this instance was
* constructed using {@link #RuleBasedCollator(String)}.
*
* @return the collation tailoring rules
* @see #getRules(boolean)
* @stable ICU 2.8
*/
--
# Deprecate method.
--method:android.icu.util.Calendar#computeZoneOffset(long,int)
/**
* This method can assume EXTENDED_YEAR has been set.
* @param millis milliseconds of the date fields (local midnight millis)
* @param millisInDay milliseconds of the time fields; may be out
* or range.
* @return total zone offset (raw + DST) for the given moment
* @stable ICU 2.0
* @deprecated This method suffers from a potential integer overflow and may be removed or
* changed in a future release. See
* ICU ticket #11632 for details.
*/
--
# Deprecate method.
--method:android.icu.util.Calendar#computeMillisInDay()
/**
* Compute the milliseconds in the day from the fields. This is a
* value from 0 to 23:59:59.999 inclusive, unless fields are out of
* range, in which case it can be an arbitrary value. This value
* reflects local zone wall time.
* @stable ICU 2.0
* @deprecated This method suffers from a potential integer overflow and may be removed or
* changed in a future release. See
* ICU ticket #11632 for details.
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getZeroDigit()
/**
* Returns the character used for zero. Different for Arabic, etc.
* @return the character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getDigits()
/**
* Returns the array of characters used as digits, in order from 0 through 9
* @return The array
* @stable ICU 4.6
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#setZeroDigit(char)
/**
* Sets the character used for zero.
*
* Note: When the specified zeroDigit is a Unicode decimal digit character
* (category:Nd) and the number value is 0, then this method propagate digit 1 to
* digit 9 by incrementing code point one by one.
*
* @param zeroDigit the zero character.
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getGroupingSeparator()
/**
* Returns the character used for grouping separator. Different for French, etc.
* @return the thousands character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getDecimalSeparator()
/**
* Returns the character used for decimal sign. Different for French, etc.
* @return the decimal character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getPerMill()
/**
* Returns the character used for mille percent sign. Different for Arabic, etc.
* @return the mille percent character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getPercent()
/**
* Returns the character used for percent sign. Different for Arabic, etc.
* @return the percent character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getMinusSign()
/**
* Returns the character used to represent minus sign. If no explicit
* negative format is specified, one is formed by prefixing
* minusSign to the positive format.
* @return the minus sign character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getPlusSign()
/**
* {@icu} Returns the localized plus sign.
* @return the plus sign, used in localized patterns and formatted
* strings
* @see #setPlusSign
* @see #setMinusSign
* @see #getMinusSign
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getMonetaryDecimalSeparator()
/**
* Returns the monetary decimal separator.
* @return the monetary decimal separator character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#getMonetaryGroupingSeparator()
/**
* {@icu} Returns the monetary grouping separator.
* @return the monetary grouping separator character
* @stable ICU 3.6
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.DecimalFormatSymbols#setGroupingSeparator(char)
/**
* Sets the character used for grouping separator. Different for French, etc.
* @param groupingSeparator the thousands character
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.Normalizer#compare(char[],char[],int)
/**
* Compare two strings for canonical equivalence.
* Further options include case-insensitive comparison and
* code point order (as opposed to code unit order).
* Convenience method.
*
* @param s1 First source string.
* @param s2 Second source string.
*
* @param options A bit set of options:
* - FOLD_CASE_DEFAULT or 0 is used for default options:
* Case-sensitive comparison in code unit order, and the input strings
* are quick-checked for FCD.
*
* - INPUT_IS_FCD
* Set if the caller knows that both s1 and s2 fulfill the FCD
* conditions. If not set, the function will quickCheck for FCD
* and normalize if necessary.
*
* - COMPARE_CODE_POINT_ORDER
* Set to choose code point order instead of code unit order
*
* - COMPARE_IGNORE_CASE
* Set to compare strings case-insensitively using case folding,
* instead of case-sensitively.
* If set, then the following case folding options are used.
*
* @return <0 or 0 or >0 as usual for string comparisons
*
* @stable ICU 2.8
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.Normalizer#compare(char[],int,int,char[],int,int,int)
/**
* Compare two strings for canonical equivalence.
* Further options include case-insensitive comparison and
* code point order (as opposed to code unit order).
*
* Canonical equivalence between two strings is defined as their normalized
* forms (NFD or NFC) being identical.
* This function compares strings incrementally instead of normalizing
* (and optionally case-folding) both strings entirely,
* improving performance significantly.
*
* Bulk normalization is only necessary if the strings do not fulfill the
* FCD conditions. Only in this case, and only if the strings are relatively
* long, is memory allocated temporarily.
* For FCD strings and short non-FCD strings there is no memory allocation.
*
* Semantically, this is equivalent to
* strcmp[CodePointOrder](foldCase(NFD(s1)), foldCase(NFD(s2)))
* where code point order and foldCase are all optional.
*
* @param s1 First source character array.
* @param s1Start start index of source
* @param s1Limit limit of the source
*
* @param s2 Second source character array.
* @param s2Start start index of the source
* @param s2Limit limit of the source
*
* @param options A bit set of options:
* - FOLD_CASE_DEFAULT or 0 is used for default options:
* Case-sensitive comparison in code unit order, and the input strings
* are quick-checked for FCD.
*
* - INPUT_IS_FCD
* Set if the caller knows that both s1 and s2 fulfill the FCD
* conditions.If not set, the function will quickCheck for FCD
* and normalize if necessary.
*
* - COMPARE_CODE_POINT_ORDER
* Set to choose code point order instead of code unit order
*
* - COMPARE_IGNORE_CASE
* Set to compare strings case-insensitively using case folding,
* instead of case-sensitively.
* If set, then the following case folding options are used.
*
*
* @return <0 or 0 or >0 as usual for string comparisons
*
* @stable ICU 2.8
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.Normalizer#compare(String,String,int)
/**
* Compare two strings for canonical equivalence.
* Further options include case-insensitive comparison and
* code point order (as opposed to code unit order).
*
* Canonical equivalence between two strings is defined as their normalized
* forms (NFD or NFC) being identical.
* This function compares strings incrementally instead of normalizing
* (and optionally case-folding) both strings entirely,
* improving performance significantly.
*
* Bulk normalization is only necessary if the strings do not fulfill the
* FCD conditions. Only in this case, and only if the strings are relatively
* long, is memory allocated temporarily.
* For FCD strings and short non-FCD strings there is no memory allocation.
*
* Semantically, this is equivalent to
* strcmp[CodePointOrder](foldCase(NFD(s1)), foldCase(NFD(s2)))
* where code point order and foldCase are all optional.
*
* @param s1 First source string.
* @param s2 Second source string.
*
* @param options A bit set of options:
* - FOLD_CASE_DEFAULT or 0 is used for default options:
* Case-sensitive comparison in code unit order, and the input strings
* are quick-checked for FCD.
*
* - INPUT_IS_FCD
* Set if the caller knows that both s1 and s2 fulfill the FCD
* conditions. If not set, the function will quickCheck for FCD
* and normalize if necessary.
*
* - COMPARE_CODE_POINT_ORDER
* Set to choose code point order instead of code unit order
*
* - COMPARE_IGNORE_CASE
* Set to compare strings case-insensitively using case folding,
* instead of case-sensitively.
* If set, then the following case folding options are used.
*
* @return <0 or 0 or >0 as usual for string comparisons
*
* @stable ICU 2.8
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.Collator#getCollationKey(String)
/**
*
* Transforms the String into a CollationKey suitable for efficient
* repeated comparison. The resulting key depends on the collator's
* rules, strength and decomposition mode.
*
*
Note that collation keys are often less efficient than simply doing comparison.
* For more details, see the ICU User Guide.
*
*
See the CollationKey class documentation for more information.
* @param source the string to be transformed into a CollationKey.
* @return the CollationKey for the given String based on this Collator's
* collation rules. If the source String is null, a null
* CollationKey is returned.
* @see CollationKey
* @see #compare(String, String)
* @stable ICU 2.8
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.text.RuleBasedCollator#getCollationKey(String)
/**
*
* Get a Collation key for the argument String source from this RuleBasedCollator.
*
* General recommendation:
* If comparison are to be done to the same String multiple times, it would be more efficient to generate
* CollationKeys for the Strings and use CollationKey.compareTo(CollationKey) for the comparisons. If the each
* Strings are compared to only once, using the method RuleBasedCollator.compare(String, String) will have a better
* performance.
*
* See the class documentation for an explanation about CollationKeys.
*
* @param source
* the text String to be transformed into a collation key.
* @return the CollationKey for the given String based on this RuleBasedCollator's collation rules. If the source
* String is null, a null CollationKey is returned.
* @see CollationKey
* @see #compare(String, String)
* @stable ICU 2.8
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.util.Calendar#isWeekend(Date)
/**
* {@icu} Returns true if the given date and time is in the weekend in this calendar
* system. Equivalent to calling setTime() followed by isWeekend(). Note: This
* method changes the time this calendar is set to.
* @param date the date and time
* @return true if the given date and time is part of the
* weekend
* @see #isWeekend()
* @stable ICU 2.0
*/
--
# Removal of reference to method that is not exposed in Android API
--method:android.icu.util.Calendar#isWeekend()
/**
* {@icu} Returns true if this Calendar's current date and time is in the weekend in
* this calendar system.
* @return true if the given date and time is part of the
* weekend
* @see #isWeekend(Date)
* @stable ICU 2.0
*/
--