Class Character

public static final byte COMBINING_SPACING_MARK

Mc = Mark, Spacing Combining (Normative).

Field Value:

8

Since:

1.1

public static final byte CONNECTOR_PUNCTUATION

Pc = Punctuation, Connector (Informative).

Field Value:

23

Since:

1.1

public static final byte CONTROL

Cc = Other, Control (Normative).

Field Value:

15

Since:

1.1

public static final byte CURRENCY_SYMBOL

Sc = Symbol, Currency (Informative).

Field Value:

26

Since:

1.1

public static final byte DASH_PUNCTUATION

Pd = Punctuation, Dash (Informative).

Field Value:

20

Since:

1.1

public static final byte DECIMAL_DIGIT_NUMBER

Nd = Number, Decimal Digit (Normative).

Field Value:

9

Since:

1.1

public static final byte DIRECTIONALITY_ARABIC_NUMBER

Weak bidirectional character type "AN".

Field Value:

6

Since:

1.4

public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL

Weak bidirectional character type "BN".

Field Value:

9

Since:

1.4

public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR

Weak bidirectional character type "CS".

Field Value:

7

Since:

1.4

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER

Weak bidirectional character type "EN".

Field Value:

3

Since:

1.4

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR

Weak bidirectional character type "ES".

Field Value:

4

Since:

1.4

public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR

Weak bidirectional character type "ET".

Field Value:

5

Since:

1.4

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT

Strong bidirectional character type "L".

Field Value:

0

Since:

1.4

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING

Strong bidirectional character type "LRE".

Field Value:

14

Since:

1.4

public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE

Strong bidirectional character type "LRO".

Field Value:

15

Since:

1.4

public static final byte DIRECTIONALITY_NONSPACING_MARK

Weak bidirectional character type "NSM".

Field Value:

8

Since:

1.4

public static final byte DIRECTIONALITY_OTHER_NEUTRALS

Neutral bidirectional character type "ON".

Field Value:

13

Since:

1.4

public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR

Neutral bidirectional character type "B".

Field Value:

10

Since:

1.4

public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

Weak bidirectional character type "PDF".

Field Value:

18

Since:

1.4

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT

Strong bidirectional character type "R".

Field Value:

1

Since:

1.4

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC

Strong bidirectional character type "AL".

Field Value:

2

Since:

1.4

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING

Strong bidirectional character type "RLE".

Field Value:

16

Since:

1.4

public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE

Strong bidirectional character type "RLO".

Field Value:

17

Since:

1.4

public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR

Neutral bidirectional character type "S".

Field Value:

11

Since:

1.4

public static final byte DIRECTIONALITY_UNDEFINED

Undefined bidirectional character type. Undefined char values have undefined directionality in the Unicode specification.

Field Value:

-1

Since:

1.4

public static final byte DIRECTIONALITY_WHITESPACE

Strong bidirectional character type "WS".

Field Value:

12

Since:

1.4

public static final byte ENCLOSING_MARK

Me = Mark, Enclosing (Normative).

Field Value:

7

Since:

1.1

public static final byte END_PUNCTUATION

Pe = Punctuation, Close (Informative).

Field Value:

22

Since:

1.1

public static final byte FINAL_QUOTE_PUNCTUATION

Pf = Punctuation, Final Quote (Informative).

Field Value:

30

Since:

1.4

public static final byte FORMAT

Cf = Other, Format (Normative).

Field Value:

16

Since:

1.1

public static final byte INITIAL_QUOTE_PUNCTUATION

Pi = Punctuation, Initial Quote (Informative).

Field Value:

29

Since:

1.4

public static final byte LETTER_NUMBER

Nl = Number, Letter (Normative).

Field Value:

10

Since:

1.1

public static final byte LINE_SEPARATOR

Zl = Separator, Line (Normative).

Field Value:

13

Since:

1.1

public static final byte LOWERCASE_LETTER

Ll = Letter, Lowercase (Informative).

Field Value:

2

Since:

1.1

public static final byte MATH_SYMBOL

Sm = Symbol, Math (Informative).

Field Value:

25

Since:

1.1

public static final int MAX_CODE_POINT

The maximum Unicode 4.0 code point, which is greater than the range of the char data type. This value is 0x10FFFF.

Field Value:

1114111

Since:

1.5

public static final char MAX_HIGH_SURROGATE

The maximum Unicode high surrogate code unit, or leading-surrogate, in the UTF-16 character encoding. This value is '\uDBFF'.

Field Value:

'\udbff'

Since:

1.5

public static final char MAX_LOW_SURROGATE

The maximum Unicode low surrogate code unit, or trailing-surrogate, in the UTF-16 character encoding. This value is '\uDFFF'.

Field Value:

'\udfff'

Since:

1.5

public static final int MAX_RADIX

Largest value allowed for radix arguments in Java. This value is 36.

Field Value:

36

See Also:

digit(char,int), forDigit(int,int), Integer.toString(int,int), Integer.valueOf(String)

public static final char MAX_SURROGATE

The maximum Unicode surrogate code unit in the UTF-16 character encoding. This value is '\uDFFF'.

Field Value:

'\udfff'

Since:

1.5

public static final char MAX_VALUE

The maximum value the char data type can hold. This value is '\\uFFFF'.

Field Value:

'\uffff'

public static final int MIN_CODE_POINT

The minimum Unicode 4.0 code point. This value is 0.

Field Value:

0

Since:

1.5

public static final char MIN_HIGH_SURROGATE

The minimum Unicode high surrogate code unit, or leading-surrogate, in the UTF-16 character encoding. This value is '\uD800'.

Field Value:

'\ud800'

Since:

1.5

public static final char MIN_LOW_SURROGATE

The minimum Unicode low surrogate code unit, or trailing-surrogate, in the UTF-16 character encoding. This value is '\uDC00'.

Field Value:

'\udc00'

Since:

1.5

public static final int MIN_RADIX

Smallest value allowed for radix arguments in Java. This value is 2.

Field Value:

2

See Also:

digit(char,int), forDigit(int,int), Integer.toString(int,int), Integer.valueOf(String)

public static final int MIN_SUPPLEMENTARY_CODE_POINT

The lowest possible supplementary Unicode code point (the first code point outside the basic multilingual plane (BMP)). This value is 0x10000.

Field Value:

65536

public static final char MIN_SURROGATE

The minimum Unicode surrogate code unit in the UTF-16 character encoding. This value is '\uD800'.

Field Value:

'\ud800'

Since:

1.5

public static final char MIN_VALUE

The minimum value the char data type can hold. This value is '\\u0000'.

Field Value:

'\u0000'

public static final byte MODIFIER_LETTER

Lm = Letter, Modifier (Informative).

Field Value:

4

Since:

1.1

public static final byte MODIFIER_SYMBOL

Sk = Symbol, Modifier (Informative).

Field Value:

27

Since:

1.1

public static final byte NON_SPACING_MARK

Mn = Mark, Non-Spacing (Normative).

Field Value:

6

Since:

1.1

public static final byte OTHER_LETTER

Lo = Letter, Other (Informative).

Field Value:

5

Since:

1.1

public static final byte OTHER_NUMBER

No = Number, Other (Normative).

Field Value:

11

Since:

1.1

public static final byte OTHER_PUNCTUATION

Po = Punctuation, Other (Informative).

Field Value:

24

Since:

1.1

public static final byte OTHER_SYMBOL

So = Symbol, Other (Informative).

Field Value:

28

Since:

1.1

public static final byte PARAGRAPH_SEPARATOR

Zp = Separator, Paragraph (Normative).

Field Value:

14

Since:

1.1

public static final byte PRIVATE_USE

Co = Other, Private Use (Normative).

Field Value:

18

Since:

1.1

public static final int SIZE

The number of bits needed to represent a char.

Field Value:

16

Since:

1.5

public static final byte SPACE_SEPARATOR

Zs = Separator, Space (Normative).

Field Value:

12

Since:

1.1

public static final byte START_PUNCTUATION

Ps = Punctuation, Open (Informative).

Field Value:

21

Since:

1.1

public static final byte SURROGATE

Cs = Other, Surrogate (Normative).

Field Value:

19

Since:

1.1

public static final byte TITLECASE_LETTER

Lt = Letter, Titlecase (Informative).

Field Value:

3

Since:

1.1

public static final Class TYPE

Class object representing the primitive char data type.

Since:

1.1

public static final byte UNASSIGNED

Cn = Other, Not Assigned (Normative).

Field Value:

0

Since:

1.1

public static final byte UPPERCASE_LETTER

Lu = Letter, Uppercase (Informative).

Field Value:

1

Since:

1.1

public Character(char value)

Wraps up a character.

Parameters:

value - the character to wrap

public static int charCount(int codePoint)

Return number of 16-bit characters required to represent the given code point.

Parameters:

codePoint - a unicode code point

Returns:

2 if codePoint >= 0x10000, 1 otherwise.

Since:

1.5

public char charValue()

Returns the character which has been wrapped by this class.

Returns:

the character wrapped

public static int codePointAt(char[] chars,
                              int index)

Get the code point at the specified index in the CharSequence. If the character is the start of a surrogate pair, and there is a following character, and this character completes the pair, then the corresponding supplementary code point is returned. Otherwise, the character at the index is returned.

Parameters:

chars - the character array in which to look

index - the index of the codepoint to get, starting at 0

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is negative or >= length()

Since:

1.5

public static int codePointAt(char[] chars,
                              int index,
                              int limit)

Get the code point at the specified index in the CharSequence. If the character is the start of a surrogate pair, and there is a following character within the specified range, and this character completes the pair, then the corresponding supplementary code point is returned. Otherwise, the character at the index is returned.

Parameters:

chars - the character array in which to look

index - the index of the codepoint to get, starting at 0

limit - the limit past which characters should not be examined

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is negative or >= limit, or if limit is negative or >= the length of the array

Since:

1.5

public static int codePointAt(CharSequence sequence,
                              int index)

Get the code point at the specified index in the CharSequence. This is like CharSequence#charAt(int), but if the character is the start of a surrogate pair, and there is a following character, and this character completes the pair, then the corresponding supplementary code point is returned. Otherwise, the character at the index is returned.

Parameters:

sequence - the CharSequence

index - the index of the codepoint to get, starting at 0

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is negative or >= length()

Since:

1.5

public static int codePointBefore(char[] chars,
                                  int index)

Get the code point before the specified index. This is like #codePointAt(char[], int), but checks the characters at index-1 and index-2 to see if they form a supplementary code point. If they do not, the character at index-1 is returned.

Parameters:

chars - the character array

index - the index just past the codepoint to get, starting at 0

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is negative or >= length()

Since:

1.5

public static int codePointBefore(char[] chars,
                                  int index,
                                  int start)

Get the code point before the specified index. This is like #codePointAt(char[], int), but checks the characters at index-1 and index-2 to see if they form a supplementary code point. If they do not, the character at index-1 is returned. The start parameter is used to limit the range of the array which may be examined.

Parameters:

chars - the character array

index - the index just past the codepoint to get, starting at 0

start - the index before which characters should not be examined

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is > start or > the length of the array, or if limit is negative or >= the length of the array

Since:

1.5

public static int codePointBefore(CharSequence sequence,
                                  int index)

Get the code point before the specified index. This is like #codePointAt(CharSequence, int), but checks the characters at index-1 and index-2 to see if they form a supplementary code point. If they do not, the character at index-1 is returned.

Parameters:

sequence - the CharSequence

index - the index just past the codepoint to get, starting at 0

Returns:

the codepoint at the specified index

Throws:

IndexOutOfBoundsException - if index is negative or >= length()

Since:

1.5

public static int codePointCount(char[] a,
                                 int offset,
                                 int count)

Returns the number of Unicode code points in the specified range of the given char array. The first char in the range is at position offset and the length of the range is count. Paired surrogates (supplementary characters are represented by a pair of chars - one from the high surrogates and one from the low surrogates) count as just one code point.

Parameters:

a - the char array to inspect

offset - the beginning of the range

count - the length of the range

Returns:

the number of Unicode code points in the given range of the array

Throws:

NullPointerException - if a is null

IndexOutOfBoundsException - if offset or count is negative or if offset + countendIndex is larger than the length of a.

Since:

1.5

public static int codePointCount(CharSequence seq,
                                 int beginIndex,
                                 int endIndex)

Returns the number of Unicode code points in the specified range of the given CharSequence. The first char in the range is at position beginIndex and the last one is at position endIndex - 1. Paired surrogates (supplementary characters are represented by a pair of chars - one from the high surrogates and one from the low surrogates) count as just one code point.

Parameters:

seq - the CharSequence to inspect

beginIndex - the beginning of the range

endIndex - the end of the range

Returns:

the number of Unicode code points in the given range of the sequence

Throws:

NullPointerException - if seq is null

IndexOutOfBoundsException - if beginIndex is negative, endIndex is larger than the length of seq, or if beginIndex is greater than endIndex.

Since:

1.5

public int compareTo(Character anotherCharacter)

Compares another Character to this Character, numerically.

Parameters:

anotherCharacter - Character to compare with this Character

Returns:

a negative integer if this Character is less than anotherCharacter, zero if this Character is equal, and a positive integer if this Character is greater

Throws:

NullPointerException - if anotherCharacter is null

Since:

1.2

public static int digit(char ch,
                        int radix)

Converts a character into a digit of the specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(ch) exceeds the radix, or if ch is not a decimal digit or in the case insensitive set of 'a'-'z', the result is -1.
character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A |U+FF21-U+FF3A|U+FF41-U+FF5A

Parameters:

ch - character to convert into a digit

radix - radix in which ch is a digit

Returns:

digit which ch represents in radix, or -1 not a valid digit

See Also:

MIN_RADIX, MAX_RADIX, forDigit(int,int), isDigit(char), getNumericValue(char)

public static int digit(int codePoint,
                        int radix)

Converts a character into a digit of the specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX, or if the result of getNumericValue(int) exceeds the radix, or if codePoint is not a decimal digit or in the case insensitive set of 'a'-'z', the result is -1. Unlike digit(char, int), this method supports supplementary Unicode code points.
character argument boundary = [Nd]|U+0041-U+005A|U+0061-U+007A |U+FF21-U+FF3A|U+FF41-U+FF5A

Parameters:

codePoint - character to convert into a digit

radix - radix in which codePoint is a digit

Returns:

digit which codePoint represents in radix, or -1 not a valid digit

Since:

1.5

See Also:

MIN_RADIX, MAX_RADIX, forDigit(int,int), isDigit(int), getNumericValue(int)

public boolean equals(Object o)

Determines if an object is equal to this object. This is only true for another Character object wrapping the same value.

Overrides:

equals in interface Object

Parameters:

o - object to compare

Returns:

true if o is a Character with the same value

public static char forDigit(int digit,
                            int radix)

Converts a digit into a character which represents that digit in a specified radix. If the radix exceeds MIN_RADIX or MAX_RADIX, or the digit exceeds the radix, then the null character '\0' is returned. Otherwise the return value is in '0'-'9' and 'a'-'z'.
return value boundary = U+0030-U+0039|U+0061-U+007A

Parameters:

digit - digit to be converted into a character

radix - radix of digit

Returns:

character representing digit in radix, or '\0'

See Also:

MIN_RADIX, MAX_RADIX, digit(char,int)

public static byte getDirectionality(char ch)

Returns the Unicode directionality property of the character. This is used in the visual ordering of text.

Parameters:

ch - the character to look up

Returns:

the directionality constant, or DIRECTIONALITY_UNDEFINED

Since:

1.4

See Also:

DIRECTIONALITY_UNDEFINED, DIRECTIONALITY_LEFT_TO_RIGHT, DIRECTIONALITY_RIGHT_TO_LEFT, DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, DIRECTIONALITY_EUROPEAN_NUMBER, DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, DIRECTIONALITY_ARABIC_NUMBER, DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, DIRECTIONALITY_NONSPACING_MARK, DIRECTIONALITY_BOUNDARY_NEUTRAL, DIRECTIONALITY_PARAGRAPH_SEPARATOR, DIRECTIONALITY_SEGMENT_SEPARATOR, DIRECTIONALITY_WHITESPACE, DIRECTIONALITY_OTHER_NEUTRALS, DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING, DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE, DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING, DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE, DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

public static byte getDirectionality(int codePoint)

Returns the Unicode directionality property of the character. This is used in the visual ordering of text. Unlike getDirectionality(char), this method supports supplementary Unicode code points.

Parameters:

codePoint - the character to look up

Returns:

the directionality constant, or DIRECTIONALITY_UNDEFINED

Since:

1.5

See Also:

DIRECTIONALITY_UNDEFINED, DIRECTIONALITY_LEFT_TO_RIGHT, DIRECTIONALITY_RIGHT_TO_LEFT, DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, DIRECTIONALITY_EUROPEAN_NUMBER, DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, DIRECTIONALITY_ARABIC_NUMBER, DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, DIRECTIONALITY_NONSPACING_MARK, DIRECTIONALITY_BOUNDARY_NEUTRAL, DIRECTIONALITY_PARAGRAPH_SEPARATOR, DIRECTIONALITY_SEGMENT_SEPARATOR, DIRECTIONALITY_WHITESPACE, DIRECTIONALITY_OTHER_NEUTRALS, DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING, DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE, DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING, DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE, DIRECTIONALITY_POP_DIRECTIONAL_FORMAT

public static int getNumericValue(char ch)

Returns the Unicode numeric value property of a character. For example, '\\u216C' (the Roman numeral fifty) returns 50.

This method also returns values for the letters A through Z, (not specified by Unicode), in these ranges: '\u0041' through '\u005A' (uppercase); '\u0061' through '\u007A' (lowercase); and '\uFF21' through '\uFF3A', '\uFF41' through '\uFF5A' (full width variants).

If the character lacks a numeric value property, -1 is returned. If the character has a numeric value property which is not representable as a nonnegative integer, such as a fraction, -2 is returned. character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A |U+FF21-U+FF3A|U+FF41-U+FF5A

Parameters:

ch - character from which the numeric value property will be retrieved

Returns:

the numeric value property of ch, or -1 if it does not exist, or -2 if it is not representable as a nonnegative integer

Since:

1.1

See Also:

forDigit(int,int), digit(char,int), isDigit(char)

public static int getNumericValue(int codePoint)

Returns the Unicode numeric value property of a character. For example, '\\u216C' (the Roman numeral fifty) returns 50.

This method also returns values for the letters A through Z, (not specified by Unicode), in these ranges: '\u0041' through '\u005A' (uppercase); '\u0061' through '\u007A' (lowercase); and '\uFF21' through '\uFF3A', '\uFF41' through '\uFF5A' (full width variants).

If the character lacks a numeric value property, -1 is returned. If the character has a numeric value property which is not representable as a nonnegative integer, such as a fraction, -2 is returned. Unlike getNumericValue(char), this method supports supplementary Unicode code points. character argument boundary = [Nd]|[Nl]|[No]|U+0041-U+005A|U+0061-U+007A |U+FF21-U+FF3A|U+FF41-U+FF5A

Parameters:

codePoint - character from which the numeric value property will be retrieved

Returns:

the numeric value property of codePoint, or -1 if it does not exist, or -2 if it is not representable as a nonnegative integer

Since:

1.5

See Also:

forDigit(int,int), digit(int,int), isDigit(int)

public static int getType(char ch)

Returns the Unicode general category property of a character.

Parameters:

ch - character from which the general category property will be retrieved

Returns:

the character category property of ch as an integer

Since:

1.1

See Also:

UNASSIGNED, UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER, OTHER_LETTER, NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK, DECIMAL_DIGIT_NUMBER, LETTER_NUMBER, OTHER_NUMBER, SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, PRIVATE_USE, SURROGATE, DASH_PUNCTUATION, START_PUNCTUATION, END_PUNCTUATION, CONNECTOR_PUNCTUATION, OTHER_PUNCTUATION, MATH_SYMBOL, CURRENCY_SYMBOL, MODIFIER_SYMBOL, INITIAL_QUOTE_PUNCTUATION, FINAL_QUOTE_PUNCTUATION

public static int getType(int codePoint)

Returns the Unicode general category property of a character. Supports supplementary Unicode code points.

Parameters:

codePoint - character from which the general category property will be retrieved

Returns:

the character category property of codePoint as an integer

Since:

1.5

See Also:

UNASSIGNED, UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER, OTHER_LETTER, NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK, DECIMAL_DIGIT_NUMBER, LETTER_NUMBER, OTHER_NUMBER, SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, PRIVATE_USE, SURROGATE, DASH_PUNCTUATION, START_PUNCTUATION, END_PUNCTUATION, CONNECTOR_PUNCTUATION, OTHER_PUNCTUATION, MATH_SYMBOL, CURRENCY_SYMBOL, MODIFIER_SYMBOL, INITIAL_QUOTE_PUNCTUATION, FINAL_QUOTE_PUNCTUATION

public int hashCode()

Returns the numerical value (unsigned) of the wrapped character. Range of returned values: 0x0000-0xFFFF.

Overrides:

hashCode in interface Object

Returns:

the value of the wrapped character

public static boolean isDefined(char ch)

Determines if a character is part of the Unicode Standard. This is an evolving standard, but covers every character in the data file.
defined = not [Cn]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode character, else false

See Also:

isDigit(char), isLetter(char), isLetterOrDigit(char), isLowerCase(char), isTitleCase(char), isUpperCase(char)

public static boolean isDefined(int codePoint)

Determines if a character is part of the Unicode Standard. This is an evolving standard, but covers every character in the data file. Unlike isDefined(char), this method supports supplementary Unicode code points.
defined = not [Cn]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode character, else false

Since:

1.5

See Also:

isDigit(int), isLetter(int), isLetterOrDigit(int), isLowerCase(int), isTitleCase(int), isUpperCase(int)

public static boolean isDigit(char ch)

Determines if a character is a Unicode decimal digit. For example, '0' is a digit.
Unicode decimal digit = [Nd]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode decimal digit, else false

See Also:

digit(char,int), forDigit(int,int), getType(char)

public static boolean isDigit(int codePoint)

Determines if a character is a Unicode decimal digit. For example, '0' is a digit. Unlike isDigit(char), this method supports supplementary Unicode code points.
Unicode decimal digit = [Nd]

Parameters:

codePoint - character to test

Returns:

true if ccodePoint is a Unicode decimal digit, else false

Since:

1.5

See Also:

digit(int,int), forDigit(int,int), getType(int)

public static boolean isHighSurrogate(char ch)

Return true if the given character is a high surrogate.

Parameters:

ch - the character

Returns:

true if the character is a high surrogate character

Since:

1.5

public static boolean isISOControl(char ch)

Determines if a character has the ISO Control property.
ISO Control = [Cc]

Parameters:

ch - character to test

Returns:

true if ch is an ISO Control character, else false

Since:

1.1

See Also:

isSpaceChar(char), isWhitespace(char)

public static boolean isISOControl(int codePoint)

Determines if a character has the ISO Control property. Unlike isISOControl(char), this method supports supplementary unicode code points.
ISO Control = [Cc]

Parameters:

codePoint - character to test

Returns:

true if codePoint is an ISO Control character, else false

Since:

1.5

See Also:

isSpaceChar(int), isWhitespace(int)

public static boolean isIdentifierIgnorable(char ch)

Determines if a character is ignorable in a Unicode identifier. This includes the non-whitespace ISO control characters ('\u0000' through '\u0008', '\u000E' through '\u001B', and '\u007F' through '\u009F'), and FORMAT characters.
Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B |U+007F-U+009F

Parameters:

ch - character to test

Returns:

true if ch is ignorable in a Unicode or Java identifier

Since:

1.1

See Also:

isJavaIdentifierPart(char), isUnicodeIdentifierPart(char)

public static boolean isIdentifierIgnorable(int codePoint)

Determines if a character is ignorable in a Unicode identifier. This includes the non-whitespace ISO control characters ('\u0000' through '\u0008', '\u000E' through '\u001B', and '\u007F' through '\u009F'), and FORMAT characters. Unlike isIdentifierIgnorable(char), this method supports supplementary Unicode code points.
Unicode identifier ignorable = [Cf]|U+0000-U+0008|U+000E-U+001B |U+007F-U+009F

Parameters:

codePoint - character to test

Returns:

true if codePoint is ignorable in a Unicode or Java identifier

Since:

1.5

See Also:

isJavaIdentifierPart(int), isUnicodeIdentifierPart(int)

public static boolean isJavaIdentifierPart(char ch)

Determines if a character can follow the first letter in a Java identifier. This is the combination of isJavaLetter (isLetter, type of LETTER_NUMBER, currency, connecting punctuation) and digit, numeric letter (like Roman numerals), combining marks, non-spacing marks, or isIdentifierIgnorable.
Java identifier extender = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf] |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F

Parameters:

ch - character to test

Returns:

true if ch can follow the first letter in a Java identifier

Since:

1.1

See Also:

isIdentifierIgnorable(char), isJavaIdentifierStart(char), isLetterOrDigit(char), isUnicodeIdentifierPart(char)

public static boolean isJavaIdentifierPart(int codePoint)

Determines if a character can follow the first letter in a Java identifier. This is the combination of isJavaLetter (isLetter, type of LETTER_NUMBER, currency, connecting punctuation) and digit, numeric letter (like Roman numerals), combining marks, non-spacing marks, or isIdentifierIgnorable. Unlike isJavaIdentifierPart(char), this method supports supplementary Unicode code points.
Java identifier extender = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]|[Mn]|[Mc]|[Nd]|[Cf] |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F

Parameters:

codePoint - character to test

Returns:

true if codePoint can follow the first letter in a Java identifier

Since:

1.5

See Also:

isIdentifierIgnorable(int), isJavaIdentifierStart(int), isLetterOrDigit(int), isUnicodeIdentifierPart(int)

public static boolean isJavaIdentifierStart(char ch)

Determines if a character can start a Java identifier. This is the combination of isLetter, any character where getType returns LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation (like '_').
Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]

Parameters:

ch - character to test

Returns:

true if ch can start a Java identifier, else false

Since:

1.1

See Also:

isJavaIdentifierPart(char), isLetter(char), isUnicodeIdentifierStart(char)

public static boolean isJavaIdentifierStart(int codePoint)

Determines if a character can start a Java identifier. This is the combination of isLetter, any character where getType returns LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation (like '_'). Unlike isJavaIdentifierStart(char), this method supports supplementary Unicode code points.
Java identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Sc]|[Pc]

Parameters:

codePoint - character to test

Returns:

true if codePoint can start a Java identifier, else false

Since:

1.5

See Also:

isJavaIdentifierPart(int), isLetter(int), isUnicodeIdentifierStart(int)

public static boolean isJavaLetter(char ch)

Deprecated. Replaced by isJavaIdentifierStart(char)

Determines if a character can start a Java identifier. This is the combination of isLetter, any character where getType returns LETTER_NUMBER, currency symbols (like '$'), and connecting punctuation (like '_').

Parameters:

ch - character to test

Returns:

true if ch can start a Java identifier, else false

See Also:

isJavaLetterOrDigit(char), isJavaIdentifierStart(char), isJavaIdentifierPart(char), isLetter(char), isLetterOrDigit(char), isUnicodeIdentifierStart(char)

public static boolean isJavaLetterOrDigit(char ch)

Deprecated. Replaced by isJavaIdentifierPart(char)

Determines if a character can follow the first letter in a Java identifier. This is the combination of isJavaLetter (isLetter, type of LETTER_NUMBER, currency, connecting punctuation) and digit, numeric letter (like Roman numerals), combining marks, non-spacing marks, or isIdentifierIgnorable.

Parameters:

ch - character to test

Returns:

true if ch can follow the first letter in a Java identifier

See Also:

isJavaLetter(char), isJavaIdentifierStart(char), isJavaIdentifierPart(char), isLetter(char), isLetterOrDigit(char), isUnicodeIdentifierPart(char), isIdentifierIgnorable(char)

public static boolean isLetter(char ch)

Determines if a character is a Unicode letter. Not all letters have case, so this may return true when isLowerCase and isUpperCase return false.
letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode letter, else false

See Also:

isDigit(char), isJavaIdentifierStart(char), isJavaLetter(char), isJavaLetterOrDigit(char), isLetterOrDigit(char), isLowerCase(char), isTitleCase(char), isUnicodeIdentifierStart(char), isUpperCase(char)

public static boolean isLetter(int codePoint)

Determines if a character is a Unicode letter. Not all letters have case, so this may return true when isLowerCase and isUpperCase return false. Unlike isLetter(char), this method supports supplementary Unicode code points.
letter = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode letter, else false

Since:

1.5

See Also:

isDigit(int), isJavaIdentifierStart(int), isJavaLetter(int), isJavaLetterOrDigit(int), isLetterOrDigit(int), isLowerCase(int), isTitleCase(int), isUnicodeIdentifierStart(int), isUpperCase(int)

public static boolean isLetterOrDigit(char ch)

Determines if a character is a Unicode letter or a Unicode digit. This is the combination of isLetter and isDigit.
letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode letter or a Unicode digit, else false

See Also:

isDigit(char), isJavaIdentifierPart(char), isJavaLetter(char), isJavaLetterOrDigit(char), isLetter(char), isUnicodeIdentifierPart(char)

public static boolean isLetterOrDigit(int codePoint)

Determines if a character is a Unicode letter or a Unicode digit. This is the combination of isLetter and isDigit. Unlike isLetterOrDigit(char), this method supports supplementary Unicode code points.
letter or digit = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nd]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode letter or a Unicode digit, else false

Since:

1.5

See Also:

isDigit(int), isJavaIdentifierPart(int), isJavaLetter(int), isJavaLetterOrDigit(int), isLetter(int), isUnicodeIdentifierPart(int)

public static boolean isLowSurrogate(char ch)

Return true if the given character is a low surrogate.

Parameters:

ch - the character

Returns:

true if the character is a low surrogate character

Since:

1.5

public static boolean isLowerCase(char ch)

Determines if a character is a Unicode lowercase letter. For example, 'a' is lowercase.
lowercase = [Ll]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode lowercase letter, else false

See Also:

isUpperCase(char), isTitleCase(char), toLowerCase(char), getType(char)

public static boolean isLowerCase(int codePoint)

Determines if a character is a Unicode lowercase letter. For example, 'a' is lowercase. Unlike isLowerCase(char), this method supports supplementary Unicode code points.
lowercase = [Ll]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode lowercase letter, else false

Since:

1.5

See Also:

isUpperCase(int), isTitleCase(int), toLowerCase(int), getType(int)

public static boolean isMirrored(char ch)

Determines whether the character is mirrored according to Unicode. For example, \u0028 (LEFT PARENTHESIS) appears as '(' in left-to-right text, but ')' in right-to-left text.

Parameters:

ch - the character to look up

Returns:

true if the character is mirrored

Since:

1.4

public static boolean isMirrored(int codePoint)

Determines whether the character is mirrored according to Unicode. For example, \u0028 (LEFT PARENTHESIS) appears as '(' in left-to-right text, but ')' in right-to-left text. Unlike isMirrored(char), this method supports supplementary Unicode code points.

Parameters:

codePoint - the character to look up

Returns:

true if the character is mirrored

Since:

1.5

public static boolean isSpace(char ch)

Deprecated. Replaced by isWhitespace(char)

Determines if a character is a ISO-LATIN-1 space. This is only the five characters '\t', '\n', '\f', '\r', and ' '.
Java space = U+0020|U+0009|U+000A|U+000C|U+000D

Parameters:

ch - character to test

Returns:

true if ch is a space, else false

See Also:

isSpaceChar(char), isWhitespace(char)

public static boolean isSpaceChar(char ch)

Determines if a character is a Unicode space character. This includes SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR.
Unicode space = [Zs]|[Zp]|[Zl]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode space, else false

Since:

1.1

See Also:

isWhitespace(char)

public static boolean isSpaceChar(int codePoint)

Determines if a character is a Unicode space character. This includes SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR. Unlike isSpaceChar(char), this method supports supplementary Unicode code points.
Unicode space = [Zs]|[Zp]|[Zl]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode space, else false

Since:

1.5

See Also:

isWhitespace(int)

public static boolean isSupplementaryCodePoint(int codePoint)

Determines whether the specified code point is in the range 0x10000 .. 0x10FFFF, i.e. the character is within the Unicode supplementary character range.

Parameters:

codePoint - a Unicode code point

Returns:

true if code point is in supplementary range

Since:

1.5

public static boolean isSurrogatePair(char ch1,
                                      char ch2)

Return true if the given characters compose a surrogate pair. This is true if the first character is a high surrogate and the second character is a low surrogate.

Parameters:

ch1 - the first character

ch2 - the first character

Returns:

true if the characters compose a surrogate pair

Since:

1.5

public static boolean isTitleCase(char ch)

Determines if a character is a Unicode titlecase letter. For example, the character "Lj" (Latin capital L with small letter j) is titlecase.
titlecase = [Lt]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode titlecase letter, else false

See Also:

isLowerCase(char), isUpperCase(char), toTitleCase(char), getType(char)

public static boolean isTitleCase(int codePoint)

Determines if a character is a Unicode titlecase letter. For example, the character "Lj" (Latin capital L with small letter j) is titlecase. Unlike isTitleCase(char), this method supports supplementary Unicode code points.
titlecase = [Lt]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode titlecase letter, else false

Since:

1.5

See Also:

isLowerCase(int), isUpperCase(int), toTitleCase(int), getType(int)

public static boolean isUnicodeIdentifierPart(char ch)

Determines if a character can follow the first letter in a Unicode identifier. This includes letters, connecting punctuation, digits, numeric letters, combining marks, non-spacing marks, and isIdentifierIgnorable.
Unicode identifier extender = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]| |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F

Parameters:

ch - character to test

Returns:

true if ch can follow the first letter in a Unicode identifier

Since:

1.1

See Also:

isIdentifierIgnorable(char), isJavaIdentifierPart(char), isLetterOrDigit(char), isUnicodeIdentifierStart(char)

public static boolean isUnicodeIdentifierPart(int codePoint)

Determines if a character can follow the first letter in a Unicode identifier. This includes letters, connecting punctuation, digits, numeric letters, combining marks, non-spacing marks, and isIdentifierIgnorable. Unlike isUnicodeIdentifierPart(char), this method supports supplementary Unicode code points.
Unicode identifier extender = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]|[Mn]|[Mc]|[Nd]|[Pc]|[Cf]| |U+0000-U+0008|U+000E-U+001B|U+007F-U+009F

Parameters:

codePoint - character to test

Returns:

true if codePoint can follow the first letter in a Unicode identifier

Since:

1.5

See Also:

isIdentifierIgnorable(int), isJavaIdentifierPart(int), isLetterOrDigit(int), isUnicodeIdentifierStart(int)

public static boolean isUnicodeIdentifierStart(char ch)

Determines if a character can start a Unicode identifier. Only letters can start a Unicode identifier, but this includes characters in LETTER_NUMBER.
Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]

Parameters:

ch - character to test

Returns:

true if ch can start a Unicode identifier, else false

Since:

1.1

See Also:

isJavaIdentifierStart(char), isLetter(char), isUnicodeIdentifierPart(char)

public static boolean isUnicodeIdentifierStart(int codePoint)

Determines if a character can start a Unicode identifier. Only letters can start a Unicode identifier, but this includes characters in LETTER_NUMBER. Unlike isUnicodeIdentifierStart(char), this method supports supplementary Unicode code points.
Unicode identifier start = [Lu]|[Ll]|[Lt]|[Lm]|[Lo]|[Nl]

Parameters:

codePoint - character to test

Returns:

true if codePoint can start a Unicode identifier, else false

Since:

1.5

See Also:

isJavaIdentifierStart(int), isLetter(int), isUnicodeIdentifierPart(int)

public static boolean isUpperCase(char ch)

Determines if a character is a Unicode uppercase letter. For example, 'A' is uppercase.
uppercase = [Lu]

Parameters:

ch - character to test

Returns:

true if ch is a Unicode uppercase letter, else false

See Also:

isLowerCase(char), isTitleCase(char), toUpperCase(char), getType(char)

public static boolean isUpperCase(int codePoint)

Determines if a character is a Unicode uppercase letter. For example, 'A' is uppercase. Unlike isUpperCase(char), this method supports supplementary Unicode code points.
uppercase = [Lu]

Parameters:

codePoint - character to test

Returns:

true if codePoint is a Unicode uppercase letter, else false

Since:

1.5

See Also:

isLowerCase(int), isTitleCase(int), toUpperCase(int), getType(int)

public static boolean isValidCodePoint(int codePoint)

Determines whether the specified code point is in the range 0x0000 .. 0x10FFFF, i.e. it is a valid Unicode code point.

Parameters:

codePoint - a Unicode code point

Returns:

true if code point is valid

Since:

1.5

public static boolean isWhitespace(char ch)

Determines if a character is Java whitespace. This includes Unicode space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR) except the non-breaking spaces ('\u00A0', '\u2007', and '\u202F'); and these characters: '\u0009', '\u000A', '\u000B', '\u000C', '\u000D', '\u001C', '\u001D', '\u001E', and '\u001F'.
Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F

Parameters:

ch - character to test

Returns:

true if ch is Java whitespace, else false

Since:

1.1

See Also:

isSpaceChar(char)

public static boolean isWhitespace(int codePoint)

Determines if a character is Java whitespace. This includes Unicode space characters (SPACE_SEPARATOR, LINE_SEPARATOR, and PARAGRAPH_SEPARATOR) except the non-breaking spaces ('\u00A0', '\u2007', and '\u202F'); and these characters: '\u0009', '\u000A', '\u000B', '\u000C', '\u000D', '\u001C', '\u001D', '\u001E', and '\u001F'. Unlike isWhitespace(char), this method supports supplementary Unicode code points.
Java whitespace = ([Zs] not Nb)|[Zl]|[Zp]|U+0009-U+000D|U+001C-U+001F

Parameters:

codePoint - character to test

Returns:

true if codePoint is Java whitespace, else false

Since:

1.5

See Also:

isSpaceChar(int)

public static int offsetByCodePoints(char[] a,
                                     int start,
                                     int count,
                                     int index,
                                     int codePointOffset)

Returns the index into the given char subarray that is offset codePointOffset code points from index.

Parameters:

a - the char array

start - the start index of the subarray

count - the length of the subarray

index - the index to be offset

codePointOffset - the number of code points offset from index

Returns:

the index into the char array

Throws:

NullPointerException - if a is null

IndexOutOfBoundsException - if start or count is negative or if start + count is greater than the length of the array

IndexOutOfBoundsException - if index is less than start or larger than start + count

IndexOutOfBoundsException - if codePointOffset is positive and the subarray from index to start + count - 1 has fewer than codePointOffset code points.

IndexOutOfBoundsException - if codePointOffset is negative and the subarray from start to index - 1 has fewer than (-codePointOffset) code points

Since:

1.5

public static int offsetByCodePoints(CharSequence seq,
                                     int index,
                                     int codePointOffset)

Returns the index into the given CharSequence that is offset codePointOffset code points from index.

Parameters:

seq - the CharSequence

index - the start position in the CharSequence

codePointOffset - the number of code points offset from the start position

Returns:

the index into the CharSequence that is codePointOffset code points offset from index

Throws:

NullPointerException - if seq is null

IndexOutOfBoundsException - if index is negative or greater than the length of the sequence.

IndexOutOfBoundsException - if codePointOffset is positive and the subsequence from index to the end of seq has fewer than codePointOffset code points

IndexOutOfBoundsException - if codePointOffset is negative and the subsequence from the start of seq to index has fewer than (-codePointOffset) code points

Since:

1.5

public static char reverseBytes(char val)

Reverse the bytes in val.

Since:

1.5

public static char[] toChars(int codePoint)

Converts a unicode code point to a UTF-16 representation of that code point.

Parameters:

codePoint - the unicode code point

Returns:

the UTF-16 representation of that code point

Throws:

IllegalArgumentException - if the code point is not a valid unicode code point

Since:

1.5

public static int toChars(int codePoint,
                          char[] dst,
                          int dstIndex)

Converts a unicode code point to its UTF-16 representation.

Parameters:

codePoint - the unicode code point

dst - the target char array

dstIndex - the start index for the target

Returns:

number of characters written to dst

Throws:

IllegalArgumentException - if codePoint is not a valid unicode code point

NullPointerException - if dst is null

IndexOutOfBoundsException - if dstIndex is not valid in dst or if the UTF-16 representation does not fit into dst

Since:

1.5

public static int toCodePoint(char high,
                              char low)

Given a valid surrogate pair, this returns the corresponding code point.

Parameters:

high - the high character of the pair

low - the low character of the pair

Returns:

the corresponding code point

Since:

1.5

public static char toLowerCase(char ch)

Converts a Unicode character into its lowercase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isLowerCase(toLowerCase(ch)) does not always return true.

Parameters:

ch - character to convert to lowercase

Returns:

lowercase mapping of ch, or ch if lowercase mapping does not exist

See Also:

isLowerCase(char), isUpperCase(char), toTitleCase(char), toUpperCase(char)

public static int toLowerCase(int codePoint)

Converts a Unicode character into its lowercase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isLowerCase(toLowerCase(codePoint)) does not always return true. Unlike toLowerCase(char), this method supports supplementary Unicode code points.

Parameters:

codePoint - character to convert to lowercase

Returns:

lowercase mapping of codePoint, or codePoint if lowercase mapping does not exist

Since:

1.5

See Also:

isLowerCase(int), isUpperCase(int), toTitleCase(int), toUpperCase(int)

public String toString()

Converts the wrapped character into a String.

Overrides:

toString in interface Object

Returns:

a String containing one character -- the wrapped character of this instance

public static String toString(char ch)

Returns a String of length 1 representing the specified character.

Parameters:

ch - the character to convert

Returns:

a String containing the character

Since:

1.4

public static char toTitleCase(char ch)

Converts a Unicode character into its titlecase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isTitleCase(toTitleCase(ch)) does not always return true.

Parameters:

ch - character to convert to titlecase

Returns:

titlecase mapping of ch, or ch if titlecase mapping does not exist

See Also:

isTitleCase(char), toLowerCase(char), toUpperCase(char)

public static int toTitleCase(int codePoint)

Converts a Unicode character into its titlecase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isTitleCase(toTitleCase(codePoint)) does not always return true. Unlike toTitleCase(char), this method supports supplementary Unicode code points.

Parameters:

codePoint - character to convert to titlecase

Returns:

titlecase mapping of codePoint, or codePoint if titlecase mapping does not exist

Since:

1.5

See Also:

isTitleCase(int), toLowerCase(int), toUpperCase(int)

public static char toUpperCase(char ch)

Converts a Unicode character into its uppercase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isUpperCase(toUpperCase(ch)) does not always return true.

Parameters:

ch - character to convert to uppercase

Returns:

uppercase mapping of ch, or ch if uppercase mapping does not exist

See Also:

isLowerCase(char), isUpperCase(char), toLowerCase(char), toTitleCase(char)

public static int toUpperCase(int codePoint)

Converts a Unicode character into its uppercase equivalent mapping. If a mapping does not exist, then the character passed is returned. Note that isUpperCase(toUpperCase(codePoint)) does not always return true. Unlike toUpperCase(char), this method supports supplementary Unicode code points.

Parameters:

codePoint - character to convert to uppercase

Returns:

uppercase mapping of codePoint, or codePoint if uppercase mapping does not exist

Since:

1.5

See Also:

isLowerCase(int), isUpperCase(int), toLowerCase(int), toTitleCase(int)

public static Character valueOf(char val)

Returns an Character object wrapping the value. In contrast to the Character constructor, this method will cache some values. It is used by boxing conversion.

Parameters:

val - the value to wrap

Returns:

the Character

Since:

1.5