All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class java.lang.Character

java.lang.Object
   |
   +----java.lang.Character

public final class Character
extends Object
implements Serializable

The Character class provides an object wrapper for Character data values and serves as a place for character-oriented operations. A wrapper is useful because most of Java's utility classes require the use of objects. Since characters are not objects in Java, they need to be "wrapped" in a Character instance.

COMBINING_SPACING_MARK
CONNECTOR_PUNCTUATION
CONTROL
CURRENCY_SYMBOL
DASH_PUNCTUATION
DECIMAL_DIGIT_NUMBER
ENCLOSING_MARK
END_PUNCTUATION
FORMAT
LETTER_NUMBER
LINE_SEPARATOR
LOWERCASE_LETTER
MATH_SYMBOL
MAX_RADIX: The maximum radix available for conversion to and from Strings.
MAX_VALUE: The maximum value a Character can have.
MIN_RADIX: The minimum radix available for conversion to and from Strings.
MIN_VALUE: The minimum value a Character can have.
MODIFIER_LETTER
MODIFIER_SYMBOL
NON_SPACING_MARK
OTHER_LETTER
OTHER_NUMBER
OTHER_PUNCTUATION
OTHER_SYMBOL
PARAGRAPH_SEPARATOR
PRIVATE_USE
SPACE_SEPARATOR
START_PUNCTUATION
SURROGATE
TITLECASE_LETTER
TYPE: The Class object representing the primitive type char.
UNASSIGNED
UPPERCASE_LETTER

Character(char): Constructs a Character object with the specified value.

charValue(): Returns the value of this Character object.
digit(char, int): Returns the numeric value of the character digit using the specified radix.
equals(Object): Compares this object against the specified object.
forDigit(int, int): Returns the character value for the specified digit in the specified radix.
getNumericValue(char): Returns the Unicode numeric value of the character as a nonnegative integer.
getType(char): Returns a value indicating a character category.
hashCode(): Returns a hashcode for this Character.
isDefined(char): Determines whether the specified character actually has a Unicode definition.
isDigit(char): Determines whether the specified character is a digit.
isIdentifierIgnorable(char): Determines whether the specified character should be regarded as an ignorable character in a Java identifier or a Unicode identifier.
isISOControl(char): Determines if the specified character is an ISO control character.
isJavaIdentifierPart(char): Determines whether the specified character may be part of a Java identifier as other than the first character.
isJavaIdentifierStart(char): Determines whether the specified character is permissible as the first character in a Java identifier.
isJavaLetter(char): Determines whether the specified character is a "Java" letter, that is, permissible as the first character in a Java identifier. Deprecated.
isJavaLetterOrDigit(char): Determines whether the specified character is a "Java" letter or digit, that is, permissible as a non-initial character in a Java identifier. Deprecated.
isLetter(char): Determines whether the specified character is a letter.
isLetterOrDigit(char): Determines whether the specified character is a letter or digit.
isLowerCase(char): Determines whether the specified character is a lowercase character.
isSpace(char): Determines if the specified character is ISO-LATIN-1 white space according to Java. Deprecated.
isSpaceChar(char): Determines if the specified character is a Unicode space character.
isTitleCase(char): Determines whether the specified character is a titlecase character.
isUnicodeIdentifierPart(char): Determines whether the specified character may be part of a Unicode identifier as other than the first character.
isUnicodeIdentifierStart(char): Determines whether the specified character is permissible as the first character in a Unicode identifier.
isUpperCase(char): Determines whether the specified character is an uppercase character.
isWhitespace(char): Determines if the specified character is white space according to Java.
toLowerCase(char): The given character is mapped to its lowercase equivalent; if the character has no lowercase equivalent, the character itself is returned.
toString(): Returns a String object representing this character's value.
toTitleCase(char): The given character is mapped to its titlecase equivalent; if the character has no titlecase equivalent, the character itself is returned.
toUpperCase(char): The given character is mapped to its uppercase equivalent; if the character has no uppercase equivalent, the character itself is returned.

MIN_RADIX

  public final static int MIN_RADIX

The minimum radix available for conversion to and from Strings. The minimum value that a radix can be is 2.

See Also:: toString

MAX_RADIX

  public final static int MAX_RADIX

The maximum radix available for conversion to and from Strings. The maximum value that a radix can be is 36.

See Also:: toString

MIN_VALUE

  public final static char MIN_VALUE

The minimum value a Character can have. The lowest minimum value a Character can have is \u0000.

MAX_VALUE

  public final static char MAX_VALUE

The maximum value a Character can have. The greatest maximum value a Character can have is \uffff.

TYPE

  public final static Class TYPE

The Class object representing the primitive type char.

UNASSIGNED

  public final static byte UNASSIGNED

UPPERCASE_LETTER

  public final static byte UPPERCASE_LETTER

LOWERCASE_LETTER

  public final static byte LOWERCASE_LETTER

TITLECASE_LETTER

  public final static byte TITLECASE_LETTER

MODIFIER_LETTER

  public final static byte MODIFIER_LETTER

OTHER_LETTER

  public final static byte OTHER_LETTER

NON_SPACING_MARK

  public final static byte NON_SPACING_MARK

ENCLOSING_MARK

  public final static byte ENCLOSING_MARK

COMBINING_SPACING_MARK

  public final static byte COMBINING_SPACING_MARK

DECIMAL_DIGIT_NUMBER

  public final static byte DECIMAL_DIGIT_NUMBER

LETTER_NUMBER

  public final static byte LETTER_NUMBER

OTHER_NUMBER

  public final static byte OTHER_NUMBER

SPACE_SEPARATOR

  public final static byte SPACE_SEPARATOR

LINE_SEPARATOR

  public final static byte LINE_SEPARATOR

PARAGRAPH_SEPARATOR

  public final static byte PARAGRAPH_SEPARATOR

CONTROL

  public final static byte CONTROL

FORMAT

  public final static byte FORMAT

PRIVATE_USE

  public final static byte PRIVATE_USE

SURROGATE

  public final static byte SURROGATE

DASH_PUNCTUATION

  public final static byte DASH_PUNCTUATION

START_PUNCTUATION

  public final static byte START_PUNCTUATION

END_PUNCTUATION

  public final static byte END_PUNCTUATION

CONNECTOR_PUNCTUATION

  public final static byte CONNECTOR_PUNCTUATION

OTHER_PUNCTUATION

  public final static byte OTHER_PUNCTUATION

MATH_SYMBOL

  public final static byte MATH_SYMBOL

CURRENCY_SYMBOL

  public final static byte CURRENCY_SYMBOL

MODIFIER_SYMBOL

  public final static byte MODIFIER_SYMBOL

OTHER_SYMBOL

  public final static byte OTHER_SYMBOL

Character

  public Character(char value)

Constructs a Character object with the specified value.

Parameters:: value - value of this Character object

charValue

  public char charValue()

Returns the value of this Character object.

hashCode

  public int hashCode()

Returns a hashcode for this Character.

Overrides:: hashCode in class Object

equals

  public boolean equals(Object obj)

Compares this object against the specified object.

Parameters:: obj - the object to compare with
Returns:: true if the objects are the same; false otherwise.
Overrides:: equals in class Object

toString

  public String toString()

Returns a String object representing this character's value.

Overrides:: toString in class Object

isLowerCase

  public static boolean isLowerCase(char ch)

Determines whether the specified character is a lowercase character.

A character is considered to be lowercase if and only if it is specified to be lowercase by the Unicode 2.0 standard (category "Ll" in the Unicode specification data file).

Of the ISO-LATIN-1 characters (character codes 0x0000 through 0x00FF), the following are lowercase: a b c d e f g h i j k l m n o p q r s t u v w x y z � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �

Many other Unicode characters are lowercase, too.

Parameters:: ch - the character to be tested
Returns:: true if the character is lowercase; false otherwise.
See Also:: isUpperCase, isTitleCase, toLowerCase

isUpperCase

  public static boolean isUpperCase(char ch)

Determines whether the specified character is an uppercase character.

A character is considered to be uppercase if and only if it is specified to be uppercase by the Unicode 2.0 standard (category "Lu" in the Unicode specification data file).

Of the ISO-LATIN-1 characters (character codes 0x0000 through 0x00FF), the following are uppercase: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �

Many other Unicode characters are uppercase, too.

Parameters:: ch - the character to be tested
Returns:: true if the character is uppercase; false otherwise.
See Also:: isLowerCase, isTitleCase, toUpperCase

isTitleCase

  public static boolean isTitleCase(char ch)

Determines whether the specified character is a titlecase character.

A character is considered to be titlecase if and only if it is specified to be titlecase by the Unicode 2.0 standard (category "Lt" in the Unicode specification data file). The basic idea is that there are a few Unicode characters whose printed representations look like pairs of Latin letters. For example, there is an uppercase letter that looks like "LJ" and the corresponding lowercase letter looks like "lj". These letters have a third form, a titlecase form, that looks like "Lj". This is the appropriate form to use when rendering a word in lowercase with initial capitals, as for a book title.

There are exactly four Unicode characters for which this method returns true:

?: LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
?: LATIN CAPITAL LETTER L WITH SMALL LETTER J
?: LATIN CAPITAL LETTER N WITH SMALL LETTER J
?: LATIN CAPITAL LETTER D WITH SMALL LETTER Z

Parameters:: ch - the character to be tested
Returns:: true if the character is titlecase; false otherwise.
See Also:: isUpperCase, isLowerCase, toTitleCase

isDigit

  public static boolean isDigit(char ch)

Determines whether the specified character is a digit.

A character is considered to be a digit if and only if it is specified to be a decimal digit by the Unicode 2.0 standard (category "Nd" in the Unicode specification data file).

These are the ranges of Unicode characters that are considered digits:

0x0030 through 0x0039: ISO-LATIN-1 digits ('0' through '9')
0x0660 through 0x0669: Arabic-Indic digits
0x06F0 through 0x06F9: Extended Arabic-Indic digits
0x0966 through 0x096F: Devanagari digits
0x09E6 through 0x09EF: Bengali digits
0x0A66 through 0x0A6F: Gurmukhi digits
0x0AE6 through 0x0AEF: Gujarati digits
0x0B66 through 0x0B6F: Oriya digits
0x0BE7 through 0x0BEF: Tamil digits
0x0C66 through 0x0C6F: Telugu digits
0x0CE6 through 0x0CEF: Kannada digits
0x0D66 through 0x0D6F: Malayalam digits
0x0E50 through 0x0E59: Thai digits
0x0ED0 through 0x0ED9: Lao digits
0x0F20 through 0x0F29: Tibetan digits
0xFF10 through 0xFF19: Fullwidth digits

Parameters:: ch - the character to be tested
Returns:: true if the character is a digit; false otherwise.
See Also:: digit, forDigit

isDefined

  public static boolean isDefined(char ch)

Determines whether the specified character actually has a Unicode definition.

Parameters:: ch - the character to be tested
Returns:: true if the character has a defined Unicode meaning; false otherwise.
See Also:: isDigit, isLetter, isLetterOrDigit, isUpperCase, isLowerCase, isTitleCase

isLetter

  public static boolean isLetter(char ch)

Determines whether the specified character is a letter.

A character is considered to be a letter if and only if it is specified to be a letter by the Unicode 2.0 standard (category "Lu", "Ll", "Lt", "Lm", or "Lo" in the Unicode specification data file).

Note that most ideographic characters are considered to be letters (category "Lo") for this purpose.

Note also that not all letters have case: many Unicode characters are letters but are neither uppercase nor lowercase nor titlecase.

Parameters:: ch - the character to be tested
Returns:: true if the character is a letter; false otherwise.
See Also:: isDigit, isLetterOrDigit, isUpperCase, isLowerCase, isTitleCase, isJavaIdentifierStart, isUnicodeIdentifierStart

isLetterOrDigit

  public static boolean isLetterOrDigit(char ch)

Determines whether the specified character is a letter or digit.

A character is considered to be a letter if and only if it is specified to be a letter or a digit by the Unicode 2.0 standard (category "Lu", "Ll", "Lt", "Lm", "Lo", or "Nd" in the Unicode specification data file). In other words, isLetterOrDigit is true of a character if and only if either isLetter is true of the character or isDigit is true of the character.

Parameters:: ch - the character to be tested
Returns:: true if the character is a letter or digit; false otherwise.
See Also:: isDigit, isLetter, isJavaIdentifierPart, isUnicodeIdentifierPart

isJavaLetter

  public static boolean isJavaLetter(char ch)

Note: isJavaLetter() is deprecated. This is the old name for this functionality; as of JDK version 1.1, the preferred method to use for this purpose is isJavaIdentifierStart.

Determines whether the specified character is a "Java" letter, that is, permissible as the first character in a Java identifier.

A character is considered to be a Java letter if and only if it is a letter or a currency symbol (such as "$") or a connecting punctuation character (such as "_").

Parameters:: ch - the character to be tested
Returns:: true if the character is a Java letter; false otherwise.
See Also:: isJavaIdentifierStart, isLetter, isJavaLetterOrDigit, isUnicodeIdentifierStart

isJavaLetterOrDigit

  public static boolean isJavaLetterOrDigit(char ch)

Note: isJavaLetterOrDigit() is deprecated. This is the old name for this functionality; as of JDK version 1.1, the preferred method to use for this purpose is isJavaIdentifierPart.

Determines whether the specified character is a "Java" letter or digit, that is, permissible as a non-initial character in a Java identifier.

A character is considered to be a Java letter or digit if and only if it is a Java letter (as defined by isJavaLetter) or a digit.

Parameters:: ch - the character to be tested
Returns:: true if the character is a Java letter or digit; false otherwise.
See Also:: isJavaIdentifierPart, isLetterOrDigit, isJavaLetter, isUnicodeIdentifierPart

isJavaIdentifierStart

  public static boolean isJavaIdentifierStart(char ch)

Determines whether the specified character is permissible as the first character in a Java identifier.

A character may start a Java identifier if and only if it is one of the following:

a letter
a currency symbol (such as "$")
a connecting punctuation character (such as "_").

Parameters:: ch - the character to be tested
Returns:: true if the character may start a Java identifier; false otherwise.
See Also:: isLetter, isJavaIdentifierPart, isUnicodeIdentifierStart

isJavaIdentifierPart

  public static boolean isJavaIdentifierPart(char ch)

Determines whether the specified character may be part of a Java identifier as other than the first character.

A character may be part of a Java identifier if and only if it is one of the following:

a letter
a currency symbol (such as "$")
a connecting punctuation character (such as "_").
a digit
a numeric letter (such as a Roman numeral character)
a combining mark
a non-spacing mark
an ignorable control character

Parameters:: ch - the character to be tested
Returns:: true if the character may be part of a Unicode identifier; false otherwise.
See Also:: isLetterOrDigit, isJavaIdentifierStart, isIdentifierIgnorable, isUnicodeIdentifierPart

isUnicodeIdentifierStart

  public static boolean isUnicodeIdentifierStart(char ch)

Determines whether the specified character is permissible as the first character in a Unicode identifier.

A character may start a Unicode identifier if and only if it is a letter.

Parameters:: ch - the character to be tested
Returns:: true if the character may start a Unicode identifier; false otherwise.
See Also:: isLetter, isJavaIdentifierStart, isUnicodeIdentifierPart

isUnicodeIdentifierPart

  public static boolean isUnicodeIdentifierPart(char ch)

Determines whether the specified character may be part of a Unicode identifier as other than the first character.

A character may be part of a Unicode identifier if and only if it is one of the following:

a letter
a connecting punctuation character (such as "_").
a digit
a numeric letter (such as a Roman numeral character)
a combining mark
a non-spacing mark
an ignorable control character

Parameters:: ch - the character to be tested
Returns:: true if the character may be part of a Unicode identifier; false otherwise.
See Also:: isLetterOrDigit, isUnicodeIdentifierStart, isIdentifierIgnorable, isJavaIdentifierPart

isIdentifierIgnorable

  public static boolean isIdentifierIgnorable(char ch)

Determines whether the specified character should be regarded as an ignorable character in a Java identifier or a Unicode identifier.

The following Unicode characters are ignorable in a Java identifier or a Unicode identifier:

0x0000 through 0x0008, 0x000E through 0x001B, and 0x007F through 0x009F: ISO control characters that are not whitespace
0x200C through 0x200F: join controls
0x200A through 0x200E: bidirectional controls
0x206A through 0x206F: format controls
0xFEFF: zero-width no-break space

Parameters:: ch - the character to be tested
Returns:: true if the character may be part of a Unicode identifier; false otherwise.
See Also:: isJavaIdentifierPart, isUnicodeIdentifierPart

toLowerCase

  public static char toLowerCase(char ch)

The given character is mapped to its lowercase equivalent; if the character has no lowercase equivalent, the character itself is returned. A character has a lowercase equivalent if and only if a lowercase mapping is specified for the character in the Unicode 2.0 attribute table. Note that some Unicode characters in the range 0x2000 through 0x2FFF have lowercase mappings; for example, ? (ROMAN NUMERAL ONE) has a lowercase mapping to ? (SMALL ROMAN NUMERAL ONE). This method does map such characters to their lowercase equivalents even though the method isUpperCase does not return true for such characters.

Parameters:: ch - the character to be converted
Returns:: the lowercase equivalent of the character, if any; otherwise the character itself.
See Also:: isLowerCase, isUpperCase, toUpperCase, toTitleCase

toUpperCase

  public static char toUpperCase(char ch)

The given character is mapped to its uppercase equivalent; if the character has no uppercase equivalent, the character itself is returned.

A character has a uppercase equivalent if and only if a uppercase mapping is specified for the character in the Unicode 2.0 attribute table. Note that some Unicode characters in the range 0x2000 through 0x2FFF have uppercase mappings; for example, ? (SMALL ROMAN NUMERAL ONE) has an uppercase mapping to ? (ROMAN NUMERAL ONE). This method does map such characters to their uppercase equivalents even though the method isLowerCase does not return true for such characters.

Parameters:: ch - the character to be converted
Returns:: the uppercase equivalent of the character, if any; otherwise the character itself.
See Also:: isUpperCase, isLowerCase, toLowerCase, toTitleCase

toTitleCase

  public static char toTitleCase(char ch)

The given character is mapped to its titlecase equivalent; if the character has no titlecase equivalent, the character itself is returned. A character has a titlecase equivalent if and only if a titlecase mapping is specified for the character in the Unicode 2.0 attribute table. Note that some Unicode characters in the range 0x2000 through 0x2FFF have titlecase mappings; for example, ? (SMALL ROMAN NUMERAL ONE) has an titlecase mapping to ? (ROMAN NUMERAL ONE). This method does map such characters to their titlecase equivalents. There are only four Unicode characters that are truly titlecase forms that are distinct from uppercase forms. As a rule, if a character has no true titlecase equivalent but does have an uppercase mapping, then the Unicode 2.0 attribute table specifies a titlecase mapping that is the same as the uppercase mapping.

Parameters:: ch - the character to be converted
Returns:: the titlecase equivalent of the character, if any; otherwise the character itself.
See Also:: isTitleCase, toUpperCase, toLowerCase

digit

  public static int digit(char ch,
                          int radix)

Returns the numeric value of the character digit using the specified radix. If the radix is not a valid radix, or the character is not a valid digit in the specified radix, -1 is returned.

A radix is valid if its value is not less than Character.MIN_RADIX and not greater than Character.MAX_RADIX. A character is a valid digit iff one of the following is true:

The method isDigit is true of the character and the Unicode 2.0 decimal digit value of the character (or its single-character decomposition) is less than the specified radix.
The character is an uppercase or lowercase Latin letter and the position of the letter in the Latin alphabet, plus 9, is less than the specified radix.

Parameters:: ch - the character to be converted; radix - the radix
Returns:: the value of the character, considered as a digit in the specified radix, or -1 if that is not possible
See Also:: isDigit, forDigit

getNumericValue

  public static int getNumericValue(char ch)

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

Parameters:: ch - the character to be converted; radix - the radix
Returns:: the numeric value of the character, as a nonnegative int value; -2 if the character has a numeric value that is not a nonnegative integer; -1 if the character has no numeric value
See Also:: isDigit, forDigit

isSpace

  public static boolean isSpace(char ch)

Note: isSpace() is deprecated. This method handles only ISO-LATIN-1 whitespace characters. To avoid disrupting existing code, its functionality remains unchanged. As of JDK version 1.1, the preferred method to use for detecting whitespace characters is isWhitespace.

Determines if the specified character is ISO-LATIN-1 white space according to Java.

Parameters:: ch - the character to be tested
Returns:: true if the character is a horizontal tabulation, new line, form feed, carriage returm, or space; false otherwise.
See Also:: isWhitespace, isSpaceChar

isSpaceChar

  public static boolean isSpaceChar(char ch)

Determines if the specified character is a Unicode space character.

A character is considered to be a space character if and only if it is specified to be a space character by the Unicode 2.0 standard (category "Zs", "Zl, or "Zp" in the Unicode specification data file).

Parameters:: ch - the character to be tested
Returns:: true if the character is a space character; false otherwise.
See Also:: isWhitespace

isWhitespace

  public static boolean isWhitespace(char ch)

Determines if the specified character is white space according to Java.

A character is considered to be a Java whitespace character if and only if it satisfies one of the following criteria:

It is a Unicode space separator (category "Zs") but is not a no-break space (\u00A0 or \uFEFF).
It is a Unicode line separator (category "Zl").
It is a Unicode paragraph separator (category "Zp").
It is \u0009, HORIZONTAL TABULATION.
It is \u000A, LINE FEED.
It is \u000B, VERTICAL TABULATION.
It is \u000C, FORM FEED.
It is \u000D, CARRIAGE RETURN
It is \u001C, FILE SEPARATOR.
It is \u001D, GROUP SEPARATOR.
It is \u001E, RECORD SEPARATOR.
It is \u001F, UNIT SEPARATOR.

Parameters:: ch - the character to be tested
Returns:: true if the character is a Java whitespace character; false otherwise.
See Also:: isSpaceChar

isISOControl

  public static boolean isISOControl(char ch)

Determines if the specified character is an ISO control character.

A character is considered to be an ISO control character if its code is in the range \u0000 through \u001F or in the range \u007F through \u009F.

Parameters:: ch - the character to be tested
Returns:: true if the character is an ISO control character; false otherwise.
See Also:: isWhitespace, isSpaceChar

getType

  public static int getType(char ch)

Returns a value indicating a character category.

Parameters:: ch - the character to be tested
Returns:: a value of type int, the character category.
See Also:: UNASSIGNED, UPPERCASE_LETTER, LOWERCASE_LETTER, TITLECASE_LETTER, MODIFIER_LETTER, OTHER_LETTER, NON_SPACING_MARK, ENCLOSING_MARK, COMBINING_SPACING_MARK, DECIMAL_DIGIT_NUMBER, OTHER_NUMBER, SPACE_SEPARATOR, LINE_SEPARATOR, PARAGRAPH_SEPARATOR, CONTROL, FORMAT, PRIVATE_USE, SURROGATE, DASH_PUNCTUATION, OPEN_PUNCTUATION, CLOSE_PUNCTUATION, CONNECTOR_PUNCTUATION, OTHER_PUNCTUATION, LETTER_NUMBER, MATH_SYMBOL, CURRENCY_SYMBOL, MODIFIER_SYMBOL, OTHER_SYMBOL

forDigit

  public static char forDigit(int digit,
                              int radix)

Returns the character value for the specified digit in the specified radix. If the digit is not valid in the radix, the 0 character is returned.

Parameters:: digit - the digit chosen by the character value; radix - the radix containing the digit

All Packages  Class Hierarchy  This Package  Previous  Next  Index