UCharacter

FOLD_CASE_DEFAULT

static val FOLD_CASE_DEFAULT: Int

[icu] Option value for case folding: use default mappings defined in CaseFolding.txt.

Value: 0

FOLD_CASE_EXCLUDE_SPECIAL_I

static val FOLD_CASE_EXCLUDE_SPECIAL_I: Int

[icu] Option value for case folding: Use the modified set of mappings provided in CaseFolding.txt to handle dotted I and dotless i appropriately for Turkic languages (tr, az).

Before Unicode 3.2, CaseFolding.txt contains mappings marked with 'I' that are to be included for default mappings and excluded for the Turkic-specific mappings.

Unicode 3.2 CaseFolding.txt instead contains mappings marked with 'T' that are to be excluded for default mappings and included for the Turkic-specific mappings.

Value: 1

MAX_CODE_POINT

static val MAX_CODE_POINT: Int

Constant U+10FFFF, same as Character#MAX_CODE_POINT.

Value: 1114111

MAX_HIGH_SURROGATE

static val MAX_HIGH_SURROGATE: Char

Constant U+DBFF, same as Character#MAX_HIGH_SURROGATE.

Value: 56319

MAX_LOW_SURROGATE

static val MAX_LOW_SURROGATE: Char

Constant U+DFFF, same as Character#MAX_LOW_SURROGATE.

Value: 57343

MAX_RADIX

static val MAX_RADIX: Int

Compatibility constant for Java Character's MAX_RADIX.

Value: 36

MAX_SURROGATE

static val MAX_SURROGATE: Char

Constant U+DFFF, same as Character#MAX_SURROGATE.

Value: 57343

MAX_VALUE

static val MAX_VALUE: Int

The highest Unicode code point value (scalar value), constant U+10FFFF (uses 21 bits). Same as Character#MAX_CODE_POINT.

Up-to-date Unicode implementation of Character#MAX_VALUE which is still a char with the value U+FFFF.

Value: 1114111

MIN_CODE_POINT

static val MIN_CODE_POINT: Int

Constant U+0000, same as Character#MIN_CODE_POINT.

Value: 0

MIN_HIGH_SURROGATE

static val MIN_HIGH_SURROGATE: Char

Constant U+D800, same as Character#MIN_HIGH_SURROGATE.

Value: 55296

MIN_LOW_SURROGATE

static val MIN_LOW_SURROGATE: Char

Constant U+DC00, same as Character#MIN_LOW_SURROGATE.

Value: 56320

MIN_RADIX

static val MIN_RADIX: Int

Compatibility constant for Java Character's MIN_RADIX.

Value: 2

MIN_SUPPLEMENTARY_CODE_POINT

static val MIN_SUPPLEMENTARY_CODE_POINT: Int

Constant U+10000, same as Character#MIN_SUPPLEMENTARY_CODE_POINT.

Value: 65536

MIN_SURROGATE

static val MIN_SURROGATE: Char

Constant U+D800, same as Character#MIN_SURROGATE.

Value: 55296

MIN_VALUE

static val MIN_VALUE: Int

The lowest Unicode code point value, constant 0. Same as Character#MIN_CODE_POINT, same integer value as Character#MIN_VALUE.

Value: 0

NO_NUMERIC_VALUE

static val NO_NUMERIC_VALUE: Double

Special value that is returned by getUnicodeNumericValue(int) when no numeric value is defined for a code point.

Value: -1.23456789E8

REPLACEMENT_CHAR

static val REPLACEMENT_CHAR: Int

Unicode value used when translating into Unicode encoding form and there is no existing character.

Value: 65533

SUPPLEMENTARY_MIN_VALUE

static val SUPPLEMENTARY_MIN_VALUE: Int

The minimum value for Supplementary code points, constant U+10000. Same as Character#MIN_SUPPLEMENTARY_CODE_POINT.

Value: 65536

TITLECASE_NO_BREAK_ADJUSTMENT

static val TITLECASE_NO_BREAK_ADJUSTMENT: Int

Do not adjust the titlecasing indexes from BreakIterator::next() indexes; titlecase exactly the characters at breaks from the iterator. Option bit for titlecasing APIs that take an options bit set. By default, titlecasing will take each break iterator index, adjust it by looking for the next cased character, and titlecase that one. Other characters are lowercased. This follows Unicode 4 & 5 section 3.13 Default Case Operations: R3 toTitlecase(X): Find the word boundaries based on Unicode Standard Annex #29, "Text Boundaries." Between each pair of word boundaries, find the first cased character F. If F exists, map F to default_title(F); then map each subsequent character C to default_lower(C).

Value: 512

TITLECASE_NO_LOWERCASE

static val TITLECASE_NO_LOWERCASE: Int

Do not lowercase non-initial parts of words when titlecasing. Option bit for titlecasing APIs that take an options bit set. By default, titlecasing will titlecase the first cased character of a word and lowercase all other characters. With this option, the other characters will not be modified.

Value: 256

charCount

static fun charCount(cp: Int): Int

Same as Character#charCount. Returns the number of chars needed to represent the code point (1 or 2). This does not check the code point for validity.

codePointAt

static fun codePointAt(
    seq: CharSequence!, 
    index: Int
): Int

Same as Character#codePointAt(CharSequence, int). Returns the code point at index. This examines only the characters at index and index+1.

codePointAt

static fun codePointAt(
    text: CharArray!, 
    index: Int
): Int

Same as Character#codePointAt(char[], int). Returns the code point at index. This examines only the characters at index and index+1.

codePointAt

static fun codePointAt(
    text: CharArray!, 
    index: Int, 
    limit: Int
): Int

Same as Character#codePointAt(char[], int, int). Returns the code point at index. This examines only the characters at index and index+1.

codePointBefore

static fun codePointBefore(
    seq: CharSequence!, 
    index: Int
): Int

Same as Character#codePointBefore(CharSequence, int). Return the code point before index. This examines only the characters at index-1 and index-2.

codePointBefore

static fun codePointBefore(
    text: CharArray!, 
    index: Int
): Int

Same as Character#codePointBefore(char[], int). Returns the code point before index. This examines only the characters at index-1 and index-2.

codePointBefore

static fun codePointBefore(
    text: CharArray!, 
    index: Int, 
    limit: Int
): Int

Same as Character#codePointBefore(char[], int, int). Return the code point before index. This examines only the characters at index-1 and index-2.

codePointCount

static fun codePointCount(
    text: CharSequence!, 
    start: Int, 
    limit: Int
): Int

Equivalent to the Character#codePointCount(CharSequence, int, int) method, for convenience. Counts the number of code points in the range of text.

codePointCount

static fun codePointCount(
    text: CharArray!, 
    start: Int, 
    limit: Int
): Int

Equivalent to the Character#codePointCount(char[], int, int) method, for convenience. Counts the number of code points in the range of text.

digit

static fun digit(
    ch: Int, 
    radix: Int
): Int

Returnss the numeric value of a decimal digit code point.
This method observes the semantics of java.lang.Character.digit(). Note that this will return positive values for code points for which isDigit returns false, just like java.lang.Character.
Semantic Change: In release 1.3.1 and prior, this did not treat the European letters as having a digit value, and also treated numeric letters and other numbers as digits. This has been changed to conform to the java semantics.
A code point is a valid digit if and only if:

• ch is a decimal digit or one of the european letters, and
• the value of ch is less than the specified radix.

digit

static fun digit(ch: Int): Int

Returnss the numeric value of a decimal digit code point.
This is a convenience overload of digit(int, int) that provides a decimal radix.
Semantic Change: In release 1.3.1 and prior, this treated numeric letters and other numbers as digits. This has been changed to conform to the java semantics.

foldCase

static fun foldCase(
    ch: Int, 
    defaultmapping: Boolean
): Int

[icu] The given character is mapped to its case folding equivalent according to UnicodeData.txt and CaseFolding.txt; if the character has no case folding equivalent, the character itself is returned.

This function only returns the simple, single-code point case mapping. Full case mappings should be used whenever possible because they produce better results by working on whole strings. They can map to a result string with a different length as appropriate. Full case mappings are applied by the case mapping functions that take String parameters rather than code points (int). See also the User Guide chapter on C/POSIX migration: https://unicode-org.github.io/icu/userguide/icu/posix#case-mappings

foldCase

static fun foldCase(
    str: String!, 
    defaultmapping: Boolean
): String!

[icu] The given string is mapped to its case folding equivalent according to UnicodeData.txt and CaseFolding.txt; if any character has no case folding equivalent, the character itself is returned. "Full", multiple-code point case folding mappings are returned here. For "simple" single-code point mappings use the API foldCase(int ch, boolean defaultmapping).

foldCase

static fun foldCase(
    ch: Int, 
    options: Int
): Int

[icu] The given character is mapped to its case folding equivalent according to UnicodeData.txt and CaseFolding.txt; if the character has no case folding equivalent, the character itself is returned.

This function only returns the simple, single-code point case mapping. Full case mappings should be used whenever possible because they produce better results by working on whole strings. They can map to a result string with a different length as appropriate. Full case mappings are applied by the case mapping functions that take String parameters rather than code points (int). See also the User Guide chapter on C/POSIX migration: https://unicode-org.github.io/icu/userguide/icu/posix#case-mappings

foldCase

static fun foldCase(
    str: String!, 
    options: Int
): String!

[icu] The given string is mapped to its case folding equivalent according to UnicodeData.txt and CaseFolding.txt; if any character has no case folding equivalent, the character itself is returned. "Full", multiple-code point case folding mappings are returned here. For "simple" single-code point mappings use the API foldCase(int ch, boolean defaultmapping).

forDigit

static fun forDigit(
    digit: Int, 
    radix: Int
): Char

Provide the java.lang.Character forDigit API, for convenience.

getAge

static fun getAge(ch: Int): VersionInfo!

[icu] Returns the "age" of the code point.

The "age" is the Unicode version when the code point was first designated (as a non-character or for Private Use) or assigned a character.

This can be useful to avoid emitting code points to receiving processes that do not accept newer characters.

The data is from the UCD file DerivedAge.txt.

getBidiPairedBracket

static fun getBidiPairedBracket(c: Int): Int

[icu] Maps the specified character to its paired bracket character. For Bidi_Paired_Bracket_Type!=None, this is the same as getMirror(int). Otherwise c itself is returned. See http://www.unicode.org/reports/tr9/

getCharFromExtendedName

static fun getCharFromExtendedName(name: String!): Int

[icu]

Find a Unicode character by either its name and return its code point value. All Unicode names are in uppercase. Extended names are all lowercase except for numbers and are contained within angle brackets. The names are searched in the following order

• Most current Unicode name if there is any
• Unicode 1.0 name if there is any
• Extended name in the form of "<codepoint_type-codepoint_hex_digits>". E.g. <noncharacter-FFFE>

getCharFromName

static fun getCharFromName(name: String!): Int

[icu]

Finds a Unicode code point by its most current Unicode name and return its code point value. All Unicode names are in uppercase. Note calling any methods related to code point names, e.g. getName() incurs a one-time initialization cost to construct the name tables.

getCharFromNameAlias

static fun getCharFromNameAlias(name: String!): Int

[icu]

Find a Unicode character by its corrected name alias and return its code point value. All Unicode names are in uppercase. Note calling any methods related to code point names, e.g. getName() incurs a one-time initialization cost to construct the name tables.

getCodePoint

static fun getCodePoint(
    lead: Int, 
    trail: Int
): Int

[icu] Returns a code point corresponding to the two surrogate code units.

getCodePoint

static fun getCodePoint(
    lead: Char, 
    trail: Char
): Int

[icu] Returns a code point corresponding to the two surrogate code units.

getCodePoint

static fun getCodePoint(char16: Char): Int

[icu] Returns the code point corresponding to the BMP code point.

getCombiningClass

static fun getCombiningClass(ch: Int): Int

[icu] Returns the combining class of the argument codepoint

getDirection

static fun getDirection(ch: Int): Int

[icu] Returns the Bidirection property of a code point. For example, 0x0041 (letter A) has the LEFT_TO_RIGHT directional property.
Result returned belongs to the interface UCharacterDirection

getDirectionality

static fun getDirectionality(cp: Int): Byte

Equivalent to the Character#getDirectionality(char) method, for convenience. Returns a byte representing the directionality of the character. [icu] Note: Unlike Character#getDirectionality(char), this returns DIRECTIONALITY_LEFT_TO_RIGHT for undefined or out-of-bounds characters. [icu] Note: The return value must be tested using the constants defined in UCharacterDirection and its interface UCharacterEnums.ECharacterDirection since the values are different from the ones defined by java.lang.Character.

getExtendedName

static fun getExtendedName(ch: Int): String!

[icu] Returns a name for a valid codepoint. Unlike, getName(int) and getName1_0(int), this method will return a name even for codepoints that are not assigned a name in UnicodeData.txt.

The names are returned in the following order.

• Most current Unicode name if there is any
• Unicode 1.0 name if there is any
• Extended name in the form of "<codepoint_type-codepoint_hex_digits>". E.g., <noncharacter-fffe>

getExtendedNameIterator

static fun getExtendedNameIterator(): ValueIterator!

[icu]

Returns an iterator for character names, iterating over codepoints.

This API only gets the iterator for the extended names. For modern, most up-to-date Unicode names use getNameIterator() or for older 1.0 Unicode names use get1_0NameIterator().

Example of use:

ValueIterator iterator = UCharacter.getExtendedNameIterator();
  ValueIterator.Element element = new ValueIterator.Element();
  while (iterator.next(element)) {
      System.out.println("Codepoint \\u" +
                         Integer.toHexString(element.codepoint) +
                         " has the name " + (String)element.value);
  }
  

The maximal range which the name iterator iterates is from

getHanNumericValue

static fun getHanNumericValue(ch: Int): Int

[icu] Returns the numeric value of a Han character.

This returns the value of Han 'numeric' code points, including those for zero, ten, hundred, thousand, ten thousand, and hundred million. This includes both the standard and 'checkwriting' characters, the 'big circle' zero character, and the standard zero character.

Note: The Unicode Standard has numeric values for more Han characters recognized by this method (see getNumericValue(int) and the UCD file DerivedNumericValues.txt), and a android.icu.text.NumberFormat can be used with a Chinese android.icu.text.NumberingSystem.

getIntPropertyMaxValue

static fun getIntPropertyMaxValue(type: Int): Int

[icu] Returns the maximum value for an integer/binary Unicode property. Can be used together with UCharacter.getIntPropertyMinValue(int) to allocate arrays of android.icu.text.UnicodeSet or similar. Examples for min/max values (for Unicode 3.2):

• UProperty.BIDI_CLASS: 0/18 (UCharacterDirection.LEFT_TO_RIGHT/UCharacterDirection.BOUNDARY_NEUTRAL)
• UProperty.SCRIPT: 0/45 (UScript.COMMON/UScript.TAGBANWA)
• UProperty.IDEOGRAPHIC: 0/1 (false/true)

getIntPropertyMinValue

static fun getIntPropertyMinValue(type: Int): Int

[icu] Returns the minimum value for an integer/binary Unicode property type. Can be used together with UCharacter.getIntPropertyMaxValue(int) to allocate arrays of android.icu.text.UnicodeSet or similar.

getIntPropertyValue

static fun getIntPropertyValue(
    ch: Int, 
    type: Int
): Int

[icu] Returns the property value for a Unicode property type of a code point. Also returns binary and mask property values.

Unicode, especially in version 3.2, defines many more properties than the original set in UnicodeData.txt.

The properties APIs are intended to reflect Unicode properties as defined in the Unicode Character Database (UCD) and Unicode Technical Reports (UTR). For details about the properties see http://www.unicode.org/.

For names of Unicode properties see the UCD file PropertyAliases.txt.

Sample usage:
  int ea = UCharacter.getIntPropertyValue(c, UProperty.EAST_ASIAN_WIDTH);
  int ideo = UCharacter.getIntPropertyValue(c, UProperty.IDEOGRAPHIC);
  boolean b = (ideo == 1) ? true : false;
  

getMirror

static fun getMirror(ch: Int): Int

[icu] Maps the specified code point to a "mirror-image" code point. For code points with the "mirrored" property, implementations sometimes need a "poor man's" mapping to another code point such that the default glyph may serve as the mirror-image of the default glyph of the specified code point.
This is useful for text conversion to and from codepages with visual order, and for displays without glyph selection capabilities.

getName

static fun getName(ch: Int): String!

[icu] Returns the most current Unicode name of the argument code point, or null if the character is unassigned or outside the range UCharacter.MIN_VALUE and UCharacter.MAX_VALUE or does not have a name.
Note calling any methods related to code point names, e.g. getName() incurs a one-time initialization cost to construct the name tables.

getName

static fun getName(
    s: String!, 
    separator: String!
): String!

[icu] Returns the names for each of the characters in a string

getNameAlias

static fun getNameAlias(ch: Int): String!

[icu] Returns the corrected name from NameAliases.txt if there is one. Returns null if the character is unassigned or outside the range UCharacter.MIN_VALUE and UCharacter.MAX_VALUE or does not have a name.
Note calling any methods related to code point names, e.g. getName() incurs a one-time initialization cost to construct the name tables.

getNameIterator

static fun getNameIterator(): ValueIterator!

[icu]

Returns an iterator for character names, iterating over codepoints.

This API only gets the iterator for the modern, most up-to-date Unicode names. For older 1.0 Unicode names use get1_0NameIterator() or for extended names use getExtendedNameIterator().

Example of use:

ValueIterator iterator = UCharacter.getNameIterator();
  ValueIterator.Element element = new ValueIterator.Element();
  while (iterator.next(element)) {
      System.out.println("Codepoint \\u" +
                         Integer.toHexString(element.codepoint) +
                         " has the name " + (String)element.value);
  }
  

The maximal range which the name iterator iterates is from UCharacter.MIN_VALUE to UCharacter.MAX_VALUE.

getNumericValue

static fun getNumericValue(ch: Int): Int

Returns the numeric value of the code point as a nonnegative integer.
If the code point does not have a numeric value, then -1 is returned.
If the code point has a numeric value that cannot be represented as a nonnegative integer (for example, a fractional value), then -2 is returned.

getPropertyEnum

static fun getPropertyEnum(propertyAlias: CharSequence!): Int

[icu] Return the UProperty selector for a given property name, as specified in the Unicode database file PropertyAliases.txt. Short, long, and any other variants are recognized. In addition, this function maps the synthetic names "gcm" / "General_Category_Mask" to the property UProperty.GENERAL_CATEGORY_MASK. These names are not in PropertyAliases.txt.

getPropertyName

static fun getPropertyName(
    property: Int, 
    nameChoice: Int
): String!

[icu] Return the Unicode name for a given property, as given in the Unicode database file PropertyAliases.txt. Most properties have more than one name. The nameChoice determines which one is returned. In addition, this function maps the property UProperty.GENERAL_CATEGORY_MASK to the synthetic names "gcm" / "General_Category_Mask". These names are not in PropertyAliases.txt.

getPropertyValueEnum

static fun getPropertyValueEnum(
    property: Int, 
    valueAlias: CharSequence!
): Int

[icu] Return the property value integer for a given value name, as specified in the Unicode database file PropertyValueAliases.txt. Short, long, and any other variants are recognized. Note: Some of the names in PropertyValueAliases.txt will only be recognized with UProperty.GENERAL_CATEGORY_MASK, not UProperty.GENERAL_CATEGORY. These include: "C" / "Other", "L" / "Letter", "LC" / "Cased_Letter", "M" / "Mark", "N" / "Number", "P" / "Punctuation", "S" / "Symbol", and "Z" / "Separator".

getPropertyValueName

static fun getPropertyValueName(
    property: Int, 
    value: Int, 
    nameChoice: Int
): String!

[icu] Return the Unicode name for a given property value, as given in the Unicode database file PropertyValueAliases.txt. Most values have more than one name. The nameChoice determines which one is returned. Note: Some of the names in PropertyValueAliases.txt can only be retrieved using UProperty.GENERAL_CATEGORY_MASK, not UProperty.GENERAL_CATEGORY. These include: "C" / "Other", "L" / "Letter", "LC" / "Cased_Letter", "M" / "Mark", "N" / "Number", "P" / "Punctuation", "S" / "Symbol", and "Z" / "Separator".

getType

static fun getType(ch: Int): Int

Returns a value indicating a code point's Unicode category. Up-to-date Unicode implementation of java.lang.Character.getType() except for the above mentioned code points that had their category changed.
Return results are constants from the interface UCharacterCategory
NOTE: the UCharacterCategory values are not compatible with those returned by java.lang.Character.getType. UCharacterCategory values match the ones used in ICU4C, while java.lang.Character type values, though similar, skip the value 17.

getTypeIterator

static fun getTypeIterator(): RangeValueIterator!

[icu]

Returns an iterator for character types, iterating over codepoints.

Example of use:

RangeValueIterator iterator = UCharacter.getTypeIterator();
  RangeValueIterator.Element element = new RangeValueIterator.Element();
  while (iterator.next(element)) {
      System.out.println("Codepoint \\u" +
                         Integer.toHexString(element.start) +
                         " to codepoint \\u" +
                         Integer.toHexString(element.limit - 1) +
                         " has the character type " +
                         element.value);
  }
  

getUnicodeNumericValue

static fun getUnicodeNumericValue(ch: Int): Double

[icu] Returns the numeric value for a Unicode code point as defined in the Unicode Character Database.

A "double" return type is necessary because some numeric values are fractions, negative, or too large for int.

For characters without any numeric values in the Unicode Character Database, this function will return NO_NUMERIC_VALUE. Note: This is different from the Unicode Standard which specifies NaN as the default value.

API Change: In release 2.2 and prior, this API has a return type int and returns -1 when the argument ch does not have a corresponding numeric value. This has been changed to synch with ICU4C This corresponds to the ICU4C function u_getNumericValue.

getUnicodeVersion

static fun getUnicodeVersion(): VersionInfo!

[icu] Returns the version of Unicode data used.

hasBinaryProperty

static fun hasBinaryProperty(
    ch: Int, 
    property: Int
): Boolean

[icu] Check a binary Unicode property for a code point.

Unicode, especially in version 3.2, defines many more properties than the original set in UnicodeData.txt.

This API is intended to reflect Unicode properties as defined in the Unicode Character Database (UCD) and Unicode Technical Reports (UTR).

For details about the properties see http://www.unicode.org/.

For names of Unicode properties see the UCD file PropertyAliases.txt.

This API does not check the validity of the codepoint.

Important: If ICU is built with UCD files from Unicode versions below 3.2, then properties marked with "new" are not or not fully available.

hasBinaryProperty

static fun hasBinaryProperty(
    s: CharSequence!, 
    property: Int
): Boolean

[icu] Returns true if the property is true for the string. Same as hasBinaryProperty(int,int) if the string contains exactly one code point.

Most properties apply only to single code points. UTS #51 Unicode Emoji defines several properties of strings.

isBMP

static fun isBMP(ch: Int): Boolean

[icu] Determines if the code point is in the BMP plane.

isBaseForm

static fun isBaseForm(ch: Int): Boolean

[icu] Determines whether the specified code point is of base form. A code point of base form does not graphically combine with preceding characters, and is neither a control nor a format character.

isDefined

static fun isDefined(ch: Int): Boolean

Determines if a code point has a defined meaning in the up-to-date Unicode standard. E.g. supplementary code points though allocated space are not defined in Unicode yet.
Up-to-date Unicode implementation of java.lang.Character.isDefined()

isDigit

static fun isDigit(ch: Int): Boolean

Determines if a code point is a Java digit.
This method observes the semantics of java.lang.Character.isDigit(). It returns true for decimal digits only.
Semantic Change: In release 1.3.1 and prior, this treated numeric letters and other numbers as digits. This has been changed to conform to the java semantics.

isHighSurrogate

static fun isHighSurrogate(codePoint: Int): Boolean

Same as Character#isHighSurrogate, except that the ICU version accepts int for code points.

isHighSurrogate

static fun isHighSurrogate(ch: Char): Boolean

Same as Character#isHighSurrogate,

isISOControl

static fun isISOControl(ch: Int): Boolean

Determines if the specified code point is an ISO control character. A code point is considered to be an ISO control character if it is in the range \u0000 through \u001F or in the range \u007F through \u009F.
Up-to-date Unicode implementation of java.lang.Character.isISOControl()

isIdentifierIgnorable

static fun isIdentifierIgnorable(ch: Int): Boolean

Determines if the specified code point should be regarded as an ignorable character in a Java identifier. A character is Java-identifier-ignorable if it has the general category Cf Formatting Control, or it is a non-Java-whitespace ISO control: U+0000..U+0008, U+000E..U+001B, U+007F..U+009F.
Up-to-date Unicode implementation of java.lang.Character.isIdentifierIgnorable().
See UTR #8.

Note that Unicode just recommends to ignore Cf (format controls).

isJavaIdentifierPart

static fun isJavaIdentifierPart(cp: Int): Boolean

Compatibility override of Java method, delegates to java.lang.Character.isJavaIdentifierPart.

isJavaIdentifierStart

static fun isJavaIdentifierStart(cp: Int): Boolean

Compatibility override of Java method, delegates to java.lang.Character.isJavaIdentifierStart.

isLegal

static fun isLegal(ch: Int): Boolean

[icu] A code point is illegal if and only if

• Out of bounds, less than 0 or greater than UCharacter.MAX_VALUE
• A surrogate value, 0xD800 to 0xDFFF
• Not-a-character, having the form 0x xxFFFF or 0x xxFFFE

isLegal

static fun isLegal(str: String!): Boolean

[icu] A string is legal iff all its code points are legal. A code point is illegal if and only if

• Out of bounds, less than 0 or greater than UCharacter.MAX_VALUE
• A surrogate value, 0xD800 to 0xDFFF
• Not-a-character, having the form 0x xxFFFF or 0x xxFFFE

isLetter

static fun isLetter(ch: Int): Boolean

Determines if the specified code point is a letter. Up-to-date Unicode implementation of java.lang.Character.isLetter()

isLetterOrDigit

static fun isLetterOrDigit(ch: Int): Boolean

Determines if the specified code point is a letter or digit. [icu] Note: This method, unlike java.lang.Character does not regard the ascii characters 'A' - 'Z' and 'a' - 'z' as digits.

isLowSurrogate

static fun isLowSurrogate(codePoint: Int): Boolean

Same as Character#isLowSurrogate, except that the ICU version accepts int for code points.

isLowSurrogate

static fun isLowSurrogate(ch: Char): Boolean

Same as Character#isLowSurrogate,

isLowerCase

static fun isLowerCase(ch: Int): Boolean

Determines if the specified code point is a lowercase character. UnicodeData only contains case mappings for code points where they are one-to-one mappings; it also omits information about context-sensitive case mappings.
For more information about Unicode case mapping please refer to the Technical report #21.
Up-to-date Unicode implementation of java.lang.Character.isLowerCase()

isMirrored

static fun isMirrored(ch: Int): Boolean

Determines whether the code point has the "mirrored" property. This property is set for characters that are commonly used in Right-To-Left contexts and need to be displayed with a "mirrored" glyph.

isPrintable

static fun isPrintable(ch: Int): Boolean

[icu] Determines whether the specified code point is a printable character according to the Unicode standard.

isSpaceChar

static fun isSpaceChar(ch: Int): Boolean

Determines if the specified code point is a Unicode specified space character, i.e. if code point is in the category Zs, Zl and Zp. Up-to-date Unicode implementation of java.lang.Character.isSpaceChar().

isSupplementary

static fun isSupplementary(ch: Int): Boolean

[icu] Determines if the code point is a supplementary character. A code point is a supplementary character if and only if it is greater than SUPPLEMENTARY_MIN_VALUE

isSupplementaryCodePoint

static fun isSupplementaryCodePoint(cp: Int): Boolean

Same as Character#isSupplementaryCodePoint.