Implementierte Schnittstellen
Serializable ， Comparable<Character>
```
public final class Character
extends Object
implements Serializable, Comparable<Character>
```
CharacterDie Klasse umschließt den Wert des primitiven Typscharin einem Objekt. Ein Objekt vom TypCharacterenthält ein einzelnes Feld vom Typchar. Außerdem bietet die Klasse mehrere Methoden. Diese bestimmen die Kategorie eines Zeichens (Kleinbuchstabe, Ziffer usw.) und wandeln Zeichen von Groß- in Kleinschreibung um und umgekehrt.
Die Zeicheninformationen basieren auf dem Unicode-Standard Version 10.0.0.
Die Methoden und Daten der KlasseCharactersind durch Informationen aus der Datei UnicodeData definiert. Diese Datei ist Teil der Unicode-Zeichendatenbank, die das Unicode Consortium pflegt. Die Datei legt verschiedene Attribute fest. Dazu gehören Name und allgemeine Kategorie jedes definierten Unicode-Codepunkts oder Zeichenbereichs.
Die Datei und ihre Beschreibung sind beim Unicode Consortium erhältlich:
- http://www.unicode.org
Unicode Character Representations

charDer Datentyp (und damitCharacterder im Objekt gekapselte Wert) basiert auf der ursprünglichen Unicode-Spezifikation. Diese definierte Zeichen als Entitäten mit fester Breite von 16 Bit. Der Unicode-Standard wurde später geändert. Er erlaubt jetzt Zeichen, deren Darstellung mehr als 16 Bit benötigt. Der Bereich der gültigen code points reicht jetzt von U+0000 bis U+10FFFF. Diese Werte heißen Unicode scalar values. (Siehe die definition der U+n-Notation im Unicode-Standard.)
Die Zeichenmenge von U+0000 bis U+FFFF wird manchmal als Basic Multilingual Plane (BMP) bezeichnet. Characters mit einem Codepunkt größer als U+FFFF heißen supplementary characters. Die Java-Plattform verwendetcharArrays undString和StringBufferKlassen in einer UTF-16-Darstellung. In dieser Darstellung werden ergänzende Zeichen als Paar voncharWerten dargestellt. Der erste stammt aus dem high surrogate-Bereich (\uD800-\uDBFF). Der zweite stammt aus dem low surrogate-Bereich (\uDC00-\uDFFF).
Deshalb repräsentiert eincharWert einen BMP-Codepunkt. Dazu gehören Surrogat-Codepunkte oder UTF-16-codierte Codeeinheiten.intEinintWert repräsentiert alle Unicode-Codepunkte, einschließlich ergänzender Codepunkte. Die unteren 21 (niedrigwertigen) Bits stellen den Unicode-Codepunkt dar. Die oberen 11 (höchstwertigen) Bits müssen null sein. Sofern nicht anders angegeben, verhalten sich Methoden für ergänzende Zeichen und Surrogat-charWerte wie folgt:
- Methoden, die nurcharWerte akzeptieren, unterstützen keine ergänzenden Zeichen. Sie behandelncharWerte im Surrogat-Bereich als undefinierte Zeichen. Zum Beispiel gibtCharacter.isLetter('\uD840')返回falseWert zurück, obwohl ein bestimmter Wert in dieser Zeichenfolge auf einen low surrogate-Wert folgt und einen Buchstaben darstellt.
- Methoden, dieintWerte akzeptieren, unterstützen alle Unicode-Zeichen, einschließlich ergänzender Zeichen. Zum Beispiel gibtCharacter.isLetter(0x2F81A)返回trueWert zurück, weil der Codepunktwert einen Buchstaben (CJK-Ideogramm) darstellt.
In der Java SE API-Dokumentation bezeichnet Unicode code point Zeichenwerte zwischen U+0000 und U+10FFFF. Der Begriff Unicode code unit bezeichnet 16-Bit-charWerte. Diese Werte sind UTF-16-codierte Codeeinheiten. Weitere Informationen zu Unicode-Begriffen finden Sie im Unicode Glossary.
Seit Version: 1.0 Siehe auch: Serialized Form

嵌套类汇总

Verschachtelte Klasse Variablen und Typen Klasse Beschreibung

`static class`	`Character.Subset`	Eine Instanz dieser Klasse repräsentiert eine bestimmte Teilmenge des Unicode-Zeichensatzes.
`static class`	`Character.UnicodeBlock`	Eine Familie von Zeichenteilmengen, die Zeichenblöcke in der Unicode-Spezifikation repräsentieren.
`static class`	`Character.UnicodeScript`	Eine Familie von Zeichenteilmengen, die Zeichenskripte repräsentieren. Diese sind in Unicode Standard Annex #24: Script Names definiert.

字段汇总

Feld Variablen und Typen Feld Beschreibung

`static int`	`BYTES`	Die Anzahl der Bytes, die zur Darstellung eines`char`Werts in vorzeichenloser Binärform verwendet werden.
`static byte`	`COMBINING_SPACING_MARK`	Die allgemeine Kategorie "Mc" in der Unicode-Spezifikation.
`static byte`	`CONNECTOR_PUNCTUATION`	Die allgemeine Kategorie "Pc" in der Unicode-Spezifikation.
`static byte`	`CONTROL`	Die allgemeine Kategorie "Cc" in der Unicode-Spezifikation.
`static byte`	`CURRENCY_SYMBOL`	Die allgemeine Kategorie "Sc" in der Unicode-Spezifikation.
`static byte`	`DASH_PUNCTUATION`	Die allgemeine Kategorie "Pd" in der Unicode-Spezifikation.
`static byte`	`DECIMAL_DIGIT_NUMBER`	Die allgemeine Kategorie „Nd" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_ARABIC_NUMBER`	Der schwache bidirektionale Zeichentyp „AN" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_BOUNDARY_NEUTRAL`	Der schwache bidirektionale Zeichentyp „BN" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_COMMON_NUMBER_SEPARATOR`	Der schwache bidirektionale Zeichentyp „CS" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER`	Der schwache bidirektionale Zeichentyp „EN" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR`	Der schwache bidirektionale Zeichentyp „ES" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR`	Der schwache bidirektionale Zeichentyp „ET" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_FIRST_STRONG_ISOLATE`	Der schwache bidirektionale Zeichentyp „FSI" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT`	Der starke bidirektionale Zeichentyp „L" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING`	Der starke bidirektionale Zeichentyp „LRE" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE`	Der schwache bidirektionale Zeichentyp „LRI" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE`	Der starke bidirektionale Zeichentyp „LRO" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_NONSPACING_MARK`	Der schwache bidirektionale Zeichentyp „NSM" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_OTHER_NEUTRALS`	Der neutrale bidirektionale Zeichentyp „ON" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_PARAGRAPH_SEPARATOR`	Der neutrale bidirektionale Zeichentyp „B" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_POP_DIRECTIONAL_FORMAT`	Der schwache bidirektionale Zeichentyp „PDF" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE`	Der schwache bidirektionale Zeichentyp „PDI" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT`	Der starke bidirektionale Zeichentyp „R" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC`	Der starke bidirektionale Zeichentyp „AL" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING`	Der starke bidirektionale Zeichentyp „RLE" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE`	Der schwache bidirektionale Zeichentyp „RLI" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE`	Der starke bidirektionale Zeichentyp „RLO" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_SEGMENT_SEPARATOR`	Der neutrale bidirektionale Zeichentyp „S" in der Unicode-Spezifikation.
`static byte`	`DIRECTIONALITY_UNDEFINED`	Der nicht definierte bidirektionale Zeichentyp.
`static byte`	`DIRECTIONALITY_WHITESPACE`	Der neutrale bidirektionale Zeichentyp „WS" in der Unicode-Spezifikation.
`static byte`	`ENCLOSING_MARK`	Die allgemeine Kategorie „Me" in der Unicode-Spezifikation.
`static byte`	`END_PUNCTUATION`	Die allgemeine Kategorie „Pe" in der Unicode-Spezifikation.
`static byte`	`FINAL_QUOTE_PUNCTUATION`	Die allgemeine Kategorie „Pf" in der Unicode-Spezifikation.
`static byte`	`FORMAT`	Die allgemeine Kategorie „Cf" in der Unicode-Spezifikation.
`static byte`	`INITIAL_QUOTE_PUNCTUATION`	Die allgemeine Kategorie „Pi" in der Unicode-Spezifikation.
`static byte`	`LETTER_NUMBER`	Die allgemeine Kategorie „Nl" in der Unicode-Spezifikation.
`static byte`	`LINE_SEPARATOR`	Die allgemeine Kategorie „Zl" in der Unicode-Spezifikation.
`static byte`	`LOWERCASE_LETTER`	Die allgemeine Kategorie „Ll" in der Unicode-Spezifikation.
`static byte`	`MATH_SYMBOL`	Die allgemeine Kategorie „Sm" in der Unicode-Spezifikation.
`static int`	`MAX_CODE_POINT`	Der Maximalwert ist ein Unicode code point, Konstante`U+10FFFF` 。
`static char`	`MAX_HIGH_SURROGATE`	Der Maximalwert ist ein Unicode high-surrogate code unit in UTF-16-Kodierung, Konstante`'\uDBFF'` 。
`static char`	`MAX_LOW_SURROGATE`	Der Maximalwert ist ein Unicode low-surrogate code unit in UTF-16-Kodierung, Konstante`'\uDFFF'` 。
`static int`	`MAX_RADIX`	Der maximale Radix für die Konvertierung in Strings und aus Strings.
`static char`	`MAX_SURROGATE`	Der maximale Wert eines Unicode-Surrogate-Code-Einheitswerts in UTF-16-Kodierung, Konstante`'\uDFFF'` 。
`static char`	`MAX_VALUE`	Der konstante Wert dieses Feldes ist vom Typ`char` `'\uFFFF'` 。
`static int`	`MIN_CODE_POINT`	Der minimale Unicode code point, Konstante`U+0000` 。
`static char`	`MIN_HIGH_SURROGATE`	Der minimale Unicode high-surrogate code unit in UTF-16-Kodierung, Konstante`'\uD800'` 。
`static char`	`MIN_LOW_SURROGATE`	Der minimale Unicode low-surrogate code unit in UTF-16-Kodierung, Konstante`'\uDC00'` 。
`static int`	`MIN_RADIX`	Der minimale Radix für die Konvertierung in Strings und aus Strings.
`static int`	`MIN_SUPPLEMENTARY_CODE_POINT`	Der minimale Unicode supplementary code point, Konstante`U+10000` 。
`static char`	`MIN_SURROGATE`	Der minimale Wert eines Unicode-Surrogate-Code-Einheitswerts in UTF-16-Kodierung, Konstante`'\uD800'` 。
`static char`	`MIN_VALUE`	Der konstante Wert dieses Feldes ist vom Typ`char` `'\u0000'` 。
`static byte`	`MODIFIER_LETTER`	Allgemeine Kategorie "Lm" in der Unicode-Spezifikation.
`static byte`	`MODIFIER_SYMBOL`	Allgemeine Kategorie "Sk" in der Unicode-Spezifikation.
`static byte`	`NON_SPACING_MARK`	Allgemeine Kategorie "Mn" in der Unicode-Spezifikation.
`static byte`	`OTHER_LETTER`	Allgemeine Kategorie "Lo" in der Unicode-Spezifikation.
`static byte`	`OTHER_NUMBER`	Allgemeine Kategorie "No" in der Unicode-Spezifikation.
`static byte`	`OTHER_PUNCTUATION`	Allgemeine Kategorie "Po" in der Unicode-Spezifikation.
`static byte`	`OTHER_SYMBOL`	Allgemeine Kategorie "So" in der Unicode-Spezifikation.
`static byte`	`PARAGRAPH_SEPARATOR`	Allgemeine Kategorie "Zp" in der Unicode-Spezifikation.
`static byte`	`PRIVATE_USE`	Allgemeine Kategorie "Co" in der Unicode-Spezifikation.
`static int`	`SIZE`	Die Anzahl der Bits zur Darstellung eines`char`Werts in vorzeichenloser Binärform, Konstante `16` 。
`static byte`	`SPACE_SEPARATOR`	Allgemeine Kategorie "Zs" in der Unicode-Spezifikation.
`static byte`	`START_PUNCTUATION`	Allgemeine Kategorie "Ps" in der Unicode-Spezifikation.
`static byte`	`SURROGATE`	Allgemeine Kategorie "Cs" in der Unicode-Spezifikation.
`static byte`	`TITLECASE_LETTER`	Allgemeine Kategorie "Lt" in der Unicode-Spezifikation.
`static 类<Character>`	`TYPE`	`类`Das Beispiel repräsentiert den primitiven Typ `char` 。
`static byte`	`UNASSIGNED`	Allgemeine Kategorie "Cn" in der Unicode-Spezifikation.
`static byte`	`UPPERCASE_LETTER`	Allgemeine Kategorie "Lu" in der Unicode-Spezifikation.

构造方法摘要

Konstruktor Konstruktor Beschreibung

`Character(char value)`	Veraltet. Die Verwendung dieses Konstruktors ist selten geeignet.

方法摘要

Alle Methoden Statische Methoden Instanzmethoden Konkrete Methoden Veraltete Methoden Variablen und Typen Methode Beschreibung

`static int`	`charCount(int codePoint)`	Bestimmt die Anzahl der Werte, die zur Darstellung des angegebenen Zeichens (Unicode-Codepunkt) erforderlich sind.`char`.
`char`	`charValue()`	Gibt den Wert dieses`Character`Objekts zurück.
`static int`	`codePointAt(char[] a, int index)`	Gibt den Codepunkt an der angegebenen Position des`char`Arrays zurück.
`static int`	`codePointAt(char[] a, int index, int limit)`	Gibt den Codepunkt an der angegebenen Position des`char`Arrays zurück, wobei nur `index`-Elemente kleiner als `limit`数组元素。
`static int`	`codePointAt(CharSequence seq, int index)`	Gibt den Codepunkt an der angegebenen Position von`CharSequence`zurück.
`static int`	`codePointBefore(char[] a, int index)`	Gibt den Codepunkt vor der angegebenen Position des`char`Arrays zurück.
`static int`	`codePointBefore(char[] a, int index, int start)`	Gibt den Codepunkt vor der angegebenen Position des`char`Arrays zurück, wobei nur `index`-Elemente größer oder gleich `start`数组元素。
`static int`	`codePointBefore(CharSequence seq, int index)`	Gibt den Codepunkt vor der angegebenen Position von`CharSequence`zurück.
`static int`	`codePointCount(char[] a, int offset, int count)`	Gibt die Anzahl der Unicode-Codepunkte im Teilarray des`char`Arrays zurück.
`static int`	`codePointCount(CharSequence seq, int beginIndex, int endIndex)`	Gibt die Anzahl der Unicode-Codepunkte im Textbereich der angegebenen char-Sequenz zurück.
`static int`	`codePointOf(String name)`	Gibt den Codepunktwert des Unicode-Zeichens zurück, das durch den angegebenen Unicode-Zeichennamen festgelegt ist.
`static int`	`compare(char x, char y)`	Vergleicht zwei`char`值。
`int`	`compareTo(Character anotherCharacter)`	Vergleicht zwei`Character`对象。
`static int`	`digit(char ch, int radix)`	Gibt den numerischen Wert des Zeichens`ch`的数值。
`static int`	`digit(int codePoint, int radix)`	Gibt den numerischen Wert des angegebenen Zeichens (Unicode-Codepunkt) in der angegebenen Basis zurück.
`boolean`	`equals(Object obj)`	Vergleicht dieses Objekt mit dem angegebenen Objekt.
`static char`	`forDigit(int digit, int radix)`	Bestimmt die Zeichendarstellung einer bestimmten Zahl in der angegebenen Basis.
`static byte`	`getDirectionality(char ch)`	Gibt die Unicode-Richtungsattribut des angegebenen Zeichens zurück.
`static byte`	`getDirectionality(int codePoint)`	Gibt die Unicode-Richtungsattribut des angegebenen Zeichens (Unicode-Codepunkt) zurück.
`static String`	`getName(int codePoint)`	Gibt den Unicode-Namen des angegebenen Zeichens`codePoint`zurück, wenn der Codepunkt`unassigned`Gibt null zurück.
`static int`	`getNumericValue(char ch)`	Gibt den Wert zurück, den das angegebene Unicode-Zeichen`int`值。
`static int`	`getNumericValue(int codePoint)`	Gibt den Wert zurück, den das angegebene Zeichen (Unicode-Codepunkt)`int`值。
`static int`	`getType(char ch)`	Gibt den Wert zurück, der die allgemeine Kategorie des Zeichens angibt.
`static int`	`getType(int codePoint)`	Gibt den Wert zurück, der die allgemeine Kategorie des Zeichens angibt.
`int`	`hashCode()`	Gibt den Hash-Code dieses`Character`zurück. Das entspricht dem Ergebnis des Aufrufs von`charValue()`.
`static int`	`hashCode(char value)`	Gibt den Hash-Code des`char`Werts zurück. Das ist kompatibel mit`Character.hashCode()`.
`static char`	`highSurrogate(int codePoint)`	Gibt das führende Surrogat (eine high surrogate code unit) des Surrogate-Paars zurück, das das angegebene ergänzende Zeichen (Unicode-Codepunkt) in UTF-16-Kodierung darstellt.
`static boolean`	`isAlphabetic(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Buchstabe ist.
`static boolean`	`isBmpCodePoint(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) in der Basic Multilingual Plane (BMP) liegt.
`static boolean`	`isDefined(char ch)`	Bestimmt, ob das Zeichen in Unicode definiert ist.
`static boolean`	`isDefined(int codePoint)`	Bestimmt, ob das Zeichen (Unicode-Codepunkt) in Unicode definiert ist.
`static boolean`	`isDigit(char ch)`	Bestimmt, ob das angegebene Zeichen eine Ziffer ist.
`static boolean`	`isDigit(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) eine Ziffer ist.
`static boolean`	`isHighSurrogate(char ch)`	Bestimmt, ob der angegebene`char`Wert ein Unicode high-surrogate code unit ist (auch leading surrogate code unit genannt).
`static boolean`	`isIdentifierIgnorable(char ch)`	Bestimmt, ob das angegebene Zeichen in einem Java-Bezeichner oder Unicode-Bezeichner als ignorierbares Zeichen gilt.
`static boolean`	`isIdentifierIgnorable(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) in einem Java-Bezeichner oder Unicode-Bezeichner als ignorierbares Zeichen gilt.
`static boolean`	`isIdeographic(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein CJKV-Ideogramm ist (chinesisch, japanisch, koreanisch und vietnamesisch), wie die Unicode-Norm es definiert.
`static boolean`	`isISOControl(char ch)`	Bestimmt, ob das angegebene Zeichen ein ISO-Steuerzeichen ist.
`static boolean`	`isISOControl(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein ISO-Steuerzeichen ist.
`static boolean`	`isJavaIdentifierPart(char ch)`	Bestimmt, ob das angegebene Zeichen Teil eines Java-Bezeichners sein darf, aber nicht das erste Zeichen ist.
`static boolean`	`isJavaIdentifierPart(int codePoint)`	Bestimmt, ob das Zeichen (Unicode-Codepunkt) Teil eines Java-Bezeichners sein darf, aber nicht das erste Zeichen ist.
`static boolean`	`isJavaIdentifierStart(char ch)`	Bestimmt, ob das angegebene Zeichen als erstes Zeichen eines Java-Bezeichners zulässig ist.
`static boolean`	`isJavaIdentifierStart(int codePoint)`	Bestimmt, ob das Zeichen (Unicode-Codepunkt) als erstes Zeichen eines Java-Bezeichners zulässig ist.
`static boolean`	`isJavaLetter(char ch)`	Veraltet. Ersetzt durch isJavaIdentifierStart(char).
`static boolean`	`isJavaLetterOrDigit(char ch)`	Veraltet. Ersetzt durch isJavaIdentifierPart(char).
`static boolean`	`isLetter(char ch)`	Bestimmt, ob das angegebene Zeichen ein Buchstabe ist.
`static boolean`	`isLetter(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Buchstabe ist.
`static boolean`	`isLetterOrDigit(char ch)`	Bestimmt, ob das angegebene Zeichen ein Buchstabe oder eine Ziffer ist.
`static boolean`	`isLetterOrDigit(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Buchstabe oder eine Ziffer ist.
`static boolean`	`isLowerCase(char ch)`	Bestimmt, ob das angegebene Zeichen ein Kleinbuchstabe ist.
`static boolean`	`isLowerCase(int codePoint)`	Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Kleinbuchstabe ist.
`static boolean`	`isLowSurrogate(char ch)`	Bestimmt, ob der angegebene`char`Prüft, ob der Wert eine Unicode low-surrogate code unit ist (auch trailing-surrogate code unit genannt).
`static boolean`	`isMirrored(char ch)`	Ermittelt, ob das Zeichen gemäß der Unicode-Spezifikation gespiegelt wird.
`static boolean`	`isMirrored(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) gemäß der Unicode-Spezifikation gespiegelt wird.
`static boolean`	`isSpace(char ch)`	Veraltet. Ersetzt durch isWhitespace(char).
`static boolean`	`isSpaceChar(char ch)`	Ermittelt, ob das angegebene Zeichen ein Unicode-Leerzeichen ist.
`static boolean`	`isSpaceChar(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Unicode-Leerzeichen ist.
`static boolean`	`isSupplementaryCodePoint(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) im Bereich der supplementary characters liegt.
`static boolean`	`isSurrogate(char ch)`	Ermittelt, ob der angegebene`char`Wert eine Unicode-Surrogate-Code-Einheit ist.
`static boolean`	`isSurrogatePair(char high, char low)`	Ermittelt, ob das angegebene`char`Wertepaar ein gültiges Unicode surrogate pair ist.
`static boolean`	`isTitleCase(char ch)`	Ermittelt, ob das angegebene Zeichen ein Titlecase-Zeichen ist.
`static boolean`	`isTitleCase(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Titlecase-Zeichen ist.
`static boolean`	`isUnicodeIdentifierPart(char ch)`	Ermittelt, ob das angegebene Zeichen Teil eines Unicode-Bezeichners sein darf, aber nicht das erste Zeichen ist.
`static boolean`	`isUnicodeIdentifierPart(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) Teil eines Unicode-Bezeichners sein darf, aber nicht das erste Zeichen ist.
`static boolean`	`isUnicodeIdentifierStart(char ch)`	Ermittelt, ob das angegebene Zeichen als erstes Zeichen eines Unicode-Bezeichners zulässig ist.
`static boolean`	`isUnicodeIdentifierStart(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) als erstes Zeichen eines Unicode-Bezeichners zulässig ist.
`static boolean`	`isUpperCase(char ch)`	Ermittelt, ob das angegebene Zeichen ein Großbuchstabe ist.
`static boolean`	`isUpperCase(int codePoint)`	Ermittelt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Großbuchstabe ist.
`static boolean`	`isValidCodePoint(int codePoint)`	Ermittelt, ob der angegebene Codepunkt ein gültiger Unicode code point value ist.
`static boolean`	`isWhitespace(char ch)`	Ermittelt gemäß Java, ob das angegebene Zeichen ein Leerzeichen ist.
`static boolean`	`isWhitespace(int codePoint)`	Ermittelt gemäß Java, ob das angegebene Zeichen (Unicode-Codepunkt) ein Leerzeichen ist.
`static char`	`lowSurrogate(int codePoint)`	Gibt die trailing surrogate (eine low surrogate code unit) des surrogate pair zurück, das den angegebenen ergänzenden Charakter (Unicode-Codepunkt) in UTF-16-Kodierung darstellt.
`static int`	`offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)`	Gibt den Index der angegebenen Position`char`zurück. Das Teilarray beginnt am angegebenen Offset `index`und umfasst `codePointOffset`代码点。
`static int`	`offsetByCodePoints(CharSequence seq, int index, int codePointOffset)`	Gibt den Index in der angegebenen char-Sequenz zurück, beginnend am angegebenen`index`Offset `codePointOffset`代码点。
`static char`	`reverseBytes(char ch)`	Gibt den Wert zurück, der durch Umkehrung der`char`Byte-Reihenfolge im angegebenen Wert entsteht.
`static char[]`	`toChars(int codePoint)`	Konvertiert das angegebene Zeichen (Unicode-Codepunkt) in seine UTF-16-Darstellung, die im`char`Array gespeichert ist.
`static int`	`toChars(int codePoint, char[] dst, int dstIndex)`	Konvertiert das angegebene Zeichen (Unicode-Codepunkt) in seine UTF-16-Darstellung.
`static int`	`toCodePoint(char high, char low)`	Konvertiert das angegebene Surrogatpaar in seinen ergänzenden Codepunktwert.
`static char`	`toLowerCase(char ch)`	Konvertiert das Zeichenparameter mithilfe der Groß-/Kleinschreibungsinformationen aus der UnicodeData-Datei in Kleinbuchstaben.
`static int`	`toLowerCase(int codePoint)`	Konvertiert den Parameter Zeichen (Unicode-Codepunkt) mithilfe der Groß-/Kleinschreibungsinformationen aus der UnicodeData-Datei in Kleinbuchstaben.
`String`	`toString()`	Gibt das Objekt zurück, das diesen`Character`值的 `String`对象。
`static String`	`toString(char c)`	Gibt das Objekt zurück, das das angegebene`char`的 `String`对象。
`static String`	`toString(int codePoint)`	Gibt das Objekt zurück, das das angegebene Zeichen (Unicode-Codepunkt) darstellt.`String`对象。
`static char`	`toTitleCase(char ch)`	Konvertiert das Zeichenargument mit den Groß-/Kleinschreibungs-Mappings aus der UnicodeData-Datei in Titlecase.
`static int`	`toTitleCase(int codePoint)`	Konvertiert das Zeichenargument (Unicode-Codepunkt) mit den Groß-/Kleinschreibungs-Mappings aus der UnicodeData-Datei in Titlecase.
`static char`	`toUpperCase(char ch)`	Konvertiert das Zeichenargument mit den Groß-/Kleinschreibungs-Mappings aus der UnicodeData-Datei in Großbuchstaben.
`static int`	`toUpperCase(int codePoint)`	Konvertiert das Zeichenargument (Unicode-Codepunkt) mit den Groß-/Kleinschreibungs-Mappings aus der UnicodeData-Datei in Großbuchstaben.
`static Character`	`valueOf(char c)`	Gibt eine`char`值的 `Character`Wert darstellt.

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - MIN_RADIX
```
public static final int MIN_RADIX
```
    Der kleinste Basiswert für die Konvertierung in Strings und aus Strings. Der konstante Wert dieses Felds ist der kleinste erlaubte Wert für den Basisparameter der Basiskonvertierungsmethoden, zum Beispieldigit方法， forDigit方法和toString类Integer方法。
    Siehe auch:
    digit(char, int),forDigit(int, int),Integer.toString(int, int),Integer.valueOf(String), Konstanter Feldwert
  - MAX_RADIX
```
public static final int MAX_RADIX
```
    Der maximale Radix für die Konvertierung in Strings und aus Strings. Der Konstantwert dieses Felds ist der maximal erlaubte Wert für den Radix-Parameter in Radix-Konvertierungsmethodendigit , zum Beispieldigit方法， forDigit方法和toString类Integer方法。
    Siehe auch:
    digit(char, int),forDigit(int, int),Integer.toString(int, int),Integer.valueOf(String), Konstanter Feldwert
  - MIN_VALUE
```
public static final char MIN_VALUE
```
    Der konstante Wert dieses Felds ist vom Typchar '\u0000' 。
    Seit Version: 1.0.2 Siehe auch: Konstante Feldwerte
  - MAX_VALUE
```
public static final char MAX_VALUE
```
    Der konstante Wert dieses Feldes ist vom Typchar '\uFFFF' 。
    Seit Version: 1.0.2 Siehe auch: Konstante Feldwerte
  - TYPE
```
public static final 类<Character> TYPE
```
    类Das Beispiel repräsentiert den primitiven Typ char 。
    Seit Version: 1.1
  - UNASSIGNED
```
public static final byte UNASSIGNED
```
    Allgemeine Kategorie „Cn" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - UPPERCASE_LETTER
```
public static final byte UPPERCASE_LETTER
```
    Allgemeine Kategorie „Lu" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - LOWERCASE_LETTER
```
public static final byte LOWERCASE_LETTER
```
    Allgemeine Kategorie „Ll" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - TITLECASE_LETTER
```
public static final byte TITLECASE_LETTER
```
    Allgemeine Kategorie „Lt" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - MODIFIER_LETTER
```
public static final byte MODIFIER_LETTER
```
    Allgemeine Kategorie „Lm" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - OTHER_LETTER
```
public static final byte OTHER_LETTER
```
    Allgemeine Kategorie „Lo" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - NON_SPACING_MARK
```
public static final byte NON_SPACING_MARK
```
    Allgemeine Kategorie „Mn" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - ENCLOSING_MARK
```
public static final byte ENCLOSING_MARK
```
    Allgemeine Kategorie „Me" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - COMBINING_SPACING_MARK
```
public static final byte COMBINING_SPACING_MARK
```
    Allgemeine Kategorie „Mc" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - DECIMAL_DIGIT_NUMBER
```
public static final byte DECIMAL_DIGIT_NUMBER
```
    Allgemeine Kategorie „Nd" in der Unicode-Spezifikation.
    Seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - LETTER_NUMBER
```
public static final byte LETTER_NUMBER
```
    Die allgemeine Kategorie „Nl" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - OTHER_NUMBER
```
public static final byte OTHER_NUMBER
```
    Die allgemeine Kategorie „No" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - SPACE_SEPARATOR
```
public static final byte SPACE_SEPARATOR
```
    Die allgemeine Kategorie „Zs" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - LINE_SEPARATOR
```
public static final byte LINE_SEPARATOR
```
    Die allgemeine Kategorie „Zl" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - PARAGRAPH_SEPARATOR
```
public static final byte PARAGRAPH_SEPARATOR
```
    Die allgemeine Kategorie „Zp" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - CONTROL
```
public static final byte CONTROL
```
    Die allgemeine Kategorie „Cc" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - FORMAT
```
public static final byte FORMAT
```
    Die allgemeine Kategorie „Cf" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - PRIVATE_USE
```
public static final byte PRIVATE_USE
```
    Die allgemeine Kategorie „Co" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - SURROGATE
```
public static final byte SURROGATE
```
    Die allgemeine Kategorie „Cs" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - DASH_PUNCTUATION
```
public static final byte DASH_PUNCTUATION
```
    Die allgemeine Kategorie „Pd" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - START_PUNCTUATION
```
public static final byte START_PUNCTUATION
```
    Die allgemeine Kategorie „Ps" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - END_PUNCTUATION
```
public static final byte END_PUNCTUATION
```
    Die allgemeine Kategorie „Pe" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - CONNECTOR_PUNCTUATION
```
public static final byte CONNECTOR_PUNCTUATION
```
    Die allgemeine Kategorie „Pc" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - OTHER_PUNCTUATION
```
public static final byte OTHER_PUNCTUATION
```
    Die allgemeine Kategorie „Po" in der Unicode-Spezifikation.
    Verfügbar seit Version 1.1. Siehe auch: Werte der Konstantenfelder
  - MATH_SYMBOL
```
public static final byte MATH_SYMBOL
```
    Die allgemeine Kategorie „Sm" in der Unicode-Spezifikation.
    Verfügbar seit Version 1.1. Siehe auch: Werte der Konstantenfelder
  - CURRENCY_SYMBOL
```
public static final byte CURRENCY_SYMBOL
```
    Die allgemeine Kategorie „Sc" in der Unicode-Spezifikation.
    Verfügbar seit Version 1.1. Siehe auch: Werte der Konstantenfelder
  - MODIFIER_SYMBOL
```
public static final byte MODIFIER_SYMBOL
```
    Die allgemeine Kategorie „Sk" in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - OTHER_SYMBOL
```
public static final byte OTHER_SYMBOL
```
    Allgemeine Kategorie „So“ in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.1 Siehe auch: Konstante Feldwerte
  - INITIAL_QUOTE_PUNCTUATION
```
public static final byte INITIAL_QUOTE_PUNCTUATION
```
    Allgemeine Kategorie „Pi“ in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.4 Siehe auch: Konstante Feldwerte
  - FINAL_QUOTE_PUNCTUATION
```
public static final byte FINAL_QUOTE_PUNCTUATION
```
    Allgemeine Kategorie „Pf“ in der Unicode-Spezifikation.
    Verfügbar seit Version: 1.4 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_UNDEFINED
```
public static final byte DIRECTIONALITY_UNDEFINED
```
    Undefinierter bidirektionaler Zeichentyp. Undefiniertcharder im Unicode-Standard als ungerichtet eingestufte Wert.
    Verfügbar ab Version: 1.4 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_LEFT_TO_RIGHT
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT
```
    Starker bidirektionaler Zeichentyp „L“ in der Unicode-Spezifikation.
    Verfügbar ab Version: 1.4 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_RIGHT_TO_LEFT
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT
```
    Starke bidirektionale Zeichenart „R“ der Unicode-Spezifikation.
    Verfügbar ab Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
```
    Der bidirektionale Zeichentyp „AL“ (stark) in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Konstanter Feldwert
  - DIRECTIONALITY_EUROPEAN_NUMBER
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER
```
    Der bidirektionale Zeichentyp „EN“ (schwach) in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Konstanter Feldwert
  - DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
```
    Der bidirektionale Zeichentyp „ES“ (schwach) in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Konstanter Feldwert
  - DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
```
    Schwacher bidirektionaler Zeichentyp „ET" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_ARABIC_NUMBER
```
public static final byte DIRECTIONALITY_ARABIC_NUMBER
```
    Schwacher bidirektionaler Zeichentyp „AN" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
```
public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
```
    Schwacher bidirektionaler Zeichentyp „CS" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_NONSPACING_MARK
```
public static final byte DIRECTIONALITY_NONSPACING_MARK
```
    Schwacher bidirektionaler Zeichentyp „NSM" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_BOUNDARY_NEUTRAL
```
public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL
```
    Schwacher bidirektionaler Zeichentyp „BN" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_PARAGRAPH_SEPARATOR
```
public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR
```
    Neutraler bidirektionaler Zeichentyp „B" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_SEGMENT_SEPARATOR
```
public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR
```
    Neutraler bidirektionaler Zeichentyp „S" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_WHITESPACE
```
public static final byte DIRECTIONALITY_WHITESPACE
```
    Neutraler bidirektionaler Zeichentyp „WS" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_OTHER_NEUTRALS
```
public static final byte DIRECTIONALITY_OTHER_NEUTRALS
```
    Neutraler bidirektionaler Zeichentyp „ON" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
```
    Starker bidirektionaler Zeichentyp „LRE" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
```
    Starker bidirektionaler Zeichentyp „LRO" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
```
    Starker bidirektionaler Zeichentyp „RLE" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
```
    Starker bidirektionaler Zeichentyp „RLO" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Werte der Konstantenfelder
  - DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
```
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
```
    Schwacher bidirektionaler Zeichentyp „PDF" in der Unicode-Spezifikation.
    Seit Version: 1.4 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE
```
    Der schwache bidirektionale Zeichentyp „LRI" in der Unicode-Spezifikation.
    Seit Version: 9 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE
```
    Der schwache bidirektionale Zeichentyp „RLI" in der Unicode-Spezifikation.
    Seit Version: 9 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_FIRST_STRONG_ISOLATE
```
public static final byte DIRECTIONALITY_FIRST_STRONG_ISOLATE
```
    Der schwache bidirektionale Zeichentyp „FSI" in der Unicode-Spezifikation.
    Seit Version: 9 Siehe auch: Konstante Feldwerte
  - DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
```
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
```
    Der schwache bidirektionale Zeichentyp „PDI" in der Unicode-Spezifikation.
    Seit Version: 9 Siehe auch: Konstante Feldwerte
  - MIN_HIGH_SURROGATE
```
public static final char MIN_HIGH_SURROGATE
```
    Der Minimalwert eines Unicode high-surrogate code unit in der UTF-16-Kodierung, Konstante'\uD800'. Ein hohes Surrogat wird auch als führendes Surrogat bezeichnet.
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MAX_HIGH_SURROGATE
```
public static final char MAX_HIGH_SURROGATE
```
    Der Maximalwert eines Unicode high-surrogate code unit in der UTF-16-Kodierung, Konstante'\uDBFF'. Ein hohes Surrogat wird auch als führendes Surrogat bezeichnet.
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MIN_LOW_SURROGATE
```
public static final char MIN_LOW_SURROGATE
```
    Der Minimalwert eines Unicode low-surrogate code unit in der UTF-16-Kodierung, Konstante'\uDC00'. Ein niedriges Surrogat wird auch als nachfolgendes Surrogat bezeichnet.
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MAX_LOW_SURROGATE
```
public static final char MAX_LOW_SURROGATE
```
    Der Maximalwert eines Unicode low-surrogate code unit in der UTF-16-Kodierung, Konstante'\uDFFF'. Ein niedriges Surrogat wird auch als nachfolgendes Surrogat bezeichnet.
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MIN_SURROGATE
```
public static final char MIN_SURROGATE
```
    Der Minimalwert einer Unicode-Surrogat-Codeeinheit in der UTF-16-Kodierung, Konstante'\uD800' 。
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MAX_SURROGATE
```
public static final char MAX_SURROGATE
```
    Der Maximalwert einer Unicode-Surrogat-Codeeinheit in der UTF-16-Kodierung, Konstante'\uDFFF' 。
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MIN_SUPPLEMENTARY_CODE_POINT
```
public static final int MIN_SUPPLEMENTARY_CODE_POINT
```
    Der Minimalwert eines Unicode supplementary code point, KonstanteU+10000 。
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MIN_CODE_POINT
```
public static final int MIN_CODE_POINT
```
    Der minimale Unicode code point, KonstanteU+0000 。
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - MAX_CODE_POINT
```
public static final int MAX_CODE_POINT
```
    Der maximale Unicode code point, KonstanteU+10FFFF 。
    Seit Version: 1.5 Siehe auch: Konstante Feldwerte
  - SIZE
```
public static final int SIZE
```
    Anzahl der Bits zur Darstellung eines Werts in vorzeichenloser Binärform,charKonstante 16 。
    Seit Version: 1.8 Siehe auch: Konstanter Feldwert
  - BYTES
```
public static final int BYTES
```
    Anzahl der Bytes zur Darstellung eines Werts in vorzeichenloser Binärform.charAnzahl der Bytes des Werts.
    Seit Version: 1.8 Siehe auch: Konstanter Feldwert
- 构造方法详细信息
  - Character
```
@Deprecated(since="9")
public Character(char value)
```
    Veraltet. Dieser Konstruktor ist selten geeignet. Die statische Fabrikmethode
    valueOf(char)ist meist die bessere Wahl, weil sie deutlich bessere Leistung bei Speicher und Zeit liefert.
    
    Konstruiert ein neu zugewiesenesCharacterObjekt, das den angegebenen char值。
    Parameter
    value - Der Wert, der durch das CharacterObjekt dargestellt wird.
- 方法详细信息
  - valueOf
```
public static Character valueOf(char c)
```
    Gibt einechar值的CharacterWert darstellt. Wenn keine neue Instanz benötigt wird, verwenden Sie diese Methode in der Regel statt des KonstruktorsCharacter, weil diese Methode die Speicher- und Zeitperformance durch Caching häufig angeforderter Werte deutlich verbessert. Diese Methode speichert immer WerteCharacter(char)im Bereich'\u0000'至'\u007F'im Cache und kann weitere Werte außerhalb dieses Bereichs speichern.
    Parameter
    c- char-Wert. Die Ergebnis-Instanz, die
    Characterdarstellt c。 Verfügbar ab Version: 1.5
  - charValue
```
public char charValue()
```
    Gibt den Wert diesesCharacterObjekts zurück.
    Ergebnis Der primitive Wert, den dieses Objekt darstellt
    char.
  - hashCode
```
public int hashCode()
```
    Gibt den Hashcode diesesCharacterObjekts zurück. Er entspricht dem Ergebnis des Aufrufs voncharValue().
    Überschreibt:
    hashCode类 Object
    Ergebnis Der Hashcode-Wert dieses
    CharacterObjekts. Siehe auch:
    Object.equals(java.lang.Object),System.identityHashCode(java.lang.Object)
  - hashCode
```
public static int hashCode(char value)
```
    Gibt den Hashcode descharWerts zurück. Er ist kompatibel mitCharacter.hashCode().
    Parameter
    value - Der charWert, für den der Hashcode zurückgegeben wird. Ergebnis
    charDer Hashcode-Wert des
  - equals
```
public boolean equals(Object obj)
```
    equalsnullVergleicht dieses Objekt mit dem angegebenen Objekt. Das Ergebnis istCharacter, genau dann, wenn das Argument nichttrue ist und einchar值。
    Wert wie dieses Objekt darstellt.
    equals在类 Object
    in der Klasse
    objParameter
    true- Das Objekt, mit dem verglichen wird. Ergebnisfalse, wenn die Objekte gleich sind. Andernfalls
    Object.hashCode(). Siehe auch:HashMap
  - toString
```
public String toString()
```
    toStringCharacter值的StringObjekt zurück, das diesencharDurch diesen dargestellten WertCharacter对象。
    Überschreibt:
    toString在类 Object
    Ergebnis Die String-Darstellung dieses Objekts.
  - toString
```
public static String toString(char c)
```
    Gibt daschar的StringObjekt darstellt. Das Ergebnis ist eine Zeichenkette der Länge 1, die nur aus dem angegebenenchar 。
    API-Hinweis: Diese Methode verarbeitet keine supplementary characters . Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die Methode
    toString(int). Parameter
    c - 要转换的 char
    Ergebnis Die String-Darstellung des angegebenen
    char的字符串表示 char
    toString
  - toString
```
public static String toString(int codePoint)
```
    -Objekt zurück, das das angegebene Zeichen (Unicode-Codepunkt) darstellt. Das Ergebnis ist eine Zeichenkette der Länge 1 oder 2, die nur aus dem angegebenenStringbesteht.codePoint 。
    - Der zu konvertierende
    codePoint - 要转换的 codePoint
    Ausnahme
    codePoint的字符串表示 codePoint
    kein valid Unicode code point ist. Seit Version: 11
    IllegalArgumentException - 如果指定的 codePointBestimmt, ob der angegebene Codepunkt ein gültiger Unicode code point value ist.
  - isValidCodePoint
```
public static boolean isValidCodePoint(int codePoint)
```
    - Der zu prüfende Unicode-Codepunkt Ergebnis
    true, wenn der angegebene Codepunktwert zwischen
    codePointund
    trueliegt; andernfallsMIN_CODE_POINTfalse. Seit Version: 1.5MAX_CODE_POINTisBmpCodePointfalseBestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) in der Basic Multilingual Plane (BMP) liegt. Diese Codepunkte lassen sich mit einem einzelnen
  - isBmpCodePoint
```
public static boolean isBmpCodePoint(int codePoint)
```
    Parameterchar- Das zu prüfende Zeichen (Unicode-Codepunkt) Ergebnis
    true, wenn das angegebene Zeichen (Unicode-Codepunkt) in der
    codePointBMP liegt; andernfalls false.
    trueWenn der angegebene Codepunkt zwischenMIN_VALUEundMAX_VALUEliegt, andernfallsfalse. Seit Version: 1.7
  - isSupplementaryCodePoint
```
public static boolean isSupplementaryCodePoint(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepunkt) im Bereich der supplementary characters liegt.
    Parameter
    codePoint- Das zu prüfende Zeichen (Unicode-Codepunkt). Ergebnis
    trueWenn der angegebene Codepunkt zwischenMIN_SUPPLEMENTARY_CODE_POINTundMAX_CODE_POINTliegt, andernfallsfalse. Seit Version: 1.5
  - isHighSurrogate
```
public static boolean isHighSurrogate(char ch)
```
    Prüft, ob der angegebenecharWert ein Unicode high-surrogate code unit ist (auch leading surrogate code unit genannt). Diese Werte stellen selbst kein Zeichen dar, werden aber in der UTF-16-Kodierung zur Darstellung von supplementary characters verwendet.
    
    Parameter
    ch - 要测试的 charWert. Ergebnis
    true如果charWert zwischenMIN_HIGH_SURROGATEundMAX_HIGH_SURROGATEliegt, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    isLowSurrogate(char),Character.UnicodeBlock.of(int)
  - isLowSurrogate
```
public static boolean isLowSurrogate(char ch)
```
    Prüft, ob der angegebenecharWert ein Unicode low-surrogate code unit ist (auch trailing surrogate code unit genannt). Diese Werte stellen selbst kein Zeichen dar, werden aber in der UTF-16-Kodierung zur Darstellung von supplementary characters verwendet.
    
    Parameter
    ch - Der zu prüfende Wert char. Ergebnis
    true如果charWert zwischenMIN_LOW_SURROGATEundMAX_LOW_SURROGATEliegt, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    isHighSurrogate(char)
  - isSurrogate
```
public static boolean isSurrogate(char ch)
```
    Prüft, ob der angegebenecharWert eine Unicode-Surrogate-Codeeinheit ist. Diese Werte stellen selbst kein Zeichen dar, werden aber in der UTF-16-Kodierung zur Darstellung von supplementary characters verwendet.
    Ein char-Wert ist eine Surrogate-Codeeinheit, wenn er eine low-surrogate code unit oder eine high-surrogate code unit ist.
    
    Parameter
    ch - 要测试的 charWert. Ergebnis
    true如果charder Wert zwischenMIN_SURROGATEundMAX_SURROGATEliegt, andernfalls falschfalse. Seit Version: 1.7
  - isSurrogatePair
```
public static boolean isSurrogatePair(char high,
                                      char low)
```
    Prüft, ob das angegebenecharWertepaar ein gültiges Unicode surrogate pair ist. Diese Methode entspricht dem Ausdruck:
    
    isHighSurrogate(high) && isLowSurrogate(low)
    Parameter
    high- der zu testende hohe Surrogat-Codepunkt
    low- der zu testende niedrige Surrogat-Codepunkt. Ergebnis
    truewahr, wenn der angegebene hohe Surrogatwert und der niedrige Surrogat-Codepunkt ein gültiges Surrogatpaar darstellen, andernfalls falschfalse. Seit Version: 1.5
  - charCount
```
public static int charCount(int codePoint)
```
    Ermittelt die Anzahl dercharWerte, die zur Darstellung des angegebenen Zeichens (Unicode-Codepunkt) nötig sind. Ist das angegebene Zeichen größer oder gleich 0x10000, gibt die Methode 2 zurück. Andernfalls gibt die Methode 1 zurück. Diese Methode prüft das angegebene Zeichen nicht als gültigen Unicode-Codepunkt. Bei Bedarf muss der Aufrufer den Zeichenwert mit
    isValidCodePointprüfen.
    
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Ergebnis 2, wenn das Zeichen ein gültiges ergänzendes Zeichen ist, andernfalls 1. Seit Version: 1.5 Siehe auch:
    isSupplementaryCodePoint(int)
  - toCodePoint
```
public static int toCodePoint(char high,
                              char low)
```
    Wandelt das angegebene Surrogatpaar in seinen ergänzenden Codepunktwert um. Diese Methode prüft das angegebene Surrogatpaar nicht. Bei Bedarf muss der Aufrufer es mitisSurrogatePairprüfen.
    Parameter
    high- die hohe Surrogat-Codeeinheit
    low- die niedrige Surrogat-Codeeinheit. Ergebnis der ergänzende Codepunkt, der aus dem angegebenen Surrogatpaar besteht. Seit Version: 1.5
  - codePointAt
```
public static int codePointAt(CharSequence seq,
                              int index)
```
    Gibt den Codepunkt an der angegebenen Position vonCharSequencezurück. Liegt der Wert an dercharangegebenen PositionCharSequenceim Bereich hoher Surrogate, ist der folgende Index kleiner als die LängeCharSequence ，并且charder Wert am folgenden Index liegt im Bereich niedriger Surrogate, gibt die Methode den zu diesem Surrogatpaar gehörenden Codepunkt zurück. Andernfalls gibt sie denchar值。
    Parameter
    seq - ein Array von charWerten (Unicode-Codeeinheiten)
    index - 要转换的 charWerte (Unicode-Codeeinheiten) seq
    Ergebnis Der Unicode-Codepunkt am angegebenen Index Ausnahme
    NullPointerException - 如果 seqleer ist.
    IndexOutOfBoundsException - 如果值 indexnegativ ist oder nicht kleiner alsseq.length()ist. Seit Version: 1.5
  - codePointAt
```
public static int codePointAt(char[] a,
                              int index)
```
    Gibtcharden Codepunkt am angegebenen Index des Arrays zurück. Wennchar数组中给定索引处的charWert am angegebenen Index im Array im hohen Surrogate-Bereich liegt, der folgende Index kleiner alschardie Länge des Arrays ist und dercharWert am folgenden Index im niedrigen Surrogate-Bereich liegt, gibt die Methode den ergänzenden Codepunkt zurück, der diesem Surrogate-Paar entspricht. Andernfalls gibt sie denchar值。
    Parameter
    a - Array char
    
    index - 要转换的 char数组中 charsoll. Der char
    Wert (Unicode-Codeeinheit) im Array
    NullPointerException - 如果 aleer ist.
    IndexOutOfBoundsException - 如果值 indexnegativ ist oder nicht kleiner als chardie Länge des Arrays ist. Seit Version: 1.5
  - codePointAt
```
public static int codePointAt(char[] a,
                              int index,
                              int limit)
```
    Gibtcharden Codepunkt am angegebenen Index des Arrays zurück, wobei nurindex小于limitArray-Elemente verwendet werden. Wennchar数组中给定索引处的charWert am angegebenen Index im Array im hohen Surrogate-Bereich liegt, der folgende Index kleiner alslimit ist und dercharWert am folgenden Index im niedrigen Surrogate-Bereich liegt, gibt die Methode den ergänzenden Codepunkt zurück, der diesem Surrogate-Paar entspricht. Andernfalls gibt sie denchar值。
    Parameter
    a - charArray
    index - 要转换的 char数组中 charWert (Unicode-Codeeinheit) der char
    
    limit - Kann im charIndex nach dem letzten Array-Element, das im Array verwendet werden kann Ergebnis Unicode-Codepunkt am gegebenen Index Ausnahme
    NullPointerException - 如果 aleer ist.
    IndexOutOfBoundsException - 如果 index参数为负或不小于 limitParameter ist, oder limitParameter negativ ist oder größer als charLänge des Arrays. Seit Version: 1.5
  - codePointBefore
```
public static int codePointBefore(CharSequence seq,
                                  int index)
```
    Gibt zurückCharSequenceden Codepunkt vor dem gegebenen Index. Wennchar在值(index - 1)在CharSequencesich im niedrigen Surrogatbereich befindet, (index - 2)不为负，并且char在值(index - 2)在CharSequencesich im hohen Surrogatbereich befindet, wird der dem Surrogatpaar entsprechende ergänzende Codepunkt zurückgegeben. Andernfalls wird zurückgegebenchar值(index - 1) 。
    Parameter
    seq - CharSequenceBeispiel
    index- Index nach dem Codepunkt, der zurückgegeben werden soll Ergebnis Unicode-Codepunktwert vor dem gegebenen Index. Ausnahme
    NullPointerException - 如果 seqleer ist.
    IndexOutOfBoundsException - 如果 indexParameter kleiner als 1 oder größer alsseq.length()ist. Seit Version: 1.5
  - codePointBefore
```
public static int codePointBefore(char[] a,
                                  int index)
```
    Gibt zurückcharden Codepunkt vor dem gegebenen Index des Arrays. Wennchar在值(index - 1)中char阵列是在低代理项范围， (index - 2)不为负，并且char在值(index - 2)中charWenn sich das Array im hohen Surrogate-Bereich befindet, gibt die Methode das ergänzende Codepunktpaar zurück. Andernfalls wird derchar值(index - 1) 。
    Parameter
    a - charArray
    index- Der Index, vor dem der Codepunkt zurückgegeben werden soll. Ergebnis Der Unicode-Codepunktwert vor dem gegebenen Index. Ausnahme
    NullPointerException - 如果 aleer ist.
    IndexOutOfBoundsException - 如果 indexParameter kleiner als 1 oder größer als die charLänge des Arrays ist. Seit Version: 1.5
  - codePointBefore
```
public static int codePointBefore(char[] a,
                                  int index,
                                  int start)
```
    Gibt dencharCodepunkt vor dem gegebenen Index des Arrays zurück, wobei nurindex大于或等于startsind. Wennchar在值(index - 1)中char阵列是在低代理项范围， (index - 2)不小于start ，并且char在值(index - 2)中charArray im hohen Surrogate-Bereich liegt, gibt die Methode den ergänzenden Codepunkt dieses Surrogate-Paars zurück. Andernfalls wird derchar值(index - 1) 。
    Parameter
    a - charArray
    index- Der Index, vor dem der Codepunkt zurückgegeben werden soll
    start - charDer Index des ersten Array-Elements im Array char
    Ergebnis Der Unicode-Codepunktwert vor dem gegebenen Index. Ausnahme
    NullPointerException - 如果 aleer ist.
    IndexOutOfBoundsException - 如果 indexParameter nicht größer als der startParameter oder größer als die char数组的长度，或者 start参数为负或不小于 chardie Länge des Arrays. Seit Version: 1.5
  - highSurrogate
```
public static char highSurrogate(int codePoint)
```
    Gibt die führende Ersatzzeichen-Einheit (ein high surrogate code unit) des surrogate pair zurück, das das angegebene ergänzende Zeichen (Unicode-Codepunkt) in UTF-16-Kodierung darstellt. Wenn das angegebene Zeichen kein supplementary character ist, wird ein nicht definierter Wert zurückgegeben char. Wenn
    isSupplementaryCodePoint(x)是truedann sindisHighSurrogate (highSurrogate(x))undtoCodePoint (highSurrogate(x), lowSurrogate (x)) == x也总是true 。
    
    Parameter
    codePoint- Ergänzungszeichen (Unicode-Codepunkt) Ergebnis Das führende Surrogate-Code-Unit, das das Zeichen in der UTF-16-Kodierung darstellt. Verfügbar seit Version: 1.7
  - lowSurrogate
```
public static char lowSurrogate(int codePoint)
```
    Gibt das nachfolgende Surrogate (ein low surrogate code unit des surrogate pair) zurück, das das angegebene Ergänzungszeichen (Unicode-Codepunkt) in der UTF-16-Kodierung darstellt. Wenn das angegebene Zeichen kein supplementary character ist, ist der Rückgabewert nicht definiert char. Wenn
    isSupplementaryCodePoint(x)是true, dann istisLowSurrogate (lowSurrogate(x))undtoCodePoint ( highSurrogate (x), lowSurrogate(x)) == x也总是true 。
    
    Parameter
    codePoint- Ergänzendes Zeichen (Unicode-Codepunkt) Ergebnis Nachgestellte Codeeinheit des Surrogats zur Darstellung eines Zeichens in UTF-16-Kodierung Seit Version: 1.7
  - toChars
```
public static int toChars(int codePoint,
                          char[] dst,
                          int dstIndex)
```
    Konvertiert das angegebene Zeichen (Unicode-Codepunkt) in seine UTF-16-Darstellung. Ist der angegebene Codepunkt ein BMP-Wert (Basic Multilingual Plane oder Plane 0), wird derselbe Wert indst[dstIndex]gespeichert und 1 zurückgegeben. Ist der angegebene Codepunkt ein ergänzendes Zeichen, werden seine Surrogat-Werte indst[dstIndex] (high-surrogate) unddst[dstIndex+1](low-surrogate) gespeichert und 2 zurückgegeben.
    Parameter
    codePoint- Das zu konvertierende Zeichen (Unicode-Codepunkt).
    dst - Array von char , in der codePointder UTF-16-Wert gespeichert wird.
    dstIndex - Der Startindex des Arrays, das die konvertierten Werte dstspeichert. Rückgabewert 1, wenn der Codepunkt ein BMP-Codepunkt ist. 2, wenn der Codepunkt ein ergänzender Codepunkt ist. Ausnahmen
    IllegalArgumentException - 如果指定的 codePointkein gültiger Unicode-Codepunkt ist.
    NullPointerException - 如果指定的 dstleer ist.
    IndexOutOfBoundsException - 如果dstIndexnegativ ist oder nicht kleiner alsdst.length ，或者如果dst在dstIndexnicht genügend Array-Elemente vorhanden sind, um die erzeugtencharWerte zu speichern. (WenndstIndex等于dst.length-1ist und das angegebenecodePointein ergänzendes Zeichen ist, werden hohe Surrogatwerte nicht indst[dstIndex]gespeichert.) Seit Version: 1.5
  - toChars
```
public static char[] toChars(int codePoint)
```
    Konvertiert das angegebene Zeichen (Unicode-Codepoint) in seine UTF-16-Darstellung, die imcharArray gespeichert wird. Wenn der angegebene Codepoint ein BMP-Wert (Basic Multilingual Plane oder Plane 0) ist, hat das erzeugtecharArray denselben Wert wiecodePoint. Wenn der angegebene Codepoint ein ergänzender Codepoint ist, enthält das erzeugtecharArray das entsprechende Surrogatpaar.
    Parameter
    codePoint- Unicode-Codepoint Ergebnis Das
    codePointArray mit der UTF-16-Darstellung von char. Ausnahme
    IllegalArgumentException - 如果指定的 codePointkein gültiger Unicode-Codepoint ist. Seit Version: 1.5
  - codePointCount
```
public static int codePointCount(CharSequence seq,
                                 int beginIndex,
                                 int endIndex)
```
    Gibt die Anzahl der Unicode-Codepoints im Textbereich der angegebenen char-Sequenz zurück. Der Textbereich beginnt am angegebenenbeginIndex und erstreckt sich bischaram IndexendIndex - 1. Die Länge des Textbereichs (inchar s) beträgt daherendIndex-beginIndex. Ungepaarte Surrogate im Textbereich zählen als je ein Codepoint.
    Parameter
    seq- Zeichensequenz
    beginIndex - Der Index des ersten chardes Textbereichs.
    endIndex - Der Index nach dem letzten chardes Textbereichs. Ergebnis Die Anzahl der Unicode-Codepoints im angegebenen Textbereich Ausnahme
    NullPointerException - 如果 seqnull ist.
    IndexOutOfBoundsException - 如果 beginIndex为负数，或者 endIndexgrößer als die Länge der gegebenen Sequenz ist, oder beginIndexgrößer als endIndexist. Seit Version: 1.5
  - codePointCount
```
public static int codePointCount(char[] a,
                                 int offset,
                                 int count)
```
    Gibt zurückchardie Anzahl der Unicode-Codepunkte im Teilarray des Array-Parameters.offsetDer Parameter ist der erste Index des Teilarrays,charder count参数指定char s chardie Länge des Arrays an. Ungepaarte Surrogate im Teilarray zählen als je ein Codepunkt.
    Parameter
    a - charArray
    offset - der erste Index im gegebenen charArray char-
    count - chardie Länge des Arrays. Rückgabewert Die Anzahl der Unicode-Codepunkte im angegebenen Teilarray. Ausnahme
    NullPointerException - 如果 aleer ist.
    IndexOutOfBoundsException - 如果 offsetoder count为负数，或者 offset + countgrößer als die Länge des gegebenen Arrays ist. Seit: 1.5
  - offsetByCodePoints
```
public static int offsetByCodePoints(CharSequence seq,
                                     int index,
                                     int codePointOffset)
```
    Gibt den Index in der gegebenen char-Sequenz zurück, der vom gegebenenindex偏移codePointOffsetCodepunkte versetzt ist.index和codePointOffsetUngepaarte Surrogate im von
    gegebenen Textbereich zählen als je ein Codepunkt.
    seqParameter
    index- die char-Sequenz
    codePointOffset- der zu versetzende Index
    NullPointerException - 如果 seq- wenn
    IndexOutOfBoundsException - 如果 index- wenn codePointOffsetnegativ oder größer als die Länge der char-Sequenz ist, oder wenn indexpositiv ist und das Teilarray ab index少于 codePointOffset代码点，或者如果 codePointOffsetnegativ ist und indexder vorherige Unter- indexkleiner als der absolute Wert codePointOffsetder Codepunkte ist. Seit Version: 1.5
  - offsetByCodePoints
```
public static int offsetByCodePoints(char[] a,
                                     int start,
                                     int count,
                                     int index,
                                     int codePointOffset)
```
    Gibt den Index innerhalb des gegebenencharTeilarrays zurück, der um den gegebenen Versatzindex由codePointOffsetCodepunkte verschoben ist.start和count参数指定charTeilbereich des Arrays an. Unpaarierte Surrogate im Textbereich zwischenindex和codePointOffsetzählen als je ein Codepunkt.
    Parameter
    a - charArray
    start - Index des ersten chardes Teilarrays
    count - charLänge des Arrays
    index- Der zu verschiebende Index
    codePointOffset- Der Versatz in Codepunkten Ergebnis Der Index im Teilarray Ausnahme
    NullPointerException - 如果 anull ist.
    IndexOutOfBoundsException - 如果 startoder countnegativ ist, oder wenn start + countgrößer als die Länge des gegebenen Arrays ist, oder index小于 startoder größer ist, dann start + count , oder codePointOffsetpositiv ist und der Textbereich, der bei indexbeginnt und bei start + count - 1endet, weniger als codePointOffset代码点，或者如果 codePointOffsetnegativ ist und der Textbereich, der bei start beginnt und bei index - 1endet, weniger als der absolute Wert von codePointOffsetCodepunkten hat. Seit Version: 1.5
  - isLowerCase
```
public static boolean isLowerCase(char ch)
```
    Prüft, ob das angegebene Zeichen ein Kleinbuchstabe ist. Ein
    Character.getType(ch)Zeichen ist ein Kleinbuchstabe, wenn seine allgemeine KategorieLOWERCASE_LETTERist oder es das von Unicode definierte Beitragsattribut Other_Lowercase besitzt.
    Hier sind Beispiele für Kleinbuchstaben:
    
    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 '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6' '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE' '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6' '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
    
    Viele andere Unicode-Zeichen sind ebenfalls Kleinbuchstaben.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) dieisLowerCase(int)Methode.
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein Kleinbuchstabe ist, andernfallsfalsefalse. Siehe auch:
    isLowerCase(char),isTitleCase(char),toLowerCase(char),getType(char)
  - isLowerCase
```
public static boolean isLowerCase(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepunkt) ein Kleinbuchstabe ist. Ein Zeichen ist ein Kleinbuchstabe, wenn seine allgemeine Kategorie (bereitgestellt von
    getType(codePoint)提供）为LOWERCASE_LETTERist oder es das von Unicode definierte Beitragsattribut Other_Lowercase besitzt.
    Hier sind Beispiele für Kleinbuchstaben:
    
    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 '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6' '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE' '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6' '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
    
    Viele andere Unicode-Zeichen sind ebenfalls Kleinbuchstaben.
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein Kleinbuchstabe ist, andernfallsfalsefalse. Seit Version: 1.5 Siehe auch:
    isLowerCase(int),isTitleCase(int),toLowerCase(int),getType(int)
  - isUpperCase
```
public static boolean isUpperCase(char ch)
```
    Prüft, ob das angegebene Zeichen ein Großbuchstabe ist. Ein Zeichen ist ein Großbuchstabe, wenn seine allgemeine Kategorie, bereitgestellt von
    Character.getType(ch) ，是UPPERCASE_LETTERist. Oder es besitzt das von Unicode definierte Beitragsattribut Other_Uppercase.
    Hier sind Beispiele für Großbuchstaben:
    
    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 '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7' '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF' '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8' '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
    
    Viele andere Unicode-Zeichen sind ebenfalls Großbuchstaben.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) dieisUpperCase(int)Methode.
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein Großbuchstabe ist, andernfallsfalsefalse. Seit Version: 1.0 Siehe auch:
    isLowerCase(char),isTitleCase(char),toUpperCase(char),getType(char)
  - isUpperCase
```
public static boolean isUpperCase(int codePoint)
```
    Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Großbuchstabe ist. Ein Zeichen ist ein Großbuchstabe, wenn seine allgemeine Kategorie (von
    getType(codePoint)提供）为UPPERCASE_LETTERist oder es die von der Unicode-Definition bereitgestellte Eigenschaft Other_Uppercase besitzt.
    Hier sind Beispiele für Großbuchstaben:
    
    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 '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7' '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF' '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8' '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
    
    Viele andere Unicode-Zeichen sind ebenfalls Großbuchstaben.
    Parameter
    codePoint- Das zu testende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein Großbuchstabe ist, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    isLowerCase(int),isTitleCase(int),toUpperCase(int),getType(int)
  - isTitleCase
```
public static boolean isTitleCase(char ch)
```
    Bestimmt, ob das angegebene Zeichen ein Titelzeichen ist. Ein Zeichen ist ein Titelzeichen, wenn seine allgemeine Kategorie, geliefert durch
    Character.getType(ch) ，是TITLECASE_LETTER 。
    Einige Zeichen sehen wie ein Paar lateinischer Buchstaben aus. Es gibt zum Beispiel einen Großbuchstaben, der wie „LJ" aussieht, und einen entsprechenden Kleinbuchstaben, der wie „lj" aussieht. Eine dritte Form, die wie „Lj" aussieht, ist die passende Form, wenn ein Wort mit Anfangsgroßbuchstaben in Kleinbuchstaben dargestellt wird, wie in Buchtiteln.
    Dies sind einige Unicode-Zeichen, für die diese Methodetruezurückgibt:
    
    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
    Viele andere Unicode-Zeichen sind ebenfalls Titelzeichen.
    Hinweis: Diese Methode kann supplementary characters nicht verarbeiten. Verwenden Sie die MethodeisTitleCase(int), um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen.
    Parameter
    ch- Das zu testende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein Titelzeichen ist, andernfallsfalse. Seit Version: 1.0.2 Siehe auch:
    isLowerCase(char),isUpperCase(char),toTitleCase(char),getType(char)
  - isTitleCase
```
public static boolean isTitleCase(int codePoint)
```
    Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) ein Titelzeichen ist. Ein Zeichen ist ein Titelzeichen, wenn seine allgemeine Kategorie, geliefert durch
    getType(codePoint) ，是TITLECASE_LETTER 。
    Dies sind einige Unicode-Zeichen, für die diese Methode
    zurückgibt:trueViele andere Unicode-Zeichen sind ebenfalls Titelzeichen.
    
    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
    Viele andere Unicode-Zeichen sind ebenfalls Titelzeichen.
    Parameter
    codePoint- Das zu prüfende Zeichen (Unicode-Codepunkt). Ergebnis
    trueWahr, wenn das Zeichen ein Titelzeichen ist. Sonstfalse. Seit: 1.5 Siehe auch:
    isLowerCase(int),isUpperCase(int),toTitleCase(int),getType(int)
  - isDigit
```
public static boolean isDigit(char ch)
```
    Prüft, ob das angegebene Zeichen eine Ziffer ist. Ein Zeichen ist eine Ziffer, wenn sein allgemeiner Kategorietyp, geliefert von
    Character.getType(ch) ，是DECIMAL_DIGIT_NUMBER 。
    Einige Unicode-Zeichenbereiche mit Ziffern:
    
    '\u0030'到'\u0039' , ISO-LATIN-1-Ziffern ( '0'到'9' ）
    
    '\u0660'到'\u0669', arabisch-indische Ziffern
    
    '\u06F0'到'\u06F9', erweiterte arabisch-indische Ziffern
    
    '\u0966'到'\u096F', Devanagari-Ziffern
    
    '\uFF10'至'\uFF19' ， '\uFF19'数字
    Viele andere Zeichenbereiche enthalten ebenfalls Ziffern. Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen, verwenden Sie die Methode
    isDigit(int).
    Parameter
    ch- Das zu prüfende Zeichen. Ergebnis
    trueWahr, wenn das Zeichen eine Ziffer ist. Sonstfalse. Siehe auch:
    digit(char, int),forDigit(int, int),getType(char)
  - isDigit
```
public static boolean isDigit(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepunkt) eine Ziffer ist. Ein Zeichen ist eine Ziffer, wenn sein allgemeiner Kategorietyp, geliefert von
    getType(codePoint) ，是DECIMAL_DIGIT_NUMBER 。
    Einige Unicode-Zeichenbereiche mit Ziffern:
    
    '\u0030'到'\u0039' , ISO-LATIN-1-Ziffern ( '0'到'9' ）
    
    '\u0660'到'\u0669', Arabisch-indische Ziffern
    
    '\u06F0'到'\u06F9', erweiterte arabisch-indische Ziffern
    
    '\u0966'到'\u096F', Devanagari-Ziffern
    
    '\uFF10'到'\uFF19', vollbreite Ziffern
    Viele andere Zeichenbereiche enthalten ebenfalls Ziffern.
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Ergebnis
    truetrue, wenn das Zeichen eine Ziffer ist, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    forDigit(int, int),getType(int)
  - isDefined
```
public static boolean isDefined(char ch)
```
    Bestimmt, ob ein Zeichen in Unicode definiert ist. Ein Zeichen ist definiert, wenn mindestens eine der folgenden Bedingungen erfüllt ist:
    Es hat einen Eintrag in der UnicodeData-Datei.
    Es hat einen Wert in einem Bereich, der von der UnicodeData-Datei definiert wird.
    Hinweis: Diese Methode kann supplementary characters nicht verarbeiten. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die MethodeisDefined(int).
    Parameter
    ch- das zu testende Zeichen. Ergebnis
    truetrue, wenn das Zeichen in Unicode eine definierte Bedeutung hat, andernfallsfalse. Seit Version: 1.0.2 Siehe auch:
    isDigit(char),isLetter(char),isLetterOrDigit(char),isLowerCase(char),isTitleCase(char),isUpperCase(char)
  - isDefined
```
public static boolean isDefined(int codePoint)
```
    Bestimmt, ob ein Zeichen in Unicode definiert ist (Unicode-Codepunkt). Ein Zeichen ist definiert, wenn mindestens eine der folgenden Bedingungen erfüllt ist:
    Es hat einen Eintrag in der UnicodeData-Datei.
    Es hat einen Wert in einem Bereich, der von der UnicodeData-Datei definiert wird.
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Ergebnis
    truetrue, wenn das Zeichen in Unicode eine definierte Bedeutung hat, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    isDigit(int),isLetter(int),isLetterOrDigit(int),isLowerCase(int),isTitleCase(int),isUpperCase(int)
  - isLetter
```
public static boolean isLetter(char ch)
```
    Prüft, ob das angegebene Zeichen ein Buchstabe ist. Ein Zeichen gilt als Buchstabe, wenn sein allgemeiner Kategorietyp (bereitgestellt von
    Character.getType(ch)) einer der folgenden Zeichentypen ist:
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    Nicht alle Buchstaben haben Groß- und Kleinschreibung. Viele Zeichen sind Buchstaben, aber weder Großbuchstaben noch Kleinbuchstaben noch Titelbuchstaben. Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen, verwenden Sie die
    isLetter(int)Methode.
    Parameter
    ch- Das zu testende Zeichen. Rückgabewert
    trueWenn das Zeichen ein Buchstabe ist, gibt die Funktion wahr zurück.falseAndernfalls gibt sie falsch zurück. Siehe auch:
    isDigit(char),isJavaIdentifierStart(char),isJavaLetter(char),isJavaLetterOrDigit(char),isLetterOrDigit(char),isLowerCase(char),isTitleCase(char),isUnicodeIdentifierStart(char),isUpperCase(char)
  - isLetter
```
public static boolean isLetter(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepunkt) ein Buchstabe ist. Ein Zeichen gilt als Buchstabe, wenn sein allgemeiner Kategorietyp (bereitgestellt von
    getType(codePoint)) einer der folgenden Zeichentypen ist:
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    Nicht alle Buchstaben haben eine Groß-/Kleinschreibung. Viele Zeichen sind Buchstaben, aber weder Großbuchstaben, noch Kleinbuchstaben, noch Titelbuchstaben.
    Parameter
    codePoint- Das zu prüfende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein Buchstabe ist, andernfallsfalsefalse. Seit Version: 1.5 Siehe auch:
    isDigit(int),isJavaIdentifierStart(int),isLetterOrDigit(int),isLowerCase(int),isTitleCase(int),isUnicodeIdentifierStart(int),isUpperCase(int)
  - isLetterOrDigit
```
public static boolean isLetterOrDigit(char ch)
```
    Bestimmt, ob das angegebene Zeichen ein Buchstabe oder eine Ziffer ist. Ein Zeichen gilt als Buchstabe oder Ziffer, wenn es ein Buchstabe oder eine Ziffer ist.
    Character.isLetter(char ch)oder Character.isDigit(char ch)回报true的字符。
    Hinweis: Diese Methode verarbeitet keine ergänzenden Zeichen. Für alle Unicode-Zeichen einschließlich der ergänzenden verwenden SieisLetterOrDigit(int)Methode.
    
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein Buchstabe oder eine Ziffer ist, andernfallsfalsefalse. Seit Version: 1.0.2 Siehe auch:
    isDigit(char),isJavaIdentifierPart(char),isJavaLetter(char),isJavaLetterOrDigit(char),isLetter(char),isUnicodeIdentifierPart(char)
  - isLetterOrDigit
```
public static boolean isLetterOrDigit(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepoint) ein Buchstabe oder eine Ziffer ist. Ein Zeichen gilt als Buchstabe oder Ziffer, wenn es einer davon ist.
    isLetter(codePoint)oder isDigit(codePoint)回报true的字符。
    
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepoint). Ergebnis
    truewenn das Zeichen ein Buchstabe oder eine Ziffer ist, andernfallsfalse。 Seit Version: 1.5 Siehe auch:
    isDigit(int),isJavaIdentifierPart(int),isLetter(int),isUnicodeIdentifierPart(int)
  - isJavaLetter
```
@Deprecated(since="1.1")
public static boolean isJavaLetter(char ch)
```
    Veraltet. Ersetzt durch isJavaIdentifierStart(char).
    Prüft, ob das angegebene Zeichen als erstes Zeichen eines Java-Bezeichners erlaubt ist. Ein Zeichen startet einen Java-Bezeichner genau dann, wenn eine der folgenden Bedingungen erfüllt ist:
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER
    
    ch是货币符号（例如'$' ）
    
    ch是连接标点字符（例如'_' ）。
    Parameter
    ch- Das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen einen Java-Bezeichner starten darf; andernfallsfalsefalse. Seit Version: 1.0.2 Siehe auch:
    isJavaLetterOrDigit(char),isJavaIdentifierStart(char),isJavaIdentifierPart(char),isLetter(char)，isLetterOrDigit(char)，isUnicodeIdentifierStart(char)
  - isJavaLetterOrDigit
```
@Deprecated(since="1.1")
public static boolean isJavaLetterOrDigit(char ch)
```
    Veraltet. Ersetzt durch isJavaIdentifierPart(char).
    Prüft, ob das angegebene Zeichen Teil eines Java-Bezeichners sein darf, aber nicht das erste Zeichen. Ein Zeichen ist genau dann Teil eines Java-Bezeichners, wenn eine der folgenden Bedingungen erfüllt ist:
    Es ist ein Buchstabe.
    Es ist ein Währungssymbol (zum Beispiel'$' ）
    Es ist ein verbindendes Satzzeichen (zum Beispiel'_' ）
    Es ist eine Ziffer.
    Es ist ein alphanumerisches Zeichen (zum Beispiel römische Zahlzeichen).
    Es ist ein kombinierendes Zeichen.
    Es ist ein Zeichen ohne Eigenvorschub.
    
    isIdentifierIgnorableDas Zeichen lieferttrue 。
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen Teil eines Java-Bezeichners sein darf, sonstfalse. Seit: 1.0.2 Siehe auch:
    isJavaLetter(char)，isJavaIdentifierStart(char)，isJavaIdentifierPart(char)，isLetter(char)，isLetterOrDigit(char)，isUnicodeIdentifierPart(char)，isIdentifierIgnorable(char)
  - isAlphabetic
```
public static boolean isAlphabetic(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepoint) ein Buchstabe ist. Ein Zeichen gilt als Buchstabe, wenn seine allgemeine Kategorie (geliefert von
    getType(codePoint)eine der folgenden ist:
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    
    LETTER_NUMBER
    Oder es hat das von der Unicode-Definition bereitgestellte Attribut Other_Alphabetic.
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepoint). Rückgabewert
    truetrue, wenn das Zeichen ein Unicode-Buchstabe ist, sonst false. Seit: 1.7
  - isIdeographic
```
public static boolean isIdeographic(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepoint) ein nach dem Unicode-Standard definiertes CJKV-Ideogramm ist (chinesisch, japanisch, koreanisch und vietnamesisch).
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepoint). Rückgabewert
    truetrue, wenn das Zeichen ein Unicode-Ideogramm ist, sonst false. Seit: 1.7
  - isJavaIdentifierStart
```
public static boolean isJavaIdentifierStart(char ch)
```
    Bestimmt, ob das angegebene Zeichen als erstes Zeichen eines Java-Bezeichners erlaubt ist. Ein Zeichen startet einen Java-Bezeichner nur, wenn eine der folgenden Bedingungen erfüllt ist:
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER
    
    ch是货币符号（例如'$' ）
    
    ch是连接标点字符（例如'_' ）。
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die MethodeisJavaIdentifierStart(int).
    Parameter
    ch- Das zu testende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen einen Java-Bezeichner starten darf, sonstfalse. Seit Version: 1.1 Siehe auch:
    isJavaIdentifierPart(char),isLetter(char),isUnicodeIdentifierStart(char),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierStart
```
public static boolean isJavaIdentifierStart(int codePoint)
```
    Bestimmt, ob ein Zeichen (Unicode-Codepunkt) als erstes Zeichen eines Java-Bezeichners erlaubt ist. Ein Zeichen startet einen Java-Bezeichner nur, wenn eine der folgenden Bedingungen erfüllt ist:
    
    isLetter(codePoint)返回true
    
    getType(codePoint)返回LETTER_NUMBER
    Das referenzierte Zeichen ist ein Währungssymbol (zum Beispiel'$' ）
    Das referenzierte Zeichen ist ein verbindendes Satzzeichen (zum Beispiel'_' ）。
    Parameter
    codePoint- Das zu testende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen einen Java-Bezeichner starten darf, sonstfalse. Seit Version: 1.5 Siehe auch:
    isJavaIdentifierPart(int),isLetter(int),isUnicodeIdentifierStart(int),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierPart
```
public static boolean isJavaIdentifierPart(char ch)
```
    Bestimmt, ob das angegebene Zeichen Teil eines Java-Bezeichners sein darf, aber nicht das erste Zeichen. Ein Zeichen ist Teil eines Java-Bezeichners, wenn eine der folgenden Bedingungen erfüllt ist:
    Es ist ein Buchstabe
    Es ist ein Währungssymbol (zum Beispiel'$' ）
    Es ist ein verbindendes Satzzeichen (zum Beispiel'_' ）
    Es ist eine Ziffer
    Es ist ein Buchstabe mit Ziffernwert (zum Beispiel ein römisches Zahlzeichen)
    Es ist ein kombinierendes Zeichen
    Es ist ein Zeichen ohne Eigenschaftsabstand
    
    isIdentifierIgnorable回报true的字符
    Hinweis: Diese Methode kann supplementary characters nicht verarbeiten. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die MethodeisJavaIdentifierPart(int).
    Parameter
    ch- das zu prüfende Zeichen. Ergebnis
    truetrue, wenn das Zeichen Teil eines Java-Bezeichners sein darf, andernfallsfalse. Seit Version: 1.1 Siehe auch:
    isIdentifierIgnorable(char),isJavaIdentifierStart(char),isLetterOrDigit(char),isUnicodeIdentifierPart(char),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierPart
```
public static boolean isJavaIdentifierPart(int codePoint)
```
    Prüft, ob ein Zeichen (Unicode-Codepunkt) Teil eines Java-Bezeichners sein darf, aber nicht das erste Zeichen. Ein Zeichen darf Teil eines Java-Bezeichners sein, wenn eine der folgenden Bedingungen erfüllt ist:
    Prüft, ob das angegebene Zeichen als erstes Zeichen eines Unicode-Bezeichners zulässig ist. Ein Zeichen startet einen Unicode-Bezeichner nur, wenn eine der folgenden Bedingungen erfüllt ist:
    Es ist ein Währungssymbol (zum Beispiel'$' ）
    Es ist ein verbindendes Satzzeichen (zum Beispiel'_' ）
    Es ist eine Ziffer
    Es ist ein Buchstabe mit Ziffernwert (zum Beispiel ein römisches Zahlzeichen)
    Es ist ein kombinierendes Zeichen
    Es ist ein Zeichen ohne Eigenschaftsabstand
    
    isIdentifierIgnorable(codePoint)Rückgabetrue的字符
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepunkt). Ergebnis
    truetrue, wenn das Zeichen Teil eines Java-Bezeichners sein darf, andernfallsfalse. Seit Version: 1.5 Siehe auch:
    isIdentifierIgnorable(int),isJavaIdentifierStart(int),isLetterOrDigit(int),isUnicodeIdentifierPart(int),SourceVersion.isIdentifier(CharSequence)
  - isUnicodeIdentifierStart
```
public static boolean isUnicodeIdentifierStart(char ch)
```
    确定指定的字符是否允许作为Unicode标识符中的第一个字符。
    当且仅当满足下列条件之一时，字符才可以启动Unicode标识符：
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER 。
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen, verwenden Sie die MethodeisUnicodeIdentifierStart(int)。
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen einen Unicode-Bezeichner starten darf; andernfallsfalsefalse. Seit Version: 1.1 Siehe auch:
    isJavaIdentifierStart(char)，isLetter(char)，isUnicodeIdentifierPart(char)
  - isUnicodeIdentifierStart
```
public static boolean isUnicodeIdentifierStart(int codePoint)
```
    Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) als erstes Zeichen in einem Unicode-Bezeichner zulässig ist. Ein Zeichen darf genau dann einen Unicode-Bezeichner starten, wenn eine der folgenden Bedingungen erfüllt ist:
    
    isLetter(codePoint)返回true
    
    getType(codePoint)返回LETTER_NUMBER 。
    Parameter
    codePoint- das zu prüfende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen einen Unicode-Bezeichner starten darf; andernfallsfalsefalse. Seit Version: 1.5 Siehe auch:
    isJavaIdentifierStart(int)，isLetter(int)，isUnicodeIdentifierPart(int)
  - isUnicodeIdentifierPart
```
public static boolean isUnicodeIdentifierPart(char ch)
```
    Bestimmt, ob das angegebene Zeichen Teil eines Unicode-Bezeichners sein darf, aber nicht das erste Zeichen. Ein Zeichen darf genau dann Teil eines Unicode-Bezeichners sein, wenn eine der folgenden Aussagen zutrifft:
    Es ist ein Buchstabe.
    Es ist ein verbindendes Satzzeichen (wie'_' ）
    Es ist eine Ziffer.
    Es ist ein alphanumerisches Zeichen (zum Beispiel römische Ziffern).
    Es ist ein kombinierendes Zeichen.
    Es ist ein Zeichen ohne Eigenbreite.
    
    isIdentifierIgnorable返回truedieses Zeichen.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen, verwenden Sie die MethodeisUnicodeIdentifierPart(int)。
    Parameter
    ch- das zu prüfende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen Teil eines Unicode-Bezeichners sein darf; andernfallsfalsefalse. Seit Version: 1.1 Siehe auch:
    isIdentifierIgnorable(char)，isJavaIdentifierPart(char)，isLetterOrDigit(char)，isUnicodeIdentifierStart(char)
  - isUnicodeIdentifierPart
```
public static boolean isUnicodeIdentifierPart(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepoint) Teil eines Unicode-Bezeichners sein kann, aber nicht das erste Zeichen. Ein Zeichen ist genau dann Teil eines Unicode-Bezeichners, wenn eine der folgenden Aussagen zutrifft:
    Es ist ein Buchstabe.
    Es ist ein verbindendes Satzzeichen (wie'_' ）
    Es ist eine Ziffer.
    Es ist eine Ziffern-Buchstaben-Zeichenfolge (zum Beispiel römische Zahlzeichen).
    Es ist ein kombinierendes Zeichen.
    Es ist ein Zeichen ohne Eigenschrittweite.
    
    isIdentifierIgnorableGibt für dieses Zeichen zurücktrue 。
    Parameter
    codePoint- Das zu prüfende Zeichen (Unicode-Codepunkt). Das Ergebnis
    trueDas Zeichen Teil eines Unicode-Bezeichners sein kann, andernfalls false。 Seit Version: 1.5 Siehe auch:
    isIdentifierIgnorable(int),isJavaIdentifierPart(int),isLetterOrDigit(int),isUnicodeIdentifierStart(int)
  - isIdentifierIgnorable
```
public static boolean isIdentifierIgnorable(char ch)
```
    Bestimmt, ob das angegebene Zeichen in einem Java-Bezeichner oder Unicode-Bezeichner als ignorierbares Zeichen gilt. Folgende Unicode-Zeichen sind in einem Java-Bezeichner oder Unicode-Bezeichner ignorierbar:
    ISO-Steuerzeichen sind keine Leerzeichen
    '\u0000'至'\u0008'
    
    '\u000E'至'\u001B'
    
    '\u007F'至'\u009F'
    
    besitzenFORMATalle Zeichen mit dem Kategorie-Wert
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie dieisIdentifierIgnorable(int)Methode, um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen.
    Parameter
    ch- Das zu testende Zeichen. Ergebnis
    trueWenn das Zeichen ein ignorierbares Steuerzeichen ist, kann es Teil eines Java- oder Unicode-Bezeichners sein, andernfalls ist esfalse. Seit Version: 1.1 Siehe auch:
    isJavaIdentifierPart(char),isUnicodeIdentifierPart(char)
  - isIdentifierIgnorable
```
public static boolean isIdentifierIgnorable(int codePoint)
```
    Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) als ignorierbares Zeichen in einem Java-Bezeichner oder Unicode-Bezeichner behandelt werden muss. Die folgenden Unicode-Zeichen sind in einem Java-Bezeichner oder Unicode-Bezeichner ignorierbar:
    ISO-Steuerzeichen, die keine Leerzeichen sind
    '\u0000'至'\u0008'
    
    '\u000E'至'\u001B'
    
    '\u007F'至'\u009F'
    
    mitFORMATAlle Zeichen der Kategorie „allgemeiner Kategorie-Wert“
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein ignorierbares Steuerzeichen ist und Teil eines Java- oder Unicode-Bezeichners sein darf, sonstfalsefalse. Seit Version: 1.5 Siehe auch:
    isJavaIdentifierPart(int),isUnicodeIdentifierPart(int)
  - toLowerCase
```
public static char toLowerCase(char ch)
```
    Die Methode wandelt das Zeichenargument anhand der Groß-/Kleinschreibungs-Informationen aus der UnicodeData-Datei in Kleinbuchstaben um. Beachten Sie, dass für einige Zeichenbereiche
    Character.isLowerCase(Character.toLowerCase(ch))并不总是返回truezurückgibt, besonders bei Symbolen oder ideografischen Zeichen.
    In der Regel verwenden SieString.toLowerCase()um Zeichen in Kleinbuchstaben umzuwandeln.String案例映射方法比Characterder Methode zur Groß-/Kleinschreibungs-Zuordnung mehrere Vorteile.StringDie Methode zur Groß-/Kleinschreibungs-Zuordnung unterstützt gebietsschemaabhängige Zuordnung, kontextabhängige Zuordnung und 1:M-Zeichenzuordnung. DieCharacterMethode zur Groß-/Kleinschreibungs-Zuordnung unterstützt dies nicht.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen, verwenden Sie dietoLowerCase(int)Methode.
    
    Parameter
    ch- Das zu konvertierende Zeichen. Rückgabewert Die Kleinschreibungs-Entsprechung des Zeichens, falls vorhanden, andernfalls das Zeichen selbst. Siehe auch:
    isLowerCase(char),String.toLowerCase()
  - toLowerCase
```
public static int toLowerCase(int codePoint)
```
    Die Methode wandelt das Zeichen-Argument (Unicode-Codepunkt) mit den Groß-/Kleinschreibungs-Mappings aus der UnicodeData-Datei in Kleinbuchstaben um. Beachten Sie, dass für bestimmte Zeichenbereiche
    Character.isLowerCase(Character.toLowerCase(codePoint))并不总是返回truebesonders bei Symbolen oder ideografischen Zeichen.
    In der Regel verwenden SieString.toLowerCase()um ein Zeichen in Kleinbuchstaben umzuwandeln.String案例映射方法比CharacterCase-Mapping-Methode mehrere Vorteile.StringDie Case-Mapping-Methode führt gebietsschemaabhängige Mappings, kontextabhängige Mappings und 1:M-Zeichenmappings aus, währendCharacterDie Methode mit Fallzuordnung ist nicht möglich.
    
    Parameter
    codePoint- Das zu konvertierende Zeichen (Unicode-Codepunkt). Rückgabewert: Der kleingeschriebene Unicode-Codepunkt des Zeichens, falls vorhanden, sonst das Zeichen selbst. Seit Version: 1.5 Siehe auch:
    isLowerCase(int),String.toLowerCase()
  - toUpperCase
```
public static char toUpperCase(char ch)
```
    Diese Methode konvertiert das Zeichen mit den Fallzuordnungsinformationen aus der UnicodeData-Datei in Großbuchstaben. Beachten Sie, dass für einige Zeichenbereiche
    Character.isUpperCase(Character.toUpperCase(ch))并不总是返回truezurückgibt, besonders bei Symbolen oder ideografischen Zeichen.
    In der Regel verwenden SieString.toUpperCase()um ein Zeichen in Großbuchstaben umzuwandeln.String案例映射方法比CharacterDie Methode zur Groß-/Kleinschreibungs-Zuordnung hat mehrere Vorteile.StringDie Methode zur Groß-/Kleinschreibungs-Zuordnung kann gebietsschemaabhängige Zuordnungen, kontextabhängige Zuordnungen und 1:M-Zeichenzuordnungen ausführen, währendCharacterdie Methode zur Groß-/Kleinschreibungs-Zuordnung dies nicht kann.
    Hinweis: Diese Methode kann supplementary characters nicht verarbeiten. Um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen, verwenden Sie dietoUpperCase(int)Methode.
    
    Parameter
    ch- das zu konvertierende Zeichen. Rückgabewert die Großschreib-Entsprechung des Zeichens, falls vorhanden, andernfalls das Zeichen selbst. Siehe auch:
    isUpperCase(char),String.toUpperCase()
  - toUpperCase
```
public static int toUpperCase(int codePoint)
```
    Die Methode konvertiert den Parameter Zeichen (Unicode-Codepunkt) mit den Groß-/Kleinschreibungs-Informationen aus der UnicodeData-Datei in Großbuchstaben. Beachten Sie, dass für bestimmte Zeichenbereiche
    Character.isUpperCase(Character.toUpperCase(codePoint))并不总是返回truezurückgegeben wird, insbesondere bei Symbolen oder ideografischen Zeichen.
    In der Regel verwenden SieString.toUpperCase()um ein Zeichen in Großbuchstaben zu konvertieren.String案例映射方法比CharacterDie Methode zur Groß-/Kleinschreibungs-Zuordnung hat mehrere Vorteile.StringDie Methode zur Groß-/Kleinschreibungs-Zuordnung kann gebietsschemaabhängige Zuordnungen, kontextabhängige Zuordnungen und 1:M-Zeichenzuordnungen ausführen, währendCharacterdie Methode zur Groß-/Kleinschreibungs-Zuordnung dies nicht kann.
    
    Parameter
    codePoint- das zu konvertierende Zeichen (Unicode-Codepunkt). Rückgabewert die Großschreib-Entsprechung des Zeichens, falls vorhanden, andernfalls das Zeichen selbst. Seit Version: 1.5 Siehe auch:
    isUpperCase(int),String.toUpperCase()
  - toTitleCase
```
public static char toTitleCase(char ch)
```
    Die Methode konvertiert den Zeichenparameter mit den Groß-/Kleinschreibungs-Informationen aus der UnicodeData-Datei in Titlecase. Wenn ein Zeichen keine explizite Titlecase-Zuordnung hat und laut UnicodeData kein Titelzeichen ist, wird die Großschreib-Zuordnung als gleichwertige Titlecase-Zuordnung zurückgegeben. Wenn derchar参数已经是标题char ist, wird derselbecharWert zurückgegeben. Beachten Sie, dass für bestimmte Zeichenbereiche
    Character.isTitleCase(Character.toTitleCase(ch))并不总是返回true 。
    Hinweis: Diese Methode kann supplementary characters nicht verarbeiten. Um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen, verwenden Sie dietoTitleCase(int)Methode.
    
    Parameter
    ch- das zu konvertierende Zeichen. Rückgabewert die Titlecase-Entsprechung des Zeichens, falls vorhanden, andernfalls das Zeichen selbst. Seit Version: 1.0.2 Siehe auch:
    isTitleCase(char),toLowerCase(char),toUpperCase(char)
  - toTitleCase
```
public static int toTitleCase(int codePoint)
```
    Die Methode konvertiert den Parameter Zeichen (Unicode-Codepunkt) mit den Groß-/Kleinschreibungs-Informationen aus der UnicodeData-Datei in Titlecase. Wenn ein Zeichen keine explizite Titlecase-Zuordnung hat und laut UnicodeData kein Titelzeichen ist, wird die Großschreib-Zuordnung als gleichwertige Titlecase-Zuordnung zurückgegeben. Wenn der Zeichenparameter bereits ein Titelzeichen ist, wird derselbe Zeichenwert zurückgegeben. Beachten Sie, dass für bestimmte Zeichenbereiche
    Character.isTitleCase(Character.toTitleCase(codePoint))并不总是返回true 。
    
    Parameter
    codePoint- Das zu konvertierende Zeichen (Unicode-Codepunkt). Der Rückgabewert ist der Titelwort-Wert des Zeichens, falls vorhanden, andernfalls das Zeichen selbst. Verfügbar ab Version: 1.5. Siehe auch:
    isTitleCase(int),toLowerCase(int),toUpperCase(int)
  - digit
```
public static int digit(char ch,
                        int radix)
```
    Gibt den numerischen Wert des Zeichens in der angegebenen Basis zurück.chWenn die Basis nicht im Bereich
    MIN_RADIX â‰¤ radix â‰¤ MAX_RADIXliegt oder der Wertchkeine gültige Ziffer in der angegebenen Basis ist, -1wird zurückgegeben. Ein Zeichen ist eine gültige Ziffer, wenn mindestens eine der folgenden Bedingungen erfüllt ist:
    Die MethodeisDigit是字符的truewahr, und der Unicode-Dezimalwert des Zeichens (oder seiner Ein-Zeichen-Zerlegung) ist kleiner als die angegebene Basis. In diesem Fall wird der Dezimalwert zurückgegeben.
    Das Zeichen ist ein Großbuchstabe des lateinischen Alphabets'A'至'Z' ，其代码小于radix + 'A' - 10. In diesem Fall wirdch - 'A' + 10 。
    Das Zeichen ist ein Kleinbuchstabe des lateinischen Alphabets'a'到'z' ，其代码小于radix + 'a' - 10. In diesem Fall wirdch - 'a' + 10 。
    Das Zeichen ist eines der vollbreiten'\uFF21'写拉丁字母A（ '\uFF21' ）到Z（ '\uFF3A' ）之一，其代码小于radix + '\uFF21' - 10. In diesem Fall wirdch - '\uFF21' + 10 。
    Das Zeichen ist einer der vollbreiten Kleinbuchstaben a ('\uFF41' ）到z（ '\uFF5A' ）之一，其代码小于radix + '\uFF41' - 10. In diesem Fall wirdch - '\uFF41' + 10 。
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie die Methodedigit(int, int), um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen.
    Parameter
    ch- Das zu konvertierende Zeichen.
    radix- Die Basis. Rückgabewert: Der numerische Wert, den das Zeichen in der angegebenen Basis darstellt. Siehe auch:
    forDigit(int, int),isDigit(char)
  - digit
```
public static int digit(int codePoint,
                        int radix)
```
    Gibt den numerischen Wert des angegebenen Zeichens (Unicode-Codepoint) in der angegebenen Basis zurück. Liegt die Basis nicht im Bereich
    MIN_RADIX â‰¤ radix â‰¤ MAX_RADIX oder ist das Zeichen keine gültige Ziffer in der angegebenen Basis, -1wird zurückgegeben. Ein Zeichen ist eine gültige Ziffer, wenn mindestens eine der folgenden Bedingungen erfüllt ist:
    Die MethodeisDigit(codePoint)ist für das Zeichentrueund der Unicode-Dezimalwert des Zeichens (oder seiner Ein-Zeichen-Zerlegung) ist kleiner als die angegebene Basis. In diesem Fall wird der Dezimalwert zurückgegeben.
    Das Zeichen ist ein großer lateinischer Buchstabe'A'至'Z' ，其代码小于radix + 'A' - 10. In diesem Fall wirdcodePoint - 'A' + 10 。
    Das Zeichen ist ein kleiner lateinischer Buchstabe'a'至'z' ，其代码小于radix + 'a' - 10. In diesem Fall wirdcodePoint - 'a' + 10 。
    Das Zeichen ist eines der Fullwidth-Großbuchstaben A ('\uFF21'写拉丁字母A（ '\uFF21' ）到Z（ '\uFF3A' ）之一，其代码小于radix + '\uFF21' - 10zurückgegeben.codePoint - '\uFF21' + 10 。
    ) bis z ('\uFF41' ）到z（ '\uFF5A' ）之一，其代码小于radix + '\uFF41'- 10zurückgegeben.codePoint - '\uFF41' + 10 。
    Parameter
    codePoint- das zu konvertierende Zeichen (Unicode-Codepoint).
    radix- die Basis. Rückgabewert Der numerische Wert, den das Zeichen in der angegebenen Basis darstellt. Seit Version: 1.5 Siehe auch:
    forDigit(int, int),isDigit(int)
  - getNumericValue
```
public static int getNumericValue(char ch)
```
    Gibt den Wert zurück, den das angegebene Unicode-Zeichen darstellt. Zum Beispiel gibt das Zeichenint(romanische Zahl 50) einen int mit dem Wert 50 zurück. Die Großbuchstaben A bis Z ('\u216C'bis
    '\u0041'到'\u005A' ），Kleinbuchstaben ( '\u0061'到'\u007A' ) und Vollbreitvarianten ( '\uFF21'到'\uFF3A'和'\uFF41'到'\uFF5A' ) haben die numerischen Werte 10 bis 35. '\uFF5A' Dies ist unabhängig von der Unicode-Spezifikation. DiesecharWerte erhalten keine numerischen Werte zugewiesen.
    Wenn das Zeichen keinen numerischen Wert hat, gibt die Methode -1 zurück. Wenn der numerische Wert des Zeichens nicht als nichtnegative Ganzzahl darstellbar ist (zum Beispiel bei Bruchzahlen), gibt die Methode -2 zurück.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen zu unterstützen (einschließlich ergänzender Zeichen), verwenden Sie die MethodegetNumericValue(int).
    
    Parameter
    ch- das zu konvertierende Zeichen. Rückgabewert der numerische Wert des Zeichens als nichtnegativer
    intWert. -2, wenn das Zeichen einen numerischen Wert hat, der nicht als nichtnegativerintWert darstellbar ist. -1, wenn das Zeichen keinen numerischen Wert hat. Seit Version: 1.1 Siehe auch:
    forDigit(int, int),isDigit(char)
  - getNumericValue
```
public static int getNumericValue(int codePoint)
```
    Gibt denintWert zurück, den das angegebene Zeichen (Unicode-Codepunkt) darstellt. Zum Beispiel gibt das Zeichen'\u216C' (römische Zahl 50) einenintmit dem Wert 50 zurück. In ihrer Großschreibung (Buchstaben A bis Z
    '\u0041'通过'\u005A' ), Kleinschreibung ( '\u0061'通过'\u007A' ) und Vollbreitvarianten ('\uFF21'通过'\uFF3A'和'\uFF41'通过'\uFF5A' ) haben die Zeichen die numerischen Werte 10 bis 35. Dies ist unabhängig von der Unicode-Spezifikation. Diese Spezifikation weist diesencharWerten keine numerischen Werte zu.
    Wenn das Zeichen keinen numerischen Wert hat, gibt die Methode -1 zurück. Wenn der numerische Wert des Zeichens nicht als nichtnegative Ganzzahl darstellbar ist (zum Beispiel bei Bruchzahlen), gibt die Methode -2 zurück.
    
    Parameter
    codePoint- das zu konvertierende Zeichen (Unicode-Codepunkt). Rückgabewert der numerische Wert des Zeichens als nichtnegativer
    intWert. -2, wenn das Zeichen einen numerischen Wert hat, der nicht als nichtnegativerintWert darstellbar ist. -1, wenn das Zeichen keinen numerischen Wert hat. Seit Version: 1.5 Siehe auch:
    forDigit(int, int),isDigit(int)
  - isSpace
```
@Deprecated(since="1.1")
public static boolean isSpace(char ch)
```
    Deprecated. Replaced by isWhitespace(char).
    
    Prüft, ob das angegebene Zeichen ein ISO-LATIN-1-Leerzeichen ist. Diese Methode gibt nur für die folgenden fünf Zeichentrue: truechars Character Code Name'\t' U+0009 HORIZONTAL TABULATION '\n' U+000A NEW LINE '\f' U+000C FORM FEED '\r' U+000D CARRIAGE RETURN ' ' U+0020 SPACE
    
    Parameter
    ch- Das zu testende Zeichen. Ergebnis
    truetrue, wenn das Zeichen ein ISO-LATIN-1-Leerzeichen ist, sonstfalse), aber kein geschütztes Leerzeichen (
    isSpaceChar(char),isWhitespace(char)
  - isSpaceChar
```
public static boolean isSpaceChar(char ch)
```
    Prüft, ob das angegebene Zeichen ein Unicode-Leerzeichen ist. Ein Zeichen gilt genau dann als Leerzeichen, wenn der Unicode-Standard es als Leerzeichen kennzeichnet. Diese Methode gibt true zurück, wenn die allgemeine Kategorie des Zeichens eine der folgenden ist:
    SPACE_SEPARATOR
    
    LINE_SEPARATOR
    
    PARAGRAPH_SEPARATOR
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Verwenden Sie die MethodeisSpaceChar(int), um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen.
    Parameter
    ch- Das zu testende Zeichen. Ergebnis
    truetrue, wenn das Zeichen ein Leerzeichen ist, sonstfalsefalse. Seit Version: 1.1 Siehe auch:
    isWhitespace(char)
  - isSpaceChar
```
public static boolean isSpaceChar(int codePoint)
```
    Prüft, ob das angegebene Zeichen (Unicode-Codepunkt) ein Unicode-Leerzeichen ist. Ein Zeichen gilt genau dann als Leerzeichen, wenn der Unicode-Standard es als Leerzeichen kennzeichnet. Diese Methode gibt true zurück, wenn die allgemeine Kategorie des Zeichens eine der folgenden ist:
    SPACE_SEPARATOR
    
    LINE_SEPARATOR
    
    PARAGRAPH_SEPARATOR
    Parameter
    codePoint- Das zu testende Zeichen (Unicode-Codepunkt). Ergebnis
    truetrue, wenn das Zeichen ein Leerzeichen ist, sonstfalsefalse. Seit Version: 1.5 Siehe auch:
    isWhitespace(int)
  - isWhitespace
```
public static boolean isWhitespace(char ch)
```
    Prüft nach Java-Regeln, ob das angegebene Zeichen ein Leerzeichen ist. Ein Zeichen ist genau dann ein Java-Leerzeichen, wenn eine der folgenden Bedingungen erfüllt ist: Es ist ein Unicode-Leerzeichen (
    SPACE_SEPARATOR ， LINE_SEPARATOR ，或PARAGRAPH_SEPARATOR ），但不也是非打破空间（ '\u00A0' ， '\u2007' ， '\u202F' ）。
    Es ist'\t' , U + 0009 HORIZONTAL '\t' 。
    Es ist'\n', U + 000A LINE FEED.
    Es ist'\u000B' , U + 000B VERTICAL '\u000B' 。
    Es ist'\f', U + 000C FORM FEED.
    Es ist'\r' ，U + 000D '\r'RETURN.
    Es ist'\u001C', U + 001C FILE SEPARATOR.
    Es ist'\u001D', U + 001D GROUP SEPARATOR.
    Es ist'\u001E', U + 001E RECORD SEPARATOR.
    Es ist'\u001F', U + 001F UNIT SEPARATOR.
    Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich ergänzender Zeichen zu unterstützen, verwenden Sie die MethodeisWhitespace(int).
    Parameter
    ch- Das zu testende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein Java-Leerzeichen ist, andernfallsfalse. Seit Version: 1.1 Siehe auch:
    isSpaceChar(char)
  - isWhitespace
```
public static boolean isWhitespace(int codePoint)
```
    Bestimmt anhand von Java, ob das angegebene Zeichen (Unicode-Codepunkt) ein Leerzeichen ist. Ein Zeichen ist genau dann ein Java-Leerzeichen, wenn es eine der folgenden Bedingungen erfüllt: Es ist ein Unicode-Leerzeichen (
    SPACE_SEPARATOR,LINE_SEPARATORoderPARAGRAPH_SEPARATOR), aber kein geschütztes Leerzeichen ('\u00A0' ， '\u2007' ， '\u202F' ）。
    Es ist'\t' , U + 0009 HORIZONTAL '\t' 。
    Es ist'\n', U + 000A LINE FEED.
    Es ist'\u000B' , U + 000B VERTICAL '\u000B' 。
    Es ist'\f', U + 000C FORM FEED.
    Es ist'\r' ，U + 000D '\r'RETURN.
    Es ist'\u001C', U + 001C FILE SEPARATOR.
    Es ist'\u001D', U + 001D GROUP SEPARATOR.
    Sie ist'\u001E', U + 001E RECORD SEPARATOR.
    Sie ist'\u001F', U + 001F UNIT SEPARATOR.
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein Java-Leerzeichen ist, andernfallsfalse. Seit: 1.5 Siehe auch:
    isSpaceChar(int)
  - isISOControl
```
public static boolean isISOControl(char ch)
```
    Ermittelt, ob das angegebene Zeichen ein ISO-Steuerzeichen ist. Ein Zeichen gilt als ISO-Steuerzeichen, wenn sein Code im Bereich'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F'liegt. Hinweis: Diese Methode kann keine supplementary characters verarbeiten. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die Methode
    isISOControl(int).
    
    Parameter
    ch- das zu testende Zeichen. Rückgabewert
    truetrue, wenn das Zeichen ein ISO-Steuerzeichen ist, andernfallsfalse. Seit: 1.1 Siehe auch:
    isSpaceChar(char),isWhitespace(char)
  - isISOControl
```
public static boolean isISOControl(int codePoint)
```
    Ermittelt, ob das referenzierte Zeichen (Unicode-Codepunkt) ein ISO-Steuerzeichen ist. Ein Zeichen gilt als ISO-Steuerzeichen, wenn sein Code im Bereich'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F' 。
    Parameter
    codePoint- das zu testende Zeichen (Unicode-Codepunkt). Rückgabewert
    truetrue, wenn das Zeichen ein ISO-Steuerzeichen ist, andernfallsfalse. Seit: 1.5 Siehe auch:
    isSpaceChar(int),isWhitespace(int)
  - getType
```
public static int getType(char ch)
```
    Gibt einen Wert zurück, der die allgemeine Kategorie des Zeichens angibt. Hinweis: Diese Methode kann keine supplementary characters verarbeiten. Verwenden Sie für alle Unicode-Zeichen (einschließlich ergänzender Zeichen) die Methode
    getType(int).
    
    Parameter
    ch- das zu testende Zeichen. Rückgabewert Ein Wert vom Typ
    int, der die allgemeine Kategorie des Zeichens angibt. Seit: 1.1 Siehe auch:
    COMBINING_SPACING_MARK,CONNECTOR_PUNCTUATION,CONTROL,CURRENCY_SYMBOL，DASH_PUNCTUATION，DECIMAL_DIGIT_NUMBER，ENCLOSING_MARK，END_PUNCTUATION，FINAL_QUOTE_PUNCTUATION，FORMAT，INITIAL_QUOTE_PUNCTUATION，LETTER_NUMBER，LINE_SEPARATOR，LOWERCASE_LETTER，MATH_SYMBOL，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，UNASSIGNED，UPPERCASE_LETTER
  - getType
```
public static int getType(int codePoint)
```
    Gibt einen Wert zurück, der die allgemeine Kategorie des Zeichens angibt.
    Parameter
    codePoint- Das zu testende Zeichen (Unicode-Codepunkt). Der Rückgabewert ist vom Typ
    intund gibt die allgemeine Kategorie des Zeichens an. Seit Version: 1.5 Siehe auch:
    COMBINING_SPACING_MARK，CONNECTOR_PUNCTUATION，CONTROL，CURRENCY_SYMBOL，DASH_PUNCTUATION，DECIMAL_DIGIT_NUMBER，ENCLOSING_MARK，END_PUNCTUATION，FINAL_QUOTE_PUNCTUATION，FORMAT，INITIAL_QUOTE_PUNCTUATION，LETTER_NUMBER，LINE_SEPARATOR，LOWERCASE_LETTER，MATH_SYMBOL，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，UNASSIGNED，UPPERCASE_LETTER
  - forDigit
```
public static char forDigit(int digit,
                            int radix)
```
    Bestimmt die Zeichenrepräsentation einer bestimmten Ziffer in einem angegebenen Radix. Wenn der Wertradixkein gültiger Radix ist oder der Wertdigitkeine gültige Ziffer im angegebenen Radix ist, wird das Leerzeichen ( '\u0000') zurückgegeben. Der
    radixParameter ist gültig, wenn er größer oder gleichMIN_RADIXund kleiner oder gleichMAX_RADIXist. Wenn0 <= digit < radix ，则digitParameter gültig.
    Wenn die Ziffer kleiner als 10 ist, wird'0' + digitzurückgegeben. Andernfalls wird der Wert'a' + digit - 10 。
    
    Parameter
    digit- Die Ziffer, die in ein Zeichen umgewandelt werden soll.
    radix- Der Radix. Ergebnis Die
    charZeichenrepräsentation der angegebenen Ziffer im angegebenen Radix. Siehe auch:
    MIN_RADIX，MAX_RADIX，digit(char, int)
  - getDirectionality
```
public static byte getDirectionality(char ch)
```
    Gibt die Unicode-Richtungseigenschaft des angegebenen Zeichens zurück. Die Zeichenrichtung dient zur Berechnung der visuellen Anordnung von Text. Für nicht definiertecharWerte ist die RichtungDIRECTIONALITY_UNDEFINED. Hinweis: Diese Methode verarbeitet keine supplementary characters. Für Unterstützung aller Unicode-Zeichen (einschließlich ergänzender Zeichen) verwenden Sie die Methode
    getDirectionality(int).
    
    Parameter
    ch - chardessen Richtungseigenschaft angefordert wird. Ergebnis
    charRichtungseigenschaft des Werts. Seit Version: 1.4 Siehe auch:
    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,DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE,DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE,DIRECTIONALITY_FIRST_STRONG_ISOLATE,DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
  - getDirectionality
```
public static byte getDirectionality(int codePoint)
```
    Gibt die Unicode-Richtungseigenschaft des angegebenen Zeichens (Unicode-Codepunkt) zurück. Die Zeichenrichtung dient zur Berechnung der visuellen Anordnung von Text. Für nicht definierte Zeichen ist der RichtungswertDIRECTIONALITY_UNDEFINED.
    Parameter
    codePoint- Zeichen (Unicode-Codepunkt), dessen Richtungseigenschaft angefordert wird. Ergebnis Richtung des Zeichens. Seit Version: 1.5 Siehe auch:
    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，DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE，DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE，DIRECTIONALITY_FIRST_STRONG_ISOLATE，DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
  - isMirrored
```
public static boolean isMirrored(char ch)
```
    Bestimmt, ob das Zeichen gemäß der Unicode-Spezifikation gespiegelt wird. Bei der Anzeige in Text von rechts nach links muss das gespiegelte Zeichen horizontal gespiegelt dargestellt werden. Zum Beispiel:'\u0028'LEFT PARENTHESIS ist semantisch als linke Klammer definiert. In Text von rechts nach links wird „(“ als „)“ angezeigt. Hinweis: Diese Methode verarbeitet keine supplementary characters. Um alle Unicode-Zeichen einschließlich der ergänzenden Zeichen zu unterstützen, verwenden Sie die
    isMirrored(int)Methode.
    
    Parameter
    ch - char, dessen Spiegelungseigenschaft angefragt wird. Ergebnis
    trueWenn char gespiegelt ist, dann false如果 charnicht gespiegelt oder nicht definiert. Seit Version: 1.4
  - isMirrored
```
public static boolean isMirrored(int codePoint)
```
    Bestimmt, ob das angegebene Zeichen (Unicode-Codepunkt) gemäß der Unicode-Spezifikation gespiegelt wird. Bei der Anzeige in Text von rechts nach links muss das gespiegelte Zeichen horizontal gespiegelt dargestellt werden. Zum Beispiel:'\u0028'LEFT PARENTHESIS ist semantisch als linke Klammer definiert. In Text von rechts nach links wird „(“ als „)“ angezeigt.
    Parameter
    codePoint- Das zu testende Zeichen (Unicode-Codepunkt). Ergebnis
    trueWenn das Zeichen gespiegelt ist, dann falsewenn das Zeichen nicht gespiegelt oder nicht definiert ist. Seit Version: 1.5
  - compareTo
```
public int compareTo(Character anotherCharacter)
```
    Vergleicht zweiCharacter对象。
    Specified by:
    compareToin der Oberfläche Comparable<Character>
    Parameter
    anotherCharacter - zu vergleichendes Character. Ergebnis der Wert
    0Ist das ArgumentCharacterentspricht diesemCharacterWert kleiner als0 , wenn diesCharacternumerisch kleiner alsCharacterParameter, wenn dieserCharacternumerisch größer alsCharacterArgument (vorzeichenloser Vergleich), ist der Wert größer als0. Beachten Sie, dass dies ein reiner numerischer Vergleich ist. Er hängt nicht vom Gebietsschema ab. Ab Version: 1.2
  - compare
```
public static int compare(char x,
                          char y)
```
    Vergleicht zweicharWert. Der gelieferte Wert ist gleich dem gelieferten Wert:
    Character.valueOf(x).compareTo(Character.valueOf(y))
    Parameter
    x - erstes charzu vergleichen
    y - zweites charErgebnis beim Vergleich Wert
    0如果x == y, kleiner als0Wert, wennx < y, falls0ist der Wert größer alsx > y
    Ab Version: 1.7
  - reverseBytes
```
public static char reverseBytes(char ch)
```
    liefert das angegebene, umgekehrtecharWert, der aus der Byte-Reihenfolge des Werts ermittelt wird.
    Parameter
    ch - darunter chardreht die Byte-Reihenfolge um. Ergebnis das angegebene, umgekehrt (oder gleichwertig vertauscht)
    charWert, der aus den Bytes des Werts ermittelt wird. Ab Version: 1.5
  - getName
```
public static String getName(int codePoint)
```
    liefert das angegebene ZeichencodePointUnicode-Namen, wenn der Codepointunassigned, wird null geliefert. Hinweis: Weist die UnicodeData-Datei dem angegebenen Zeichen keinen Namen zu, ist der gelieferte Name gleich dem Ergebnis des Ausdrucks. Die UnicodeData-Datei ist Teil der Unicode-Zeichendatenbank, die das Unicode Consortium pflegt.
    
    Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') + " " + Integer.toHexString(codePoint).toUpperCase(Locale.ROOT);
    
    Parameter
    codePoint- Zeichen (Codepoint). Ergebnis den Unicode-Namen des angegebenen Zeichens, oder null, wenn kein Codepoint zugewiesen ist. Ausnahme
    IllegalArgumentException - 如果指定的 codePointkein gültiger Unicode-Codepunkt ist. Seit Version: 1.7
  - codePointOf
```
public static int codePointOf(String name)
```
    Gibt den Codepunktwert des Unicode-Zeichens zurück, das durch den angegebenen Unicode-Zeichennamen definiert ist. Hinweis: Wenn die UnicodeData-Datei (Teil der vom Unicode Consortium gepflegten Unicode-Zeichendatenbank) dem Zeichen keinen Namen zuweist, wird der Name als Ergebnis des Ausdrucks definiert
    
    Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') + " " + Integer.toHexString(codePoint).toUpperCase(Locale.ROOT);
    
    nameBeim Abgleich wird die Groß- und Kleinschreibung ignoriert. Führende und nachfolgende Leerzeichen werden entfernt.
    
    Parameter
    name- Unicode-Zeichenname Ergebnis Der Codepunktwert des Zeichens, das durch seinen Namen angegeben ist. Ausnahmen
    IllegalArgumentException - 如果指定的 namekein gültiger Unicode-Zeichenname ist.
    NullPointerException - 如果 nameist null
    Seit Version: 9

Klasse Character

Unicode Character Representations

嵌套类汇总

字段汇总

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

字段详细信息

MIN_RADIX

MAX_RADIX

MIN_VALUE

MAX_VALUE

TYPE

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

OTHER_SYMBOL

INITIAL_QUOTE_PUNCTUATION

FINAL_QUOTE_PUNCTUATION

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

DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE

DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE

DIRECTIONALITY_FIRST_STRONG_ISOLATE

DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE

MIN_HIGH_SURROGATE

MAX_HIGH_SURROGATE

MIN_LOW_SURROGATE

MAX_LOW_SURROGATE

MIN_SURROGATE

MAX_SURROGATE

MIN_SUPPLEMENTARY_CODE_POINT

MIN_CODE_POINT

MAX_CODE_POINT

SIZE

BYTES

构造方法详细信息

Character