Toutes les interfaces implémentées
Serializable ， Comparable<Character>
```
public final class Character
extends Object
implements Serializable, Comparable<Character>
```
CharacterLa classe Character enveloppe la valeur d'un type primitifchardans un objet. Un objet de typeCharactercontient un seul champ dont le type estchar. De plus, cette classe fournit plusieurs méthodes pour déterminer la catégorie d'un caractère (lettre minuscule, chiffre, etc.) et pour convertir un caractère de majuscule en minuscule, et inversement.
Les informations sur les caractères sont basées sur la version 10.0.0 de la norme Unicode.
Les méthodes et les données de la classeCharactersont définies à partir des informations du fichier UnicodeData. Ce fichier fait partie de la base de données de caractères Unicode maintenue par le Unicode Consortium. Ce fichier spécifie diverses propriétés, notamment le nom et la catégorie générale de chaque point de code Unicode défini ou de chaque plage de caractères.
Ce fichier et sa description sont disponibles auprès du Unicode Consortium :
- http://www.unicode.org
Représentation des caractères Unicode

charLes types de données (et doncCharacterles valeurs encapsulées par les objets) sont basés sur la spécification Unicode originale, qui définit un caractère comme une entité de largeur fixe de 16 bits. Depuis, la norme Unicode a changé pour permettre la représentation de caractères nécessitant plus de 16 bits. La plage des points de code valides s'étend désormais de U+0000 à U+10FFFF. Elle est appelée valeurs scalaires Unicode. (Voir la définition de la notation U+n dans la norme Unicode.)
L'ensemble des caractères de U+0000 à U+FFFF est parfois appelé plan multilingue de base (BMP). Les caractères dont le point de code est supérieur à U+FFFF sont appelés caractères supplémentaires. La plateforme Java utilisechardans les tableauxString和StringBufferdans les classes la représentation UTF-16. Dans cette représentation, les caractères supplémentaires sont représentés par une paire decharvaleurs, la première issue de la plage des substituts hauts (\uD800-\uDBFF), la seconde issue de la plage des substituts bas (\uDC00-\uDFFF).
Ainsi,charune valeur représente un point de code du plan multilingue de base (BMP), y compris les points de code de substitution ou les unités de code encodées en UTF-16.intune valeur représente tous les points de code Unicode, y compris les points de code supplémentaires.intLes 21 bits inférieurs (de poids faible) servent à représenter un point de code Unicode. Les 11 bits supérieurs (de poids fort) doivent être zéro. Sauf indication contraire, le comportement vis-à-vis des caractères supplémentaires et des substitutscharvaleurs est le suivant :
- Les méthodes qui n'acceptent que descharvaleurs ne prennent pas en charge les caractères supplémentaires. Elles traitent lescharvaleurs de la plage des substituts comme des caractères non définis. Par exemple,Character.isLetter('\uD840')返回falsemême si une valeur spécifique suivie d'un substitut bas dans cette chaîne représente aussi une lettre.
- Les méthodes qui acceptent desintvaleurs prennent en charge tous les caractères Unicode, y compris les caractères supplémentaires. Par exemple,Character.isLetter(0x2F81A)返回trueparce que la valeur du point de code représente une lettre (idéogramme CJK).
Dans la documentation de l'API Java SE, point de code Unicode désigne les valeurs de caractères entre U+0000 et U+10FFFF. Unité de code Unicode désigne les valeurs 16 bitscharqui sont des unités de code encodées en UTF-16. Pour plus d'informations sur la terminologie Unicode, consultez le glossaire Unicode.
Depuis la version : 1.0 Voir aussi : Serialized Form

嵌套类汇总

Classe imbriquée Variable et type Classe Description

`static class`	`Character.Subset`	Une instance de cette classe représente un sous-ensemble spécifique du jeu de caractères Unicode.
`static class`	`Character.UnicodeBlock`	Une famille de sous-ensembles de caractères représentant les blocs de caractères de la spécification Unicode.
`static class`	`Character.UnicodeScript`	Une famille de sous-ensembles de caractères représentant les écritures de caractères définies dans Unicode Standard Annex #24: Script Names.

字段汇总

Champ Variable et type Description du champ

`static int`	`BYTES`	Nombre d'octets utilisés pour représenter une`char`valeur sous forme binaire non signée.
`static byte`	`COMBINING_SPACING_MARK`	Catégorie générale « Mc » dans la spécification Unicode.
`static byte`	`CONNECTOR_PUNCTUATION`	Catégorie générale « Pc » dans la spécification Unicode.
`static byte`	`CONTROL`	Catégorie générale « Cc » dans la spécification Unicode.
`static byte`	`CURRENCY_SYMBOL`	Catégorie générale « Sc » dans la spécification Unicode.
`static byte`	`DASH_PUNCTUATION`	Catégorie générale « Pd » dans la spécification Unicode.
`static byte`	`DECIMAL_DIGIT_NUMBER`	Catégorie générale « Nd » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_ARABIC_NUMBER`	Type de caractère bidirectionnel faible « AN » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_BOUNDARY_NEUTRAL`	Type de caractère bidirectionnel faible « BN » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_COMMON_NUMBER_SEPARATOR`	Type de caractère bidirectionnel faible « CS » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER`	Type de caractère bidirectionnel faible « EN » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR`	Type de caractère bidirectionnel faible « ES » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR`	Type de caractère bidirectionnel faible « ET » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_FIRST_STRONG_ISOLATE`	Type de caractère bidirectionnel faible « FSI » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT`	Type de caractère bidirectionnel fort « L » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING`	Type de caractère bidirectionnel fort « LRE » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE`	Type de caractère bidirectionnel faible « LRI » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE`	Type de caractère bidirectionnel fort « LRO » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_NONSPACING_MARK`	Type de caractère bidirectionnel faible « NSM » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_OTHER_NEUTRALS`	Type de caractère bidirectionnel neutre « ON » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_PARAGRAPH_SEPARATOR`	Type de caractère bidirectionnel neutre « B » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_POP_DIRECTIONAL_FORMAT`	Type de caractère bidirectionnel faible « PDF » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE`	Type de caractère bidirectionnel faible « PDI » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT`	Type de caractère bidirectionnel fort « R » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC`	Type de caractère bidirectionnel fort « AL » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING`	Type de caractère bidirectionnel fort « RLE » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE`	Type de caractère bidirectionnel faible « RLI » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE`	Type de caractère bidirectionnel fort « RLO » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_SEGMENT_SEPARATOR`	Type de caractère bidirectionnel neutre « S » de la spécification Unicode.
`static byte`	`DIRECTIONALITY_UNDEFINED`	Type de caractère bidirectionnel non défini.
`static byte`	`DIRECTIONALITY_WHITESPACE`	Type de caractère bidirectionnel neutre « WS » de la spécification Unicode.
`static byte`	`ENCLOSING_MARK`	Catégorie générale « Me » de la spécification Unicode.
`static byte`	`END_PUNCTUATION`	Catégorie générale « Pe » de la spécification Unicode.
`static byte`	`FINAL_QUOTE_PUNCTUATION`	Catégorie générale « Pf » de la spécification Unicode.
`static byte`	`FORMAT`	Catégorie générale « Cf » de la spécification Unicode.
`static byte`	`INITIAL_QUOTE_PUNCTUATION`	Catégorie générale « Pi » de la spécification Unicode.
`static byte`	`LETTER_NUMBER`	Catégorie générale « Nl » de la spécification Unicode.
`static byte`	`LINE_SEPARATOR`	Catégorie générale « Zl » de la spécification Unicode.
`static byte`	`LOWERCASE_LETTER`	Catégorie générale « Ll » de la spécification Unicode.
`static byte`	`MATH_SYMBOL`	Catégorie générale « Sm » de la spécification Unicode.
`static int`	`MAX_CODE_POINT`	Valeur maximale d'un Unicode code point, constante`U+10FFFF` 。
`static char`	`MAX_HIGH_SURROGATE`	Valeur maximale d'un Unicode high-surrogate code unit en encodage UTF-16, constante`'\uDBFF'` 。
`static char`	`MAX_LOW_SURROGATE`	Valeur maximale d'un Unicode low-surrogate code unit en encodage UTF-16, constante`'\uDFFF'` 。
`static int`	`MAX_RADIX`	Valeur de base maximale utilisable pour les conversions vers et depuis une chaîne.
`static char`	`MAX_SURROGATE`	Valeur maximale d'une unité de code de substitution Unicode en encodage UTF-16, constante`'\uDFFF'` 。
`static char`	`MAX_VALUE`	La valeur constante de ce champ est de type`char` `'\uFFFF'` 。
`static int`	`MIN_CODE_POINT`	Valeur minimale d'un point de code Unicode, constante`U+0000` 。
`static char`	`MIN_HIGH_SURROGATE`	Valeur minimale d'une unité de code de substitution haute Unicode en encodage UTF-16, constante`'\uD800'` 。
`static char`	`MIN_LOW_SURROGATE`	Valeur minimale d'une unité de code de substitution basse Unicode en encodage UTF-16, constante`'\uDC00'` 。
`static int`	`MIN_RADIX`	Valeur de base minimale utilisable pour les conversions vers et depuis une chaîne.
`static int`	`MIN_SUPPLEMENTARY_CODE_POINT`	Valeur minimale d'un point de code supplémentaire Unicode, constante`U+10000` 。
`static char`	`MIN_SURROGATE`	Valeur minimale d'une unité de code de substitution Unicode en encodage UTF-16, constante`'\uD800'` 。
`static char`	`MIN_VALUE`	La valeur constante de ce champ est de type`char` `'\u0000'` 。
`static byte`	`MODIFIER_LETTER`	Catégorie générale « Lm » dans la spécification Unicode.
`static byte`	`MODIFIER_SYMBOL`	Catégorie générale « Sk » dans la spécification Unicode.
`static byte`	`NON_SPACING_MARK`	Catégorie générale « Mn » dans la spécification Unicode.
`static byte`	`OTHER_LETTER`	Catégorie générale « Lo » dans la spécification Unicode.
`static byte`	`OTHER_NUMBER`	Catégorie générale « No » dans la spécification Unicode.
`static byte`	`OTHER_PUNCTUATION`	Catégorie générale « Po » dans la spécification Unicode.
`static byte`	`OTHER_SYMBOL`	Catégorie générale « So » dans la spécification Unicode.
`static byte`	`PARAGRAPH_SEPARATOR`	Catégorie générale « Zp » dans la spécification Unicode.
`static byte`	`PRIVATE_USE`	Catégorie générale « Co » dans la spécification Unicode.
`static int`	`SIZE`	Nombre de bits utilisés pour représenter une valeur`char`sous forme binaire non signée, constante `16` 。
`static byte`	`SPACE_SEPARATOR`	Catégorie générale « Zs » dans la spécification Unicode.
`static byte`	`START_PUNCTUATION`	Catégorie générale « Ps » dans la spécification Unicode.
`static byte`	`SURROGATE`	Catégorie générale « Cs » dans la spécification Unicode.
`static byte`	`TITLECASE_LETTER`	Catégorie générale « Lt » dans la spécification Unicode.
`static 类<Character>`	`TYPE`	`类`Instance représentant le type primitif `char` 。
`static byte`	`UNASSIGNED`	Catégorie générale « Cn » dans la spécification Unicode.
`static byte`	`UPPERCASE_LETTER`	Catégorie générale « Lu » dans la spécification Unicode.

构造方法摘要

构造方法
构造器	Description
`Character(char value)`	Obsolète. L'utilisation de ce constructeur est rarement appropriée.

方法摘要

Toutes les méthodes Méthodes statiques Méthodes d'instance Méthodes concrètes Méthodes obsolètes Variable et type Méthode Description

`static int`	`charCount(int codePoint)`	Détermine le nombre de valeurs nécessaires pour représenter le caractère spécifié (point de code Unicode).`char`Retourne la valeur de cet objet.
`char`	`charValue()`	Retourne la valeur de l'objet`Character`.
`static int`	`codePointAt(char[] a, int index)`	Retourne le point de code à l'index donné du tableau`char`.
`static int`	`codePointAt(char[] a, int index, int limit)`	Retourne le point de code à l'index donné du tableau`char`, où seuls les éléments du tableau `index`inférieurs à `limit`数组元素。
`static int`	`codePointAt(CharSequence seq, int index)`	Retourne le point de code à l'index donné de`CharSequence`.
`static int`	`codePointBefore(char[] a, int index)`	Retourne le point de code précédant l'index donné du tableau`char`.
`static int`	`codePointBefore(char[] a, int index, int start)`	Retourne le point de code précédant l'index donné du tableau`char`, où seuls les éléments du tableau `index`supérieurs ou égaux à `start`数组元素。
`static int`	`codePointBefore(CharSequence seq, int index)`	Retourne le point de code précédant l'index donné de`CharSequence`.
`static int`	`codePointCount(char[] a, int offset, int count)`	Retourne le nombre de points de code Unicode dans le sous-tableau du paramètre de tableau`char`.
`static int`	`codePointCount(CharSequence seq, int beginIndex, int endIndex)`	Retourne le nombre de points de code Unicode dans la plage de texte de la séquence de char spécifiée.
`static int`	`codePointOf(String name)`	Retourne la valeur du point de code du caractère Unicode désigné par le nom de caractère Unicode donné.
`static int`	`compare(char x, char y)`	Compare numériquement deux valeurs`char`值。
`int`	`compareTo(Character anotherCharacter)`	Compare numériquement deux objets`Character`对象。
`static int`	`digit(char ch, int radix)`	Retourne la valeur numérique du caractère`ch`的数值。
`static int`	`digit(int codePoint, int radix)`	Retourne la valeur numérique du caractère spécifié (point de code Unicode) dans la base spécifiée.
`boolean`	`equals(Object obj)`	Compare cet objet avec l'objet spécifié.
`static char`	`forDigit(int digit, int radix)`	Détermine la représentation sous forme de caractère d'un chiffre spécifique dans la base spécifiée.
`static byte`	`getDirectionality(char ch)`	Retourne la propriété de directionnalité Unicode du caractère donné.
`static byte`	`getDirectionality(int codePoint)`	Retourne la propriété de directionnalité Unicode du caractère donné (point de code Unicode).
`static String`	`getName(int codePoint)`	Retourne le nom Unicode du caractère spécifié`codePoint`, ou null si le point de code est`unassigned`，renvoie null.
`static int`	`getNumericValue(char ch)`	Renvoie la valeur représentée par le`int`值。
`static int`	`getNumericValue(int codePoint)`	Renvoie la valeur représentée par le caractère spécifié (point de code Unicode).`int`值。
`static int`	`getType(char ch)`	Renvoie une valeur représentant la catégorie générale du caractère.
`static int`	`getType(int codePoint)`	Renvoie une valeur représentant la catégorie générale du caractère.
`int`	`hashCode()`	Renvoie le code de hachage de cet`Character`objet. Il équivaut à appeler`charValue()`.
`static int`	`hashCode(char value)`	Renvoie le code de hachage de la`char`valeur. Il est compatible avec`Character.hashCode()`.
`static char`	`highSurrogate(int codePoint)`	Renvoie le substituant dominant (high surrogate code unit) de la paire de substituants représentant le caractère supplémentaire spécifié (point de code Unicode) en encodage UTF-16.
`static boolean`	`isAlphabetic(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est une lettre.
`static boolean`	`isBmpCodePoint(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) appartient au Basic Multilingual Plane (BMP).
`static boolean`	`isDefined(char ch)`	Détermine si le caractère est défini dans Unicode.
`static boolean`	`isDefined(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est défini dans Unicode.
`static boolean`	`isDigit(char ch)`	Détermine si le caractère spécifié est un chiffre.
`static boolean`	`isDigit(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un chiffre.
`static boolean`	`isHighSurrogate(char ch)`	Détermine si la`char`valeur donnée est un high-surrogate code unit Unicode (aussi appelé unité de code de substituant dominant).
`static boolean`	`isIdentifierIgnorable(char ch)`	Détermine si le caractère spécifié doit être ignoré dans un identifiant Java ou un identifiant Unicode.
`static boolean`	`isIdentifierIgnorable(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) doit être ignoré dans un identifiant Java ou un identifiant Unicode.
`static boolean`	`isIdeographic(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un idéogramme CJKV (chinois, japonais, coréen et vietnamien) défini par la norme Unicode.
`static boolean`	`isISOControl(char ch)`	Détermine si le caractère spécifié est un caractère de contrôle ISO.
`static boolean`	`isISOControl(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un caractère de contrôle ISO.
`static boolean`	`isJavaIdentifierPart(char ch)`	Détermine si le caractère spécifié peut faire partie d'un identifiant Java, autre que le premier caractère.
`static boolean`	`isJavaIdentifierPart(int codePoint)`	Détermine si le caractère (point de code Unicode) peut faire partie d'un identifiant Java, autre que le premier caractère.
`static boolean`	`isJavaIdentifierStart(char ch)`	Détermine si le caractère spécifié est autorisé comme premier caractère d'un identifiant Java.
`static boolean`	`isJavaIdentifierStart(int codePoint)`	Détermine si le caractère (point de code Unicode) est autorisé comme premier caractère d'un identifiant Java.
`static boolean`	`isJavaLetter(char ch)`	Obsolète. Remplacé par isJavaIdentifierStart(char).
`static boolean`	`isJavaLetterOrDigit(char ch)`	Obsolète. Remplacé par isJavaIdentifierPart(char).
`static boolean`	`isLetter(char ch)`	Détermine si le caractère spécifié est une lettre.
`static boolean`	`isLetter(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est une lettre.
`static boolean`	`isLetterOrDigit(char ch)`	Détermine si le caractère spécifié est une lettre ou un chiffre.
`static boolean`	`isLetterOrDigit(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est une lettre ou un chiffre.
`static boolean`	`isLowerCase(char ch)`	Détermine si le caractère spécifié est un caractère minuscule.
`static boolean`	`isLowerCase(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un caractère minuscule.
`static boolean`	`isLowSurrogate(char ch)`	Détermine si la`char`Détermine si la valeur est une unité de code Unicode low-surrogate (aussi appelée unité de code trailing-surrogate).
`static boolean`	`isMirrored(char ch)`	Détermine si le caractère est mis en miroir selon la spécification Unicode.
`static boolean`	`isMirrored(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est mis en miroir selon la spécification Unicode.
`static boolean`	`isSpace(char ch)`	Obsolète. Remplacé par isWhitespace(char).
`static boolean`	`isSpaceChar(char ch)`	Détermine si le caractère spécifié est un caractère d'espacement Unicode.
`static boolean`	`isSpaceChar(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un caractère d'espacement Unicode.
`static boolean`	`isSupplementaryCodePoint(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) se trouve dans la plage des supplementary characters.
`static boolean`	`isSurrogate(char ch)`	Détermine si la valeur donnée`char`est une unité de code de substitution Unicode.
`static boolean`	`isSurrogatePair(char high, char low)`	Détermine si la paire de valeurs spécifiée`char`est une paire de substitution Unicode valide.
`static boolean`	`isTitleCase(char ch)`	Détermine si le caractère spécifié est un caractère de titre.
`static boolean`	`isTitleCase(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un caractère de titre.
`static boolean`	`isUnicodeIdentifierPart(char ch)`	Détermine si le caractère spécifié peut faire partie d'un identifiant Unicode, autrement que comme premier caractère.
`static boolean`	`isUnicodeIdentifierPart(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) peut faire partie d'un identifiant Unicode, autrement que comme premier caractère.
`static boolean`	`isUnicodeIdentifierStart(char ch)`	Détermine si le caractère spécifié est autorisé comme premier caractère dans un identifiant Unicode.
`static boolean`	`isUnicodeIdentifierStart(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est autorisé comme premier caractère dans un identifiant Unicode.
`static boolean`	`isUpperCase(char ch)`	Détermine si le caractère spécifié est un caractère majuscule.
`static boolean`	`isUpperCase(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un caractère majuscule.
`static boolean`	`isValidCodePoint(int codePoint)`	Détermine si le point de code spécifié est une valeur de point de code Unicode valide.
`static boolean`	`isWhitespace(char ch)`	Détermine si le caractère spécifié est un espace selon Java.
`static boolean`	`isWhitespace(int codePoint)`	Détermine si le caractère spécifié (point de code Unicode) est un espace selon Java.
`static char`	`lowSurrogate(int codePoint)`	Retourne la substitution finale (l'unité de code low surrogate) de la paire de substitution représentant en encodage UTF-16 le caractère supplémentaire spécifié (point de code Unicode).
`static int`	`offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)`	Retourne l'index dans la séquence de caractères donnée, à partir du`char`le sous-tableau part du décalage donné `index`par `codePointOffset`代码点。
`static int`	`offsetByCodePoints(CharSequence seq, int index, int codePointOffset)`	Retourne l'index dans la séquence de caractères donnée, à partir du`index`décalage `codePointOffset`代码点。
`static char`	`reverseBytes(char ch)`	Retourne la valeur obtenue en inversant l'ordre des octets dans la valeur`char`spécifiée.
`static char[]`	`toChars(int codePoint)`	Convertit le caractère spécifié (point de code Unicode) en sa représentation UTF-16 stockée dans un`char`tableau.
`static int`	`toChars(int codePoint, char[] dst, int dstIndex)`	Convertit le caractère spécifié (point de code Unicode) en sa représentation UTF-16.
`static int`	`toCodePoint(char high, char low)`	Convertit la paire de substitution spécifiée en sa valeur de point de code supplémentaire.
`static char`	`toLowerCase(char ch)`	Convertit le paramètre caractère en minuscule en utilisant les informations de mappage de casse du fichier UnicodeData.
`static int`	`toLowerCase(int codePoint)`	Convertit le paramètre caractère (point de code Unicode) en minuscule en utilisant les informations de mappage de casse du fichier UnicodeData.
`String`	`toString()`	Retourne la valeur représentant ce`Character`值的 `String`对象。
`static String`	`toString(char c)`	Retourne un objet représentant le`char`的 `String`对象。
`static String`	`toString(int codePoint)`	Retourne un objet représentant le caractère spécifié (point de code Unicode).`String`对象。
`static char`	`toTitleCase(char ch)`	Convertit l'argument caractère en titlecase en utilisant les informations de mappage de casse du fichier UnicodeData.
`static int`	`toTitleCase(int codePoint)`	Convertit l'argument caractère (point de code Unicode) en titlecase en utilisant les informations de mappage de casse du fichier UnicodeData.
`static char`	`toUpperCase(char ch)`	Convertit l'argument caractère en majuscule en utilisant les informations de mappage de casse du fichier UnicodeData.
`static int`	`toUpperCase(int codePoint)`	Convertit l'argument caractère (point de code Unicode) en majuscule en utilisant les informations de mappage de casse du fichier UnicodeData.
`static Character`	`valueOf(char c)`	Retourne une instance de`char`值的 `Character`spécifiée.

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

- 字段详细信息
  - MIN_RADIX
```
public static final int MIN_RADIX
```
    La plus petite base utilisable pour les conversions vers et depuis une chaîne. La valeur constante de ce champ est la plus petite valeur autorisée pour l'argument base des méthodes de conversion de base, par exempledigit方法， forDigit方法和toString类Integer方法。
    Voir aussi :
    digit(char, int),forDigit(int, int),Integer.toString(int, int),Integer.valueOf(String), Valeur constante du champ
  - MAX_RADIX
```
public static final int MAX_RADIX
```
    La plus grande base utilisable pour les conversions vers et depuis une chaîne. La valeur constante de ce champ est la plus grande valeur autorisée pour l'argument base des méthodes de conversion de basedigit , par exempledigit方法， forDigit方法和toString类Integer方法。
    Voir aussi :
    digit(char, int),forDigit(int, int),Integer.toString(int, int),Integer.valueOf(String), Valeur constante du champ
  - MIN_VALUE
```
public static final char MIN_VALUE
```
    La valeur constante de ce champ est du typechar '\u0000' 。
    Disponible depuis : 1.0.2 Voir aussi : Valeurs des champs constants
  - MAX_VALUE
```
public static final char MAX_VALUE
```
    La valeur constante de ce champ est de typechar '\uFFFF' 。
    Disponible depuis : 1.0.2 Voir aussi : Valeurs des champs constants
  - TYPE
```
public static final 类<Character> TYPE
```
    类L'instance représente le type primitif char 。
    Disponible depuis : 1.1
  - UNASSIGNED
```
public static final byte UNASSIGNED
```
    Catégorie générale « Cn » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - UPPERCASE_LETTER
```
public static final byte UPPERCASE_LETTER
```
    Catégorie générale « Lu » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - LOWERCASE_LETTER
```
public static final byte LOWERCASE_LETTER
```
    Catégorie générale « Ll » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - TITLECASE_LETTER
```
public static final byte TITLECASE_LETTER
```
    Catégorie générale « Lt » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - MODIFIER_LETTER
```
public static final byte MODIFIER_LETTER
```
    Catégorie générale « Lm » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - OTHER_LETTER
```
public static final byte OTHER_LETTER
```
    Catégorie générale « Lo » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - NON_SPACING_MARK
```
public static final byte NON_SPACING_MARK
```
    Catégorie générale « Mn » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - ENCLOSING_MARK
```
public static final byte ENCLOSING_MARK
```
    Catégorie générale « Me » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - COMBINING_SPACING_MARK
```
public static final byte COMBINING_SPACING_MARK
```
    Catégorie générale « Mc » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - DECIMAL_DIGIT_NUMBER
```
public static final byte DECIMAL_DIGIT_NUMBER
```
    Catégorie générale « Nd » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - LETTER_NUMBER
```
public static final byte LETTER_NUMBER
```
    Catégorie générale « Nl » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - OTHER_NUMBER
```
public static final byte OTHER_NUMBER
```
    Catégorie générale « No » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - SPACE_SEPARATOR
```
public static final byte SPACE_SEPARATOR
```
    Catégorie générale « Zs » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - LINE_SEPARATOR
```
public static final byte LINE_SEPARATOR
```
    Catégorie générale « Zl » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - PARAGRAPH_SEPARATOR
```
public static final byte PARAGRAPH_SEPARATOR
```
    Catégorie générale « Zp » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - CONTROL
```
public static final byte CONTROL
```
    Catégorie générale « Cc » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - FORMAT
```
public static final byte FORMAT
```
    Catégorie générale « Cf » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - PRIVATE_USE
```
public static final byte PRIVATE_USE
```
    Catégorie générale « Co » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - SURROGATE
```
public static final byte SURROGATE
```
    Catégorie générale « Cs » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - DASH_PUNCTUATION
```
public static final byte DASH_PUNCTUATION
```
    Catégorie générale « Pd » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - START_PUNCTUATION
```
public static final byte START_PUNCTUATION
```
    Catégorie générale « Ps » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - END_PUNCTUATION
```
public static final byte END_PUNCTUATION
```
    Catégorie générale « Pe » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - CONNECTOR_PUNCTUATION
```
public static final byte CONNECTOR_PUNCTUATION
```
    Catégorie générale « Pc » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : valeurs des champs constants
  - OTHER_PUNCTUATION
```
public static final byte OTHER_PUNCTUATION
```
    Catégorie générale « Po » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - MATH_SYMBOL
```
public static final byte MATH_SYMBOL
```
    Catégorie générale « Sm » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - CURRENCY_SYMBOL
```
public static final byte CURRENCY_SYMBOL
```
    Catégorie générale « Sc » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - MODIFIER_SYMBOL
```
public static final byte MODIFIER_SYMBOL
```
    Catégorie générale « Sk » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - OTHER_SYMBOL
```
public static final byte OTHER_SYMBOL
```
    Catégorie générale « So » dans la spécification Unicode.
    Disponible depuis : 1.1 Voir aussi : Valeurs des champs constants
  - INITIAL_QUOTE_PUNCTUATION
```
public static final byte INITIAL_QUOTE_PUNCTUATION
```
    Catégorie générale « Pi » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - FINAL_QUOTE_PUNCTUATION
```
public static final byte FINAL_QUOTE_PUNCTUATION
```
    Catégorie générale « Pf » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_UNDEFINED
```
public static final byte DIRECTIONALITY_UNDEFINED
```
    Type de caractère bidirectionnel non défini. La valeur non définiecharpossède une directionnalité non définie dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_LEFT_TO_RIGHT
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT
```
    Type de caractère bidirectionnel fort « L » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_RIGHT_TO_LEFT
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT
```
    Type de caractère bidirectionnel fort « R » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
```
    Type de caractère bidirectionnel fort « AL » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_EUROPEAN_NUMBER
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER
```
    Type de caractère bidirectionnel faible « EN » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
```
    Type de caractère bidirectionnel faible « ES » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
```
public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
```
    Type de caractère bidirectionnel faible « ET » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_ARABIC_NUMBER
```
public static final byte DIRECTIONALITY_ARABIC_NUMBER
```
    Type de caractère bidirectionnel faible « AN » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
```
public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
```
    Type de caractère bidirectionnel faible « CS » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_NONSPACING_MARK
```
public static final byte DIRECTIONALITY_NONSPACING_MARK
```
    Type de caractère bidirectionnel faible « NSM » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_BOUNDARY_NEUTRAL
```
public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL
```
    Type de caractère bidirectionnel faible « BN » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_PARAGRAPH_SEPARATOR
```
public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR
```
    Type de caractère bidirectionnel neutre « B » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_SEGMENT_SEPARATOR
```
public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR
```
    Type de caractère bidirectionnel neutre « S » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_WHITESPACE
```
public static final byte DIRECTIONALITY_WHITESPACE
```
    Type de caractère bidirectionnel neutre « WS » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_OTHER_NEUTRALS
```
public static final byte DIRECTIONALITY_OTHER_NEUTRALS
```
    Type de caractère bidirectionnel neutre « ON » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
```
    Type de caractère bidirectionnel fort « LRE » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
```
    Type de caractère bidirectionnel fort « LRO » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
```
    Type de caractère bidirectionnel fort « RLE » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
```
    Type de caractère bidirectionnel fort « RLO » dans la spécification Unicode.
    Disponible depuis : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
```
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
```
    Type de caractère bidirectionnel faible « PDF » dans la spécification Unicode.
    Depuis la version : 1.4 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE
```
public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE
```
    Type de caractère bidirectionnel faible « LRI » dans la spécification Unicode.
    Depuis la version : 9 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE
```
public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE
```
    Type de caractère bidirectionnel faible « RLI » dans la spécification Unicode.
    Depuis la version : 9 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_FIRST_STRONG_ISOLATE
```
public static final byte DIRECTIONALITY_FIRST_STRONG_ISOLATE
```
    Type de caractère bidirectionnel faible « FSI » dans la spécification Unicode.
    Depuis la version : 9 Voir aussi : Valeurs des champs constants
  - DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
```
public static final byte DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE
```
    Type de caractère bidirectionnel faible « PDI » dans la spécification Unicode.
    Depuis la version : 9 Voir aussi : Valeurs des champs constants
  - MIN_HIGH_SURROGATE
```
public static final char MIN_HIGH_SURROGATE
```
    Valeur minimale d'une unité de code Unicode high-surrogate dans l'encodage UTF-16, constante'\uD800'. Un surrogate haut est aussi appelé surrogate de tête.
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MAX_HIGH_SURROGATE
```
public static final char MAX_HIGH_SURROGATE
```
    Valeur maximale d'une unité de code Unicode high-surrogate dans l'encodage UTF-16, constante'\uDBFF'. Un surrogate haut est aussi appelé surrogate de tête.
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MIN_LOW_SURROGATE
```
public static final char MIN_LOW_SURROGATE
```
    Valeur minimale d'une unité de code Unicode low-surrogate dans l'encodage UTF-16, constante'\uDC00'. Un surrogate bas est aussi appelé surrogate de queue.
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MAX_LOW_SURROGATE
```
public static final char MAX_LOW_SURROGATE
```
    Valeur maximale d'une unité de code Unicode low-surrogate dans l'encodage UTF-16, constante'\uDFFF'. Un surrogate bas est aussi appelé surrogate de queue.
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MIN_SURROGATE
```
public static final char MIN_SURROGATE
```
    Valeur minimale d'une unité de code surrogate Unicode dans l'encodage UTF-16, constante'\uD800' 。
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MAX_SURROGATE
```
public static final char MAX_SURROGATE
```
    Valeur maximale d'une unité de code surrogate Unicode dans l'encodage UTF-16, constante'\uDFFF' 。
    Depuis la version : 1.5 Voir aussi : Valeurs des champs constants
  - MIN_SUPPLEMENTARY_CODE_POINT
```
public static final int MIN_SUPPLEMENTARY_CODE_POINT
```
    Valeur minimale d'un point de code Unicode supplementary, constanteU+10000 。
    Disponible depuis : 1.5 Voir aussi : Valeurs des champs constants
  - MIN_CODE_POINT
```
public static final int MIN_CODE_POINT
```
    Valeur minimale d'un point de code Unicode, constanteU+0000 。
    Disponible depuis : 1.5 Voir aussi : Valeurs des champs constants
  - MAX_CODE_POINT
```
public static final int MAX_CODE_POINT
```
    Valeur maximale d'un point de code Unicode, constanteU+10FFFF 。
    Disponible depuis : 1.5 Voir aussi : Valeurs des champs constants
  - SIZE
```
public static final int SIZE
```
    Nombre de bits utilisés pour représenter une valeur sous forme binaire non signée, constantechar. 16 。
    Disponible depuis : 1.5 Voir aussi : Valeurs des champs constants
  - BYTES
```
public static final int BYTES
```
    Nombre d'octets utilisés pour représenter une valeurcharsous forme binaire non signée.
    Disponible depuis : 1.8 Voir aussi : Valeurs des champs constants
- 构造方法详细信息
  - Character
```
@Deprecated(since="9")
public Character(char value)
```
    Deprecated. It is rarely appropriate to use this constructor. The static factory
    valueOf(char)is generally a better choice, as it is likely to yield significantly better space and time performance.
    
    Construit un nouvel objetCharacteralloué qui représente la valeur char值。
    Paramètres
    value - Valeur à représenter par l'objet Character.
- 方法详细信息
  - valueOf
```
public static Character valueOf(char c)
```
    Retourne une instancechar值的Characterspécifiée. Si une nouvelle instanceCharactern'est pas nécessaire, utilisez cette méthode de préférence au constructeurCharacter(char), car elle améliore nettement les performances en espace et en temps grâce à la mise en cache des valeurs fréquemment demandées. Cette méthode met toujours en cache les valeurs dans la plage'\u0000'至'\u007F', et peut mettre en cache d'autres valeurs en dehors de cette plage.
    Paramètres
    c- Valeur char. Résultat
    CharacterInstance qui représente c. Ab Version: 1.5
  - charValue
```
public char charValue()
```
    Retourne la valeur de cetCharacterobjet.
    Résultat La valeur primitive représentée par cet objet
    char.
  - hashCode
```
public int hashCode()
```
    Retourne le code de hachage de ceCharacter; il est égal au résultat de l'appel decharValue().
    Remplacement :
    hashCode类 Object
    Résultat Le code de hachage de ce
    Character. Voir aussi :
    Object.equals(java.lang.Object),System.identityHashCode(java.lang.Object)
  - hashCode
```
public static int hashCode(char value)
```
    Retourne le code de hachage de lacharvaleur ; il est compatible avecCharacter.hashCode().
    Paramètres
    value - Le chardont on retourne le code de hachage. Résultat
    charLe code de hachage de la valeur. Depuis la version : 1.8
  - equals
```
public boolean equals(Object obj)
```
    Compare cet objet avec l'objet spécifié. Le résultat estnullsi et seulement si l'argument n'est pasCharacteret est un objettrue qui représente la mêmechar值。
    Remplacement :
    equals在类 Object
    Paramètres
    obj- L'objet à comparer. Résultat
    trueSi les objets sont identiques ; sinonfalse. Voir aussi :
    Object.hashCode(),HashMap
  - toString
```
public String toString()
```
    Retourne un objetCharacter值的String. Le résultat est une chaîne de longueur 1 dont l'unique composant est la primitivecharpar la valeur de représentationCharacter对象。
    Réécriture :
    toString在类 Object
    Résultat La représentation sous forme de chaîne de cet objet.
  - toString
```
public static String toString(char c)
```
    Retourne un objetchar的Stringspécifié. Le résultat est une chaîne de longueur 1, composée uniquement duchar 。
    Note API : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthode
    toString(int). Paramètres
    c - 要转换的 char
    à convertir Résultat La représentation sous forme de chaîne du
    char的字符串表示 char
    Disponible depuis : 1.4
  - toString
```
public static String toString(int codePoint)
```
    Retourne un objetStringreprésentant le caractère spécifié (point de code Unicode). Le résultat est une chaîne de longueur 1 ou 2, composée uniquement ducodePoint 。
    Paramètres
    codePoint - 要转换的 codePoint
    à convertir Résultat La représentation sous forme de chaîne du
    codePoint的字符串表示 codePoint
    Exceptions
    IllegalArgumentException - 如果指定的 codePointspécifié n'est pas un valid Unicode code point. Disponible depuis : 11
  - isValidCodePoint
```
public static boolean isValidCodePoint(int codePoint)
```
    Détermine si le point de code spécifié est une valeur Unicode code point valide.
    Paramètres
    codePoint- le point de code Unicode à tester Résultat
    truetrue si la valeur du point de code spécifié est comprise entreMIN_CODE_POINTetMAX_CODE_POINT, sinonfalse. Disponible depuis : 1.5
  - isBmpCodePoint
```
public static boolean isBmpCodePoint(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) se trouve dans le Basic Multilingual Plane (BMP). Ces points de code peuvent être représentés avec un seulchar.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode) Résultat
    trueSi le point de code spécifié est compris entreMIN_VALUEetMAX_VALUE; sinon, la valeur estfalse. Disponible depuis la version : 1.7
  - isSupplementaryCodePoint
```
public static boolean isSupplementaryCodePoint(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) se trouve dans la plage des caractères supplémentaires (supplementary characters).
    Paramètres
    codePoint- Le caractère (point de code Unicode) à tester. Résultat
    trueSi le point de code spécifié est compris entreMIN_SUPPLEMENTARY_CODE_POINTetMAX_CODE_POINT; sinon, la valeur estfalse. Disponible depuis la version : 1.5
  - isHighSurrogate
```
public static boolean isHighSurrogate(char ch)
```
    Détermine si la valeurcharest une unité de code high-surrogate Unicode (également appelée unité de code de substitution haute). Ces valeurs ne représentent pas de caractères par elles-mêmes, mais servent dans l'encodage UTF-16 à représenter les caractères supplémentaires.
    
    Paramètres
    ch - 要测试的 charà tester. Résultat
    true如果charest comprise entreMIN_HIGH_SURROGATEetMAX_HIGH_SURROGATE; sinon, la valeur estfalse. Disponible depuis la version : 1.5. Voir aussi :
    isLowSurrogate(char),Character.UnicodeBlock.of(int)
  - isLowSurrogate
```
public static boolean isLowSurrogate(char ch)
```
    Détermine si la valeurcharest une unité de code low-surrogate Unicode (également appelée unité de code de substitution basse). Ces valeurs ne représentent pas de caractères par elles-mêmes, mais servent dans l'encodage UTF-16 à représenter les caractères supplémentaires.
    
    Paramètres
    ch - La valeur à tester char. Résultat
    true如果charest comprise entreMIN_LOW_SURROGATEetMAX_LOW_SURROGATE; sinon, la valeur estfalse. Disponible depuis la version : 1.5. Voir aussi :
    isHighSurrogate(char)
  - isSurrogate
```
public static boolean isSurrogate(char ch)
```
    Détermine si la valeurcharest une unité de code de substitution Unicode. Ces valeurs ne représentent pas de caractères par elles-mêmes, mais servent dans l'encodage UTF-16 à représenter les caractères supplémentaires.
    Une valeur char est une unité de code de substitution si et seulement si c'est une unité de code low-surrogate ou high-surrogate.
    
    Paramètres
    ch - 要测试的 charà tester. Résultat
    true如果charla valeur est comprise entreMIN_SURROGATEetMAX_SURROGATE, sinon falsefalse. Depuis la version : 1.7
  - isSurrogatePair
```
public static boolean isSurrogatePair(char high,
                                      char low)
```
    Détermine si la paire decharvaleurs spécifiée est une paire de substitution Unicode valide. Cette méthode équivaut à l'expression :
    
    isHighSurrogate(high) && isLowSurrogate(low)
    Paramètres
    high- La valeur de substitution haute à tester
    low- La valeur de substitution basse à tester. Résultat
    truetrue si les valeurs de substitution haute et basse spécifiées forment une paire de substitution valide ; sinon falsefalse. Depuis la version : 1.5
  - charCount
```
public static int charCount(int codePoint)
```
    Détermine le nombre de valeurscharnécessaires pour représenter le caractère spécifié (point de code Unicode). Si le caractère spécifié est supérieur ou égal à 0x10000, la méthode renvoie 2. Sinon, elle renvoie 1. Cette méthode ne valide pas le caractère comme point de code Unicode valide. Si nécessaire, l'appelant doit valider la valeur du caractère avec
    isValidCodePoint.
    
    Paramètres
    codePoint- Le caractère (point de code Unicode) à tester. Résultat 2 si le caractère est un caractère supplémentaire valide ; sinon 1. Depuis la version : 1.5 Voir aussi :
    isSupplementaryCodePoint(int)
  - toCodePoint
```
public static int toCodePoint(char high,
                              char low)
```
    Convertit la paire de substitution spécifiée en sa valeur de point de code supplémentaire. Cette méthode ne valide pas la paire de substitution spécifiée. Si nécessaire, l'appelant doit la valider avecisSurrogatePair.
    Paramètres
    high- L'unité de code de substitution haute
    low- L'unité de code de substitution basse. Résultat Le point de code supplémentaire formé par la paire de substitution spécifiée. Depuis la version : 1.5
  - codePointAt
```
public static int codePointAt(CharSequence seq,
                              int index)
```
    Renvoie le point de code à l'index donnéCharSequencedechar. Si la valeurCharSequenceà l'index donné se trouve dans la plage de substitution haute, si l'index suivant est inférieur à la longueurCharSequence ，并且charla valeur à l'index suivant se trouve dans la plage de substitution basse, la méthode renvoie le point de code correspondant à cette paire de substitution. Sinon, elle renvoie la valeurchar值。
    Paramètres
    seq - Un tableau de charvaleurs (unités de code Unicode)
    index - 要转换的 charvaleur (unité de code Unicode) à convertir seq
    Résultat Le point de code Unicode à l'index donné. Exception
    NullPointerException - 如果 seqest vide.
    IndexOutOfBoundsException - 如果值 indexest négative ou n'est pas inférieure àseq.length(). Disponible depuis la version : 1.5
  - codePointAt
```
public static int codePointAt(char[] a,
                              int index)
```
    Retournecharle point de code à l'index donné du tableau. Sichar数组中给定索引处的charSi la valeur se situe dans la plage de proxy élevée, l'index suivant est inférieur àcharla longueur du tableau, et aux index suivantscharWert im Bereich des niedrigen Surrogats liegt, wird der zu diesem Surrogatpaar gehörende ergänzende Codepoint geliefert. Andernfalls wird der Wertchar值。
    Parameter
    a - Les tableaux char
    
    index - 要转换的 char数组中 charWert (Unicode-Codeeinheit) des char
    
    结果
    
    给定索引处的Unicode代码点
    
    异常
    
    NullPointerException - 如果 aest vide.
    IndexOutOfBoundsException - 如果值 indexest négative ou n'est pas inférieure à charla longueur du tableau. Depuis la version : 1.5
  - codePointAt
```
public static int codePointAt(char[] a,
                              int index,
                              int limit)
```
    renvoiecharle point de code à l'index donné du tableau, où seuls peuvent être utilisésindex小于limitles éléments du tableau. Sichar数组中给定索引处的charse trouve dans la plage des substituts hauts, que l'index suivant est inférieurlimit et que la valeur à l'index suivantcharse trouve dans la plage des substituts bas, alors le point de code supplémentaire correspondant à cette paire de substituts est renvoyé. Sinon, la valeur à l'index donné duchar值。
    Paramètres
    a - chartableau
    index - 要转换的 char数组中 charWert (Unicode-Codeeinheit) des char
    
    limit - an charErgebnis den Index nach dem letzten Arrayelement im verwendeten Array. Den Unicode-Codepoint am angegebenen Index. Ausnahme
    NullPointerException - 如果 aist null.
    IndexOutOfBoundsException - 如果 index参数为负或不小于 limitParameter oder limitParameter negativ oder größer als charLänge des Arrays. Ab Version: 1.5
  - codePointBefore
```
public static int codePointBefore(CharSequence seq,
                                  int index)
```
    liefertCharSequenceCodepoint vor dem angegebenen Index. Wennchar在值(index - 1)在CharSequenceim Bereich des niedrigen Surrogats liegt, (index - 2)不为负，并且char在值(index - 2)在CharSequenceLiegt das Array im Bereich des High Surrogates, wird der zu diesem Surrogatpaar gehörende ergänzende Codepoint geliefert. Andernfalls wirdchar值(index - 1) 。
    Parameter
    seq - CharSequenceInstanz
    index- Index nach dem zurückzugebenden Codepoint. Ergebnis den Codepointwert vor dem angegebenen Index. Ausnahme
    NullPointerException - 如果 seqist null.
    IndexOutOfBoundsException - 如果 indexDas Argument kleiner als 1 oder größer alsseq.length(). Ab Version: 1.5
  - codePointBefore
```
public static int codePointBefore(char[] a,
                                  int index)
```
    liefertcharCodepoint vor dem angegebenen Index des Arrays. Wennchar在值(index - 1)中char阵列是在低代理项范围， (index - 2)不为负，并且char在值(index - 2)中charSi la valeur du tableau se trouve dans la plage des hauts substituants, la paire de points de code supplémentaires correspondant à ce substitut est renvoyée. Sinon, lachar值(index - 1) 。
    Paramètres
    a - chartableau
    index- l'index suivant le point de code à renvoyer. Résultat La valeur du point de code Unicode avant l'index donné. Exceptions
    NullPointerException - 如果 aest nul.
    IndexOutOfBoundsException - 如果 indexle paramètre est inférieur à 1 ou supérieur à charla longueur du tableau. Depuis : 1.5
  - codePointBefore
```
public static int codePointBefore(char[] a,
                                  int index,
                                  int start)
```
    Renvoiecharle point de code précédant l'index donné du tableau, où seuls lesindex大于或等于startsont utilisés. Si lachar在值(index - 1)中char阵列是在低代理项范围， (index - 2)不小于start ，并且char在值(index - 2)中chartableau se trouve dans la plage des hauts substituants, la paire de points de code supplémentaires correspondant à ce substitut est renvoyée. Sinon, lachar值(index - 1) 。
    Paramètres
    a - chartableau
    index- l'index suivant le point de code à renvoyer
    start - charle premier élément du tableau char
    Résultat La valeur du point de code Unicode avant l'index donné. Exceptions
    NullPointerException - 如果 aest nul.
    IndexOutOfBoundsException - 如果 indexle paramètre n'est pas supérieur au paramètre startou est supérieur à char数组的长度，或者 start参数为负或不小于 charla longueur du tableau. Depuis la version : 1.5
  - highSurrogate
```
public static char highSurrogate(int codePoint)
```
    Retourne l'unité de code de substitution haute (high surrogate code unit) de la paire de substitution représentant le caractère supplémentaire (point de code Unicode) spécifié en encodage UTF-16. Si le caractère spécifié n'est pas un supplementary character, la valeur retournée n'est pas définie char. Si
    isSupplementaryCodePoint(x)是true, alorsisHighSurrogate (highSurrogate(x))ettoCodePoint (highSurrogate(x), lowSurrogate (x)) == x也总是true 。
    
    Paramètres
    codePoint- le caractère supplémentaire (point de code Unicode) Résultat l'unité de code de substitution haute utilisée pour représenter le caractère en encodage UTF-16 Depuis la version : 1.7
  - lowSurrogate
```
public static char lowSurrogate(int codePoint)
```
    Retourne l'unité de code de substitution basse (low surrogate code unit) de la paire de substitution représentant le caractère supplémentaire (point de code Unicode) spécifié en encodage UTF-16. Si le caractère spécifié n'est pas un supplementary character, la valeur retournée n'est pas définie char. Si
    isSupplementaryCodePoint(x)是true, alorsisLowSurrogate (lowSurrogate(x))ettoCodePoint ( highSurrogate (x), lowSurrogate(x)) == x也总是true 。
    
    Paramètres
    codePoint- le caractère supplémentaire (point de code Unicode) Résultat l'unité de code de substitution basse utilisée pour représenter le caractère en encodage UTF-16 Depuis la version : 1.7
  - toChars
```
public static int toChars(int codePoint,
                          char[] dst,
                          int dstIndex)
```
    Convertit le caractère spécifié (point de code Unicode) en sa représentation UTF-16. Si le point de code spécifié est une valeur BMP (plan multilingue de base ou plan 0), la même valeur est stockée dansdst[dstIndex]et la méthode retourne 1. Si le point de code spécifié est un caractère supplémentaire, ses valeurs de substitution sont stockées dansdst[dstIndex] (high-surrogate) etdst[dstIndex+1](low-surrogate), et la méthode retourne 2.
    Paramètres
    codePoint- le caractère (point de code Unicode) à convertir.
    dst - le tableau char dans lequel codePointles valeurs UTF-16 sont stockées.
    dstIndex - l'index de début dans le tableau dstoù la valeur convertie est stockée. Résultat 1 si le point de code est un point de code BMP, 2 si le point de code est un point de code supplémentaire. Exceptions
    IllegalArgumentException - 如果指定的 codePointspécifié n'est pas un point de code Unicode valide.
    NullPointerException - 如果指定的 dstspécifié est nul.
    IndexOutOfBoundsException - 如果dstIndexest négatif ou n'est pas inférieur àdst.length ，或者如果dst在dstIndexpas assez d'éléments pour stocker lescharvaleurs générées. (SidstIndex等于dst.length-1et que lecodePointspécifié est un caractère supplémentaire, la valeur de l'agent haut n'est pas stockée dansdst[dstIndex].) Depuis la version : 1.5
  - toChars
```
public static char[] toChars(int codePoint)
```
    Convertit le caractère spécifié (point de code Unicode) en sa représentation UTF-16 stockée dans le tableauchar. Si le point de code spécifié est une valeur BMP (plan multilingue de base ou plan 0), le tableauchargénéré a les mêmes valeurs quecodePoint. Si le point de code spécifié est un point de code supplémentaire, le tableauchargénéré contient la paire d'agents correspondante.
    Paramètres
    codePoint- point de code Unicode Résultat Le tableau
    codePointcontenant la représentation UTF-16 de char. Exceptions
    IllegalArgumentException - 如果指定的 codePointspécifié n'est pas un point de code Unicode valide. Depuis la version : 1.5
  - codePointCount
```
public static int codePointCount(CharSequence seq,
                                 int beginIndex,
                                 int endIndex)
```
    Retourne le nombre de points de code Unicode dans la plage de texte de la séquence de char spécifiée. La plage de texte commence à l'indexbeginIndex spécifié et s'étend jusqu'àcharà l'indexendIndex - 1. La longueur de la plage de texte (enchar s) est doncendIndex-beginIndex. Les agents non appariés dans la plage de texte comptent pour un point de code chacun.
    Paramètres
    seq- séquence de caractères
    beginIndex - l'index du premier charde la plage de texte.
    endIndex - l'index après le dernier charde la plage de texte. Résultat Le nombre de points de code Unicode dans la plage de texte spécifiée Exceptions
    NullPointerException - 如果 seqest nul.
    IndexOutOfBoundsException - 如果 beginIndex为负数，或者 endIndexest supérieur à la longueur de la séquence donnée, ou si beginIndexest supérieur à endIndex. Depuis la version : 1.5
  - codePointCount
```
public static int codePointCount(char[] a,
                                 int offset,
                                 int count)
```
    Retournecharle nombre de points de code Unicode dans le sous-tableau du paramètre tableau.offsetLe paramètre est le premiercharindice du sous-tableau, count参数指定char s chardu tableau. Les substituts non appariés dans le sous-tableau comptent pour un point de code chacun.
    Paramètres
    a - chartableau
    offset - le premier charindice dans le tableau donné char-
    count - charla longueur du tableau. Résultat : le nombre de points de code Unicode dans le sous-tableau spécifié. Exceptions
    NullPointerException - 如果 aest nul.
    IndexOutOfBoundsException - 如果 offsetou count为负数，或者 offset + countest supérieur à la longueur du tableau donné. Depuis : 1.5
  - offsetByCodePoints
```
public static int offsetByCodePoints(CharSequence seq,
                                     int index,
                                     int codePointOffset)
```
    Retourne l'indice dans la séquence de char donnée, décalé deindex偏移codePointOffsetdonné, en points de code.index和codePointOffsetet
    comptent pour un point de code chacun.
    seqParamètres
    index- séquence de caractères
    codePointOffset- l'indice à décaler
    NullPointerException - 如果 seq- si
    IndexOutOfBoundsException - 如果 index- si codePointOffsetest négatif ou supérieur à la longueur de la séquence de char, ou si indexest positif et si le sous- index少于 codePointOffset代码点，或者如果 codePointOffsetest négatif et indexLe sous- précédent indexInférieur à la valeur absolue codePointOffsetPoint de code. Disponible à partir de la version : 1.5
  - offsetByCodePoints
```
public static int offsetByCodePoints(char[] a,
                                     int start,
                                     int count,
                                     int index,
                                     int codePointOffset)
```
    Retourne l'index donné.charUn sous-tableau part d'un décalage donné.index由codePointOffsetpoint de code.start和count参数指定chardu sous-tableau du tableau. Les substituts non appariés dans la plage de texte délimitée parindex和codePointOffsetcomptent pour un point de code chacun.
    Paramètre
    a - chartableau
    start - index du premier élément du sous-tableau charde
    count - charLa longueur du tableau
    index- L'index de décalage
    codePointOffset- Le décalage en points de code. Résultat : l'index dans le sous-tableau. Exceptions
    NullPointerException - 如果 aest nul.
    IndexOutOfBoundsException - 如果 startou countest négatif, ou si start + countest supérieur à la longueur du tableau donné, ou si index小于 startou plus grand, alors start + count , ou codePointOffsetest positif et la plage de texte se termine indexet se termine par start + count - 1avec moins de codePointOffset代码点，或者如果 codePointOffsetest négatif et la plage de texte commence start et se termine par index - 1avec une valeur absolue inférieure à codePointOffsetpoints de code. Disponible depuis : 1.5
  - isLowerCase
```
public static boolean isLowerCase(char ch)
```
    Détermine si le caractère spécifié est en minuscule. Un caractère est en minuscule si
    Character.getType(ch)sa catégorie générale fournie parLOWERCASE_LETTERest de type LOWERCASE, ou s'il possède la propriété contributive Other_Lowercase définie par le standard Unicode.
    Voici des exemples de caractères en minuscule :
    
    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'
    
    De nombreux autres caractères Unicode sont aussi en minuscule.
    Remarque : Cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisLowerCase(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère est en minuscule, sinonfalsefalse. Voir aussi :
    isLowerCase(char),isTitleCase(char),toLowerCase(char),getType(char)
  - isLowerCase
```
public static boolean isLowerCase(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est en minuscule. Un caractère est en minuscule si
    getType(codePoint)提供）为LOWERCASE_LETTER) est de type LOWERCASE, ou s'il possède la propriété contributive Other_Lowercase définie par le standard Unicode.
    Voici des exemples de caractères en minuscule :
    
    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'
    
    De nombreux autres caractères Unicode sont aussi en minuscule.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère est en minuscule, sinonfalsefalse. Depuis la version : 1.5 Voir aussi :
    isLowerCase(int),isTitleCase(int),toLowerCase(int),getType(int)
  - isUpperCase
```
public static boolean isUpperCase(char ch)
```
    Détermine si le caractère spécifié est en majuscule. Un caractère est en majuscule si sa catégorie générale, fournie par
    Character.getType(ch) ，是UPPERCASE_LETTERUPPERCASE. Ou s'il possède la propriété contributive Other_Uppercase définie par le standard Unicode.
    Voici des exemples de caractères en majuscule :
    
    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'
    
    De nombreux autres caractères Unicode sont aussi en majuscule.
    Remarque : Cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisUpperCase(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère est en majuscule, sinonfalsefalse. Depuis la version : 1.0 Voir aussi :
    isLowerCase(char),isTitleCase(char),toUpperCase(char),getType(char)
  - isUpperCase
```
public static boolean isUpperCase(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est une lettre majuscule. Si la catégorie générale du caractère (fournie par
    getType(codePoint)提供）为UPPERCASE_LETTER, ou s'il possède la propriété contributive Other_Uppercase définie par le standard Unicode, alors le caractère est une majuscule.
    Voici des exemples de lettres majuscules :
    
    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'
    
    De nombreux autres caractères Unicode sont aussi des majuscules.
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truetrue si le caractère est une majuscule ; sinonfalsefalse. Depuis la version : 1.5 Voir aussi :
    isLowerCase(int),isTitleCase(int),toUpperCase(int),getType(int)
  - isTitleCase
```
public static boolean isTitleCase(char ch)
```
    Détermine si le caractère spécifié est une lettre de titre. Un caractère est une lettre de titre si sa catégorie générale, fournie par
    Character.getType(ch) ，是TITLECASE_LETTER 。
    Certains caractères ressemblent à une paire de lettres latines. Par exemple, il existe une lettre majuscule qui ressemble à « LJ » et une lettre minuscule correspondante qui ressemble à « lj ». Une troisième forme, qui ressemble à « Lj », est la forme appropriée pour présenter un mot en minuscules avec une majuscule initiale, comme dans un titre de livre.
    Voici les caractères Unicode pour lesquels cette méthode renvoietruetrue :
    
    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
    De nombreux autres caractères Unicode sont aussi des lettres de titre.
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisTitleCase(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère est une lettre de titre ; sinonfalsefalse. Depuis la version : 1.0.2 Voir aussi :
    isLowerCase(char),isUpperCase(char),toTitleCase(char),getType(char)
  - isTitleCase
```
public static boolean isTitleCase(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est une lettre de titre. Un caractère est une lettre de titre si sa catégorie générale, fournie par
    getType(codePoint) ，是TITLECASE_LETTER 。
    Certains caractères ressemblent à une paire de lettres latines. Par exemple, il existe une lettre majuscule qui ressemble à « LJ » et une lettre minuscule correspondante qui ressemble à « lj ». Une troisième forme, qui ressemble à « Lj », est la forme appropriée pour présenter un mot en minuscules avec une majuscule initiale, comme dans un titre de livre.
    Voici les caractères Unicode pour lesquels cette méthode renvoietruetrue :
    
    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
    Beaucoup d'autres caractères Unicode sont aussi des titres.
    Paramètres
    codePoint- Le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère est un titre, sinonfalsefalse. Disponible depuis : 1.5. Voir aussi :
    isLowerCase(int),isUpperCase(int),toTitleCase(int),getType(int)
  - isDigit
```
public static boolean isDigit(char ch)
```
    Détermine si le caractère spécifié est un chiffre. Un caractère est un chiffre si son type de catégorie générale, fourni par
    Character.getType(ch) ，是DECIMAL_DIGIT_NUMBER 。
    Certaines plages de caractères Unicode contenant des chiffres :
    
    '\u0030'到'\u0039' à '0'到'9' ）
    
    '\u0660'到'\u0669'de
    
    '\u06F0'到'\u06F9', les chiffres arabo-indiens
    
    '\u0966'到'\u096F'à
    
    '\uFF10'至'\uFF19' ， '\uFF19'数字
    ,
    isDigit(int)chiffres.
    Paramètres
    ch- Le caractère à tester. Résultat
    truetrue si le caractère est un chiffre, sinonfalsefalse. Voir aussi :
    digit(char, int),forDigit(int, int),getType(char)
  - isDigit
```
public static boolean isDigit(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est un chiffre. Un caractère est un chiffre si son type de catégorie générale, fourni par
    getType(codePoint) ，是DECIMAL_DIGIT_NUMBER 。
    Certaines plages de caractères Unicode contenant des chiffres :
    
    '\u0030'到'\u0039' , chiffres ISO-LATIN-1 ( '0'到'9' ）
    
    '\u0660'到'\u0669', chiffres arabo-indiens
    
    '\u06F0'到'\u06F9', chiffres arabo-indiens étendus
    
    '\u0966'到'\u096F', chiffres devanagari
    
    '\uFF10'到'\uFF19', chiffres pleine largeur
    De nombreuses autres plages de caractères contiennent aussi des chiffres.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère est un chiffre ; sinonfalse. Depuis la version : 1.5 Voir aussi :
    forDigit(int, int),getType(int)
  - isDefined
```
public static boolean isDefined(char ch)
```
    Détermine si un caractère est défini dans Unicode. Un caractère est défini si au moins une des conditions suivantes est remplie :
    Il possède une entrée dans le fichier UnicodeData.
    Il a une valeur dans une plage définie par le fichier UnicodeData.
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisDefined(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère a une signification définie dans Unicode ; sinonfalse. Depuis la version : 1.0.2 Voir aussi :
    isDigit(char),isLetter(char),isLetterOrDigit(char),isLowerCase(char),isTitleCase(char),isUpperCase(char)
  - isDefined
```
public static boolean isDefined(int codePoint)
```
    Détermine si un caractère est défini dans Unicode (point de code Unicode). Un caractère est défini si au moins une des conditions suivantes est remplie :
    Il possède une entrée dans le fichier UnicodeData.
    Il a une valeur dans une plage définie par le fichier UnicodeData.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère a une signification définie dans Unicode ; sinonfalse. Depuis la version : 1.5 Voir aussi :
    isDigit(int)，isLetter(int)，isLetterOrDigit(int)，isLowerCase(int)，isTitleCase(int)，isUpperCase(int)
  - isLetter
```
public static boolean isLetter(char ch)
```
    Détermine si le caractère spécifié est une lettre. Un caractère est considéré comme une lettre si sa catégorie générale (fournie par
    Character.getType(ch)) correspond à l'un des types suivants :
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    Toutes les lettres n'ont pas de casse. Beaucoup de caractères sont des lettres, mais ne sont ni majuscules, ni minuscules, ni lettres majuscules de titre. Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez la méthode
    isLetter(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère est une lettre ;falsesinon. Voir aussi :
    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)
```
    Détermine si le caractère spécifié (point de code Unicode) est une lettre. Un caractère est considéré comme une lettre si sa catégorie générale (fournie par
    getType(codePoint)) correspond à l'un des types suivants :
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    Toutes les lettres n'ont pas de casse. Beaucoup de caractères sont des lettres, mais ne sont ni majuscules, ni minuscules, ni lettres majuscules de titre.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère est une lettre ; sinonfalse. Depuis la version : 1.5 Voir aussi :
    isDigit(int)，isJavaIdentifierStart(int)，isLetterOrDigit(int)，isLowerCase(int)，isTitleCase(int)，isUnicodeIdentifierStart(int)，isUpperCase(int)
  - isLetterOrDigit
```
public static boolean isLetterOrDigit(char ch)
```
    Détermine si le caractère spécifié est une lettre ou un chiffre. Un caractère est considéré comme une lettre ou un chiffre si
    Character.isLetter(char ch)ou 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)der Methode.
    
    Parameter
    ch- zu prüfendes Zeichen. Ergebnis
    truewenn das Zeichen ein Buchstabe oder eine Ziffer ist, andernfalls false. Ab 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)
```
    Bestimmt, ob das angegebene Zeichen (Codepoint) ein Buchstabe oder eine Ziffer ist. Ein Zeichen gilt dann als Buchstabe oder Ziffer, wenn es entweder Buchstabe oder Ziffer
    isLetter(codePoint)oder isDigit(codePoint)回报true的字符。
    
    Parameter
    codePoint- zu prüfendes Zeichen (Codepoint). Ergebnis
    truewenn das Zeichen ein Buchstabe oder eine Ziffer ist, andernfalls false. Ab Version: 1.5. Siehe auch:
    isDigit(int)，isJavaIdentifierPart(int)，isLetter(int)，isUnicodeIdentifierPart(int)
  - isJavaLetter
```
@Deprecated(since="1.1")
public static boolean isJavaLetter(char ch)
```
    Deprecated. Replaced by isJavaIdentifierStart(char).
    Bestimmt, ob das angegebene Zeichen als erstes Zeichen eines Java-Bezeichners zulässig ist. Ein Zeichen darf einen Java-Bezeichner nur unter einer der folgenden Bedingungen beginnen:
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER
    
    ch是货币符号（例如'$' ）
    
    ch是连接标点字符（例如'_' ）。
    Parameter
    ch- zu prüfendes Zeichen. Ergebnis
    true, wenn das Zeichen einen Java-Bezeichner beginnen kann, andernfallsfalse. Ab 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)
```
    Deprecated. Remplacé par isJavaIdentifierPart(char).
    Détermine si le caractère spécifié peut faire partie d'un identifiant Java, autre que le premier caractère. Un caractère peut faire partie d'un identifiant Java si et seulement si l'une des conditions suivantes est remplie :
    C'est une lettre.
    C'est un symbole monétaire (par exemple'$' ）
    C'est un caractère de ponctuation de liaison (par exemple'_' ）
    C'est un chiffre.
    C'est un caractère alphanumérique (par exemple un chiffre romain).
    C'est une marque combinante.
    C'est une marque non espacée.
    
    isIdentifierIgnorableRetournetrue 。
    Paramètres
    ch- le caractère à tester. Résultat
    truesi le caractère peut faire partie d'un identifiant Java, sinonfalse. Depuis la version : 1.0.2. Voir aussi :
    isJavaLetter(char),isJavaIdentifierStart(char),isJavaIdentifierPart(char),isLetter(char),isLetterOrDigit(char),isUnicodeIdentifierPart(char),isIdentifierIgnorable(char)
  - isAlphabetic
```
public static boolean isAlphabetic(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est une lettre. Un caractère est considéré comme une lettre si sa catégorie générale (fournie par
    getType(codePoint)) est l'une des suivantes, ou s'il possède la propriété Other_Alphabetic définie par la norme Unicode.
    
    UPPERCASE_LETTER
    
    LOWERCASE_LETTER
    
    TITLECASE_LETTER
    
    MODIFIER_LETTER
    
    OTHER_LETTER
    
    LETTER_NUMBER
    
    或者它具有由Unicode标准定义的贡献属性Other_Alphabetic.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truesi le caractère est une lettre Unicode, false. Depuis la version : 1.7.
  - isIdeographic
```
public static boolean isIdeographic(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est un idéogramme CJKV (chinois, japonais, coréen et vietnamien) défini par la norme Unicode.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truesi le caractère est un idéogramme Unicode, false. Depuis la version : 1.7.
  - isJavaIdentifierStart
```
public static boolean isJavaIdentifierStart(char ch)
```
    Détermine si le caractère spécifié est autorisé comme premier caractère d'un identifiant Java. Le caractère peut démarrer un identifiant Java si et seulement si l'une des conditions suivantes est remplie :
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER
    
    ch是货币符号（例如'$' ）
    
    ch是连接标点字符（例如'_' ）。
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisJavaIdentifierStart(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère peut démarrer un identifiant Java, sinonfalse. Depuis la version : 1.1 Voir aussi :
    isJavaIdentifierPart(char),isLetter(char),isUnicodeIdentifierStart(char),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierStart
```
public static boolean isJavaIdentifierStart(int codePoint)
```
    Détermine si le caractère (point de code Unicode) est autorisé comme premier caractère d'un identifiant Java. Le caractère peut démarrer un identifiant Java si et seulement si l'une des conditions suivantes est remplie :
    
    isLetter(codePoint)返回true
    
    getType(codePoint)返回LETTER_NUMBER
    le caractère référencé est un symbole monétaire (par exemple'$' ）
    le caractère référencé est un caractère de ponctuation de liaison (par exemple'_' ）。
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truetrue si le caractère peut démarrer un identifiant Java, sinonfalse. Depuis la version : 1.5 Voir aussi :
    isJavaIdentifierPart(int),isLetter(int),isUnicodeIdentifierStart(int),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierPart
```
public static boolean isJavaIdentifierPart(char ch)
```
    Détermine si le caractère spécifié peut faire partie d'un identifiant Java, autre que le premier caractère. Le caractère peut faire partie d'un identifiant Java si l'une des conditions suivantes est remplie :
    c'est une lettre
    c'est un symbole monétaire (par exemple'$' ）
    c'est un caractère de ponctuation de liaison (par exemple'_' ）
    c'est un chiffre
    C'est une lettre numérique (par exemple un chiffre romain).
    C'est une marque combinante.
    C'est une marque non espacée.
    
    isIdentifierIgnorable回报true的字符
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisJavaIdentifierPart(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère peut faire partie d'un identifiant Java, sinonfalsefalse. Depuis la version : 1.1 Voir aussi :
    isIdentifierIgnorable(char),isJavaIdentifierStart(char),isLetterOrDigit(char),isUnicodeIdentifierPart(char),SourceVersion.isIdentifier(CharSequence)
  - isJavaIdentifierPart
```
public static boolean isJavaIdentifierPart(int codePoint)
```
    Détermine si le caractère (point de code Unicode) peut faire partie d'un identifiant Java, autrement que comme premier caractère. Un caractère peut faire partie d'un identifiant Java si l'une des conditions suivantes est remplie :
    C'est une lettre.
    C'est un symbole monétaire (par exemple'$' ）
    C'est un caractère de ponctuation de liaison (par exemple'_' ）
    C'est un chiffre.
    C'est une lettre numérique (par exemple un chiffre romain).
    C'est une marque combinante.
    C'est une marque non espacée.
    
    isIdentifierIgnorable(codePoint)Retourtrue的字符
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truetrue si le caractère peut faire partie d'un identifiant Java, sinonfalsefalse. Depuis la version : 1.5 Voir aussi :
    isIdentifierIgnorable(int),isJavaIdentifierStart(int),isLetterOrDigit(int),isUnicodeIdentifierPart(int),SourceVersion.isIdentifier(CharSequence)
  - isUnicodeIdentifierStart
```
public static boolean isUnicodeIdentifierStart(char ch)
```
    Détermine si le caractère spécifié est autorisé comme premier caractère d'un identifiant Unicode. Un caractère peut commencer un identifiant Unicode si et seulement si l'une des conditions suivantes est remplie :
    
    isLetter(ch)返回true
    
    getType(ch)返回LETTER_NUMBER 。
    Hinweis: Diese Methode verarbeitet keine ergänzenden Zeichen. Für alle Unicode-Zeichen einschließlich der ergänzenden verwenden SieisUnicodeIdentifierStart(int)。
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère peut commencer un identifiant Unicode ; sinon falsefalse。 Depuis la version : 1.1 Voir aussi :
    isJavaIdentifierStart(char)，isLetter(char)，isUnicodeIdentifierPart(char)
  - isUnicodeIdentifierStart
```
public static boolean isUnicodeIdentifierStart(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est autorisé comme premier caractère d'un identifiant Unicode. Un caractère peut commencer un identifiant Unicode si et seulement si l'une des conditions suivantes est remplie :
    
    isLetter(codePoint)返回true
    
    getType(codePoint)返回LETTER_NUMBER 。
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère peut commencer un identifiant Unicode ; sinon falsefalse。 Depuis la version : 1.5 Voir aussi :
    isJavaIdentifierStart(int)，isLetter(int)，isUnicodeIdentifierPart(int)
  - isUnicodeIdentifierPart
```
public static boolean isUnicodeIdentifierPart(char ch)
```
    Détermine si le caractère spécifié peut faire partie d'un identifiant Unicode, autrement que comme premier caractère. Un caractère peut faire partie d'un identifiant Unicode si et seulement si l'une des affirmations suivantes est vraie :
    C'est une lettre
    C'est un caractère de ponctuation de liaison (comme'_' ）
    C'est un chiffre
    C'est un caractère alphanumérique (par exemple un chiffre romain)
    C'est une marque combinante
    C'est une marque non espacée
    
    isIdentifierIgnorable返回truece caractère.
    Hinweis: Diese Methode verarbeitet keine ergänzenden Zeichen. Für alle Unicode-Zeichen einschließlich der ergänzenden verwenden SieisUnicodeIdentifierPart(int)。
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère peut faire partie d'un identifiant Unicode ; sinon falsefalse。 Depuis la version : 1.1 Voir aussi :
    isIdentifierIgnorable(char)，isJavaIdentifierPart(char)，isLetterOrDigit(char)，isUnicodeIdentifierStart(char)
  - isUnicodeIdentifierPart
```
public static boolean isUnicodeIdentifierPart(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) peut faire partie d'un identifiant Unicode, sans être le premier caractère. Un caractère peut faire partie d'un identifiant Unicode si et seulement si l'une des affirmations suivantes est vraie :
    C'est une lettre
    C'est un caractère de ponctuation de liaison (comme'_' ）
    C'est un chiffre
    C'est un caractère alphanumérique (par exemple un chiffre romain)
    C'est une marque combinante
    C'est une marque non espacée
    
    isIdentifierIgnorableRetournetrue 。
    Paramètres
    codePoint- Le caractère (point de code Unicode) à tester. Résultat
    trueLe résultat est vrai si le caractère peut faire partie d'un identifiant Unicode. Sinon, il vautfalse. Depuis la version : 1.5 Voir aussi :
    isIdentifierIgnorable(int),isJavaIdentifierPart(int),isLetterOrDigit(int),isUnicodeIdentifierStart(int)
  - isIdentifierIgnorable
```
public static boolean isIdentifierIgnorable(char ch)
```
    Détermine si le caractère spécifié doit être considéré comme un caractère ignorable dans un identifiant Java ou un identifiant Unicode. Les caractères Unicode suivants sont ignorables dans un identifiant Java ou un identifiant Unicode :
    Les caractères de contrôle ISO qui ne sont pas des espaces
    '\u0000'至'\u0008'
    
    '\u000E'至'\u001B'
    
    '\u007F'至'\u009F'
    
    Tous les caractères ayantFORMATcomme valeur de catégorie générale
    Remarque : Cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisIdentifierIgnorable(int).
    Paramètres
    ch- Le caractère à tester. Résultat
    trueLe résultat est vrai si le caractère est un caractère de contrôle ignorable, pouvant faire partie d'un identifiant Java ou Unicode. Sinon, il vautfalse. Depuis la version : 1.1 Voir aussi :
    isJavaIdentifierPart(char),isUnicodeIdentifierPart(char)
  - isIdentifierIgnorable
```
public static boolean isIdentifierIgnorable(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) doit être considéré comme un caractère ignorable dans un identifiant Java ou un identifiant Unicode. Les caractères Unicode suivants sont ignorables dans un identifiant Java ou un identifiant Unicode :
    Les caractères de contrôle ISO qui ne sont pas des espaces
    '\u0000'至'\u0008'
    
    '\u000E'至'\u001B'
    
    '\u007F'至'\u009F'
    
    Tous les caractères ayantFORMATtous les caractères de la catégorie de valeur générale
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truetrue si le caractère est un caractère de contrôle ignorable, pouvant faire partie d'un identifiant Java ou Unicode, sinonfalsefalse. Depuis : 1.5 Voir aussi :
    isJavaIdentifierPart(int),isUnicodeIdentifierPart(int)
  - toLowerCase
```
public static char toLowerCase(char ch)
```
    Convertit l'argument caractère en minuscule avec les informations de mappage de casse du fichier UnicodeData. Notez que pour certaines plages de caractères,
    Character.isLowerCase(Character.toLowerCase(ch))并不总是返回true, en particulier pour les symboles et les idéogrammes.
    En général, utilisezString.toLowerCase()pour convertir un caractère en minuscule.String案例映射方法比Characterla méthode de mappage de casse Character.StringLa méthode String peut effectuer des mappages sensibles aux paramètres régionaux, des mappages contextuels et des mappages de caractères 1:M, alors queCharacterla méthode Character ne le peut pas.
    Remarque : cette méthode ne gère pas les caractères supplémentaires (supplementary characters). Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodetoLowerCase(int).
    
    Paramètres
    ch- le caractère à convertir. Résultat l'équivalent en minuscule du caractère, s'il existe, sinon le caractère lui-même. Voir aussi :
    isLowerCase(char),String.toLowerCase()
  - toLowerCase
```
public static int toLowerCase(int codePoint)
```
    Convertit l'argument caractère (point de code Unicode) en minuscule avec les informations de mappage de casse du fichier UnicodeData. Notez que pour certaines plages de caractères,
    Character.isLowerCase(Character.toLowerCase(codePoint))并不总是返回true, en particulier pour les symboles et les idéogrammes.
    En général, utilisezString.toLowerCase()pour convertir un caractère en minuscule.String案例映射方法比Characterla méthode de mappage de casse Character.StringLa méthode String peut effectuer des mappages sensibles aux paramètres régionaux, des mappages contextuels et des mappages de caractères 1:M, alors queCharacterla méthode Character ne le peut pas.
    
    Paramètres
    codePoint- le caractère (point de code Unicode) à convertir. Résultat l'équivalent en minuscule du caractère (point de code Unicode), s'il existe, sinon le caractère lui-même. Depuis : 1.5 Voir aussi :
    isLowerCase(int),String.toLowerCase()
  - toUpperCase
```
public static char toUpperCase(char ch)
```
    Convertit l'argument caractère en majuscule avec les informations de mappage de casse du fichier UnicodeData. Notez que pour certaines plages de caractères,
    Character.isUpperCase(Character.toUpperCase(ch))并不总是返回true, en particulier pour les symboles et les idéogrammes.
    En général, utilisezString.toUpperCase()pour convertir un caractère en majuscule.String案例映射方法比CharacterLa méthode de mappage de casse présente plusieurs avantages.StringLa méthode de mappage de casse effectue des mappages sensibles aux paramètres régionaux, des mappages contextuels et des mappages 1:M de caractères, alors queCharacterla méthode de mappage de casse ne le fait pas.
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez latoUpperCase(int)méthode.
    
    Paramètres
    ch- le caractère à convertir. Résultat : l'équivalent en majuscule du caractère, s'il existe ; sinon, le caractère lui-même. Voir aussi :
    isUpperCase(char),String.toUpperCase()
  - toUpperCase
```
public static int toUpperCase(int codePoint)
```
    Convertit le paramètre caractère (point de code Unicode) en majuscule à partir des informations de mappage de casse du fichier UnicodeData. Notez que pour certaines plages de caractères,
    Character.isUpperCase(Character.toUpperCase(codePoint))并不总是返回true, en particulier pour les symboles ou les idéogrammes.
    En général, utilisezString.toUpperCase()pour convertir un caractère en majuscule.String案例映射方法比CharacterLa méthode de mappage de casse présente plusieurs avantages.StringLa méthode de mappage de casse effectue des mappages sensibles aux paramètres régionaux, des mappages contextuels et des mappages 1:M de caractères, alors queCharacterla méthode de mappage de casse ne le fait pas.
    
    Paramètres
    codePoint- le caractère à convertir (point de code Unicode). Résultat : l'équivalent en majuscule du caractère, s'il existe ; sinon, le caractère lui-même. Depuis la version : 1.5 Voir aussi :
    isUpperCase(int),String.toUpperCase()
  - toTitleCase
```
public static char toTitleCase(char ch)
```
    Wandelt das Zeichenargument anhand der Fall-Mappings aus der Datei UnicodeData in einen Titel um. Hat ein Zeichen kein ausdrückliches Titel-Mapping und ist es nach UnicodeData selbst kein Titelzeichen, liefert die Großbuchstabenmapping dieses Zeichen als gleichwertiges Titel-Mapping. Istchar参数已经是标题char , la même valeurcharest renvoyée. Notez que pour certaines plages de caractères,
    Character.isTitleCase(Character.toTitleCase(ch))并不总是返回true 。
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez latoTitleCase(int)méthode.
    
    Paramètres
    ch- le caractère à convertir. Résultat : l'équivalent en casse de titre du caractère, s'il existe ; sinon, le caractère lui-même. Depuis la version : 1.0.2 Voir aussi :
    isTitleCase(char),toLowerCase(char),toUpperCase(char)
  - toTitleCase
```
public static int toTitleCase(int codePoint)
```
    Wandelt das Zeichenargument (Codepoint) anhand der Fall-Mappings aus der Datei UnicodeData in eine Titelcasemapping um. Hat ein Zeichen kein ausdrückliches Titel-Mapping und ist es nach UnicodeData selbst kein Titelzeichen, liefert die Großbuchstabenmapping dieses Zeichen als gleichwertiges Titel-Mapping. Ist das Zeichenargument bereits ein Titelzeichen, liefert die Methode denselben Zeichenwert. Beachten Sie, dass für einige Zeichenbereiche
    Character.isTitleCase(Character.toTitleCase(codePoint))并不总是返回true 。
    
    Paramètres
    codePoint- Le caractère (point de code Unicode) à convertir. Le résultat est le titre du caractère, s'il en a un, sinon le caractère lui-même. Depuis : 1.5. Voir aussi :
    isTitleCase(int),toLowerCase(int),toUpperCase(int)
  - digit
```
public static int digit(char ch,
                        int radix)
```
    Retourne la valeur numérique du caractère dans la base spécifiée.chSi la base n'est pas dans la plage
    MIN_RADIX â‰¤ radix â‰¤ MAX_RADIXou si la valeurchn'est pas un chiffre valide dans la base spécifiée, -1est retourné. Un caractère est un chiffre valide si au moins une des conditions suivantes est remplie :
    La méthodeisDigit是字符的trueet la valeur décimale Unicode du caractère (ou de sa décomposition en un seul caractère) est inférieure à la base spécifiée. Dans ce cas, la valeur décimale est retournée.
    Le caractère est une lettre latine majuscule'A'至'Z' ，其代码小于radix + 'A' - 10. Dans ce cas, la valeurch - 'A' + 10 。
    Le caractère est une lettre latine minuscule'a'到'z' ，其代码小于radix + 'a' - 10. Dans ce cas, la valeurch - 'a' + 10 。
    Le caractère est une lettre latine majuscule pleine chasse'\uFF21'写拉丁字母A（ '\uFF21' ）到Z（ '\uFF3A' ）之一，其代码小于radix + '\uFF21' - 10. Dans ce cas, la valeurch - '\uFF21' + 10 。
    Le caractère est une lettre latine minuscule pleine chasse a ('\uFF41' ）到z（ '\uFF5A' ）之一，其代码小于radix + '\uFF41' - 10. Dans ce cas, la valeurch - '\uFF41' + 10 。
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodedigit(int, int).
    Paramètres
    ch- Le caractère à convertir.
    radix- La base. Résultat : la valeur numérique représentée par le caractère dans la base spécifiée. Voir aussi :
    forDigit(int, int),isDigit(char)
  - digit
```
public static int digit(int codePoint,
                        int radix)
```
    renvoie la valeur numérique du caractère spécifié (point de code Unicode) dans la base indiquée. Si la base n'est pas dans la plage
    MIN_RADIX â‰¤ radix â‰¤ MAX_RADIX ou si le caractère n'est pas un chiffre valide dans la base indiquée, -1est renvoyé. Un caractère est un chiffre valide si au moins l'une des conditions suivantes est remplie :
    La méthodeisDigit(codePoint)du caractère esttrueet la valeur décimale Unicode du caractère (ou sa décomposition en un seul caractère) est inférieure à la base indiquée. Dans ce cas, la valeur décimale est renvoyée.
    Le caractère est une lettre latine majuscule'A'至'Z' ，其代码小于radix + 'A' - 10. Dans ce cas, la valeurcodePoint - 'A' + 10 。
    Le caractère est une lettre latine minuscule'a'至'z' ，其代码小于radix + 'a' - 10. Dans ce cas, la valeurcodePoint - 'a' + 10 。
    Le caractère est une lettre latine majuscule pleine chasse A ('\uFF21'写拉丁字母A（ '\uFF21' ）到Z（ '\uFF3A' ）之一，其代码小于radix + '\uFF21' - 10est renvoyée.codePoint - '\uFF21' + 10 。
    ) à z ('\uFF41' ）到z（ '\uFF5A' ）之一，其代码小于radix + '\uFF41'- 10est renvoyée.codePoint - '\uFF41' + 10 。
    Paramètres
    codePoint- le caractère (point de code Unicode) à convertir.
    radix- la base. Résultat : la valeur numérique représentée par le caractère dans la base indiquée. Depuis la version : 1.5 Voir aussi :
    forDigit(int, int),isDigit(int)
  - getNumericValue
```
public static int getNumericValue(char ch)
```
    renvoie la valeurintreprésentée par le caractère Unicode spécifié. Par exemple, le caractère'\u216C'(chiffre romain 50) renvoie un int de valeur 50. Les lettres majuscules A à Z (
    '\u0041'到'\u005A' ), les lettres minuscules ( '\u0061'到'\u007A' ) et les variantes pleine largeur ( '\uFF21'到'\uFF3A'和'\uFF41'到'\uFF5A' ) représentent des valeurs numériques de 10 à 35 '\uFF5A' . Cela ne vient pas de la spécification Unicode, qui n'assigne pas de valeur numérique à cescharvaleurs.
    Si le caractère n'a pas de valeur numérique, la méthode renvoie -1. Si la valeur numérique du caractère ne peut pas être représentée comme un entier non négatif (par exemple, une valeur décimale), elle renvoie -2.
    Attention : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez lagetNumericValue(int)méthode.
    
    Paramètres
    ch- le caractère à convertir. Résultat la valeur numérique du caractère, sous forme de valeur non négative
    int; -2 si le caractère possède une valeur numérique mais que celle-ci ne peut pas être représentée comme valeur non négativeint; -1 si le caractère n'a pas de valeur numérique. Disponible depuis : 1.1. Voir aussi :
    forDigit(int, int),isDigit(char)
  - getNumericValue
```
public static int getNumericValue(int codePoint)
```
    Retourne la valeur représentée par le caractère spécifié (point de code Unicode).intPar exemple, le caractère'\u216C' （chiffre romain 50）renvoie la valeur 50 deint。 Dans leurs majuscules (lettres A à Z
    '\u0041'通过'\u005A' ), minuscule ( '\u0061'通过'\u007A' （） et leurs variantes à pleine largeur'\uFF21'通过'\uFF3A'和'\uFF41'通过'\uFF5A' ) ont des valeurs numériques de 10 à 35, ce qui est indépendant de la spécification Unicode, où elles n'en ont pas.charAttribue une valeur numérique.
    Retourne -1 si le caractère n'a pas de valeur numérique. Retourne -2 si la valeur numérique du caractère ne peut pas être représentée comme un entier non négatif (par exemple, une valeur décimale).
    
    Paramètres
    codePoint- Le caractère à convertir (point de code Unicode). Résultat La valeur numérique du caractère, comme valeur non négative.
    intRetourne -2 si le caractère a une valeur numérique mais que cette valeur ne peut pas être représentée comme une valeur non négative.intRetourne -1 si le caractère n'a pas de valeur numérique. Depuis : 1.5 Voir aussi :
    forDigit(int, int),isDigit(int)
  - isSpace
```
@Deprecated(since="1.1")
public static boolean isSpace(char ch)
```
    Deprecated. Remplacé par isWhitespace(char).
    
    Détermine si le caractère spécifié est un espace ISO-LATIN-1. Cette méthode retourne true uniquement pour les cinq caractères suivants.true： 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
    
    Paramètres
    ch- Le caractère à tester. Résultat
    trueSi le caractère est un espace ISO-LATIN-1 ; sinonfalse. Voir aussi :
    isSpaceChar(char),isWhitespace(char)
  - isSpaceChar
```
public static boolean isSpaceChar(char ch)
```
    Détermine si le caractère spécifié est un espace Unicode. Un caractère est un espace si et seulement si la norme Unicode le désigne comme tel. Cette méthode renvoie true si la catégorie générale du caractère est l'une des suivantes :
    SPACE_SEPARATOR
    
    LINE_SEPARATOR
    
    PARAGRAPH_SEPARATOR
    Remarque : Cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisSpaceChar(int).
    Paramètres
    ch- Le caractère à tester. Résultat
    trueSi le caractère est un espace ; sinonfalse. Depuis la version : 1.1 Voir aussi :
    isWhitespace(char)
  - isSpaceChar
```
public static boolean isSpaceChar(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est un espace Unicode. Un caractère est un espace si et seulement si la norme Unicode le désigne comme tel. Cette méthode renvoie true si la catégorie générale du caractère est l'une des suivantes :
    SPACE_SEPARATOR
    
    LINE_SEPARATOR
    
    PARAGRAPH_SEPARATOR
    Paramètres
    codePoint- Le caractère à tester (point de code Unicode). Résultat
    trueSi le caractère est un espace ; sinonfalse. Depuis la version : 1.5 Voir aussi :
    isWhitespace(int)
  - isWhitespace
```
public static boolean isWhitespace(char ch)
```
    Détermine si le caractère spécifié est un espace selon Java. Un caractère est un espace Java si et seulement s'il remplit l'une des conditions suivantes : c'est un espace Unicode (
    SPACE_SEPARATOR ， LINE_SEPARATOR ，或PARAGRAPH_SEPARATOR ), mais ce n'est pas un espace insécable ( '\u00A0' ， '\u2007' ， '\u202F' ）。
    C'est'\t' , U + 0009 HORIZONTAL '\t' 。
    C'est'\n', U + 000A LINE FEED.
    C'est'\u000B' , U + 000B VERTICAL '\u000B' 。
    C'est'\f', U + 000C FORM FEED.
    C'est'\r' ，U + 000D '\r'RETURN.
    C'est'\u001C', U + 001C FILE SEPARATOR.
    C'est'\u001D', U + 001D GROUP SEPARATOR.
    C'est'\u001E', U + 001E RECORD SEPARATOR.
    C'est'\u001F', U + 001F UNIT SEPARATOR.
    Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la méthodeisWhitespace(int).
    Paramètres
    ch- le caractère à tester. Résultat
    truetrue si le caractère est un espace blanc Java, sinonfalse. Depuis la version : 1.1 Voir aussi :
    isSpaceChar(char)
  - isWhitespace
```
public static boolean isWhitespace(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est un espace blanc selon Java. Un caractère est un espace blanc Java si et seulement s'il remplit l'une des conditions suivantes : c'est un caractère d'espacement Unicode (
    SPACE_SEPARATOR,LINE_SEPARATOR, ouPARAGRAPH_SEPARATOR), mais ce n'est pas aussi un espace insécable ('\u00A0' ， '\u2007' ， '\u202F' ）。
    C'est'\t' , U + 0009 HORIZONTAL '\t' 。
    C'est'\n', U + 000A LINE FEED.
    C'est'\u000B' , U + 000B VERTICAL '\u000B' 。
    C'est'\f', U + 000C FORM FEED.
    C'est'\r' ，U + 000D '\r'RETURN.
    C'est'\u001C', U + 001C FILE SEPARATOR.
    C'est'\u001D', U + 001D GROUP SEPARATOR.
    C'est'\u001E', U + 001E RECORD SEPARATOR.
    C'est'\u001F', U + 001F UNIT SEPARATOR.
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truesi le caractère est un caractère d'espacement Java, sinonfalse. Depuis la version : 1.5 Voir aussi :
    isSpaceChar(int)
  - isISOControl
```
public static boolean isISOControl(char ch)
```
    Détermine si le caractère spécifié est un caractère de contrôle ISO. Un caractère est considéré comme un caractère de contrôle ISO si son code se trouve dans la plage'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F'. Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez la méthode
    isISOControl(int).
    
    Paramètres
    ch- le caractère à tester. Résultat
    truesi le caractère est un caractère de contrôle ISO, sinonfalse. Depuis la version : 1.1 Voir aussi :
    isSpaceChar(char),isWhitespace(char)
  - isISOControl
```
public static boolean isISOControl(int codePoint)
```
    Détermine si le caractère référencé (point de code Unicode) est un caractère de contrôle ISO. Un caractère est considéré comme un caractère de contrôle ISO si son code se trouve dans la plage'\u0000'通过'\u001F'或在范围'\u007F'通过'\u009F' 。
    Paramètres
    codePoint- le caractère (point de code Unicode) à tester. Résultat
    truesi le caractère est un caractère de contrôle ISO, sinonfalse. Depuis la version : 1.5 Voir aussi :
    isSpaceChar(int),isWhitespace(int)
  - getType
```
public static int getType(char ch)
```
    Retourne une valeur indiquant la catégorie générale du caractère. Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez la méthode
    getType(int).
    
    Paramètres
    ch- le caractère à tester. Résultat La valeur de type
    intindiquant la catégorie générale du caractère. Depuis la version : 1.1 Voir aussi :
    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)
```
    Renvoie une valeur indiquant la catégorie générale du caractère.
    Paramètres
    codePoint- Le caractère à tester (point de code Unicode). Le résultat est une valeur de type
    intindiquant la catégorie générale du caractère. Disponible depuis : 1.5. Voir aussi :
    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)
```
    Détermine la représentation sous forme de caractère d'un chiffre dans une base spécifiée. Si la valeurradixn'est pas une base valide, ou si la valeurdigitn'est pas un chiffre valide dans la base spécifiée, la méthode renvoie le caractère nul ( '\u0000'). La
    radixest valide si elle est supérieure ou égale àMIN_RADIXet inférieure ou égale àMAX_RADIX. Si0 <= digit < radix ，则digitest valide.
    Si le chiffre est inférieur à 10, la méthode renvoie'0' + digit. Sinon, elle renvoie la valeur'a' + digit - 10 。
    
    Paramètres
    digit- le chiffre à convertir en caractère.
    radix- la base. Résultat La
    charreprésentation du chiffre spécifié dans la base indiquée. Voir aussi :
    MIN_RADIX，MAX_RADIX，digit(char, int)
  - getDirectionality
```
public static byte getDirectionality(char ch)
```
    Retourne la propriété de direction Unicode du caractère donné. La direction d'un caractère sert à calculer l'ordre visuel du texte. Non définicharLa valeur de direction d'une valeur non définie estDIRECTIONALITY_UNDEFINED. Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode (y compris les caractères supplémentaires), utilisez la méthode
    getDirectionality(int).
    
    Paramètres
    ch - char, dont on demande la propriété de direction. Résultat
    charLa propriété de direction de la valeur. Depuis : 1.4 Voir aussi :
    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)
```
    Retourne la propriété de direction Unicode du caractère donné (point de code Unicode). La direction d'un caractère sert à calculer l'ordre visuel du texte. La direction d'un caractère non défini vautDIRECTIONALITY_UNDEFINED.
    Paramètres
    codePoint- le caractère (point de code Unicode) dont on demande la propriété de direction. Résultat La direction du caractère. Depuis : 1.5 Voir aussi :
    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)
```
    Détermine si le caractère est mis en miroir selon la spécification Unicode. Lors de l'affichage dans un texte de droite à gauche, le caractère en miroir doit avoir son glyphe inversé horizontalement. Par exemple,'\u0028'LEFT PARENTHESIS est défini sémantiquement comme une parenthèse gauche. Il s'affiche comme « ( » dans un texte de gauche à droite, mais comme « ) » dans un texte de droite à gauche. Remarque : cette méthode ne gère pas les supplementary characters. Pour prendre en charge tous les caractères Unicode, y compris les caractères supplémentaires, utilisez la
    isMirrored(int)méthode.
    
    Paramètres
    ch - char, pour demander la propriété de miroir. Résultat
    truetrue si char est en miroir, false如果 charnon en miroir ou non défini. Depuis la version : 1.4
  - isMirrored
```
public static boolean isMirrored(int codePoint)
```
    Détermine si le caractère spécifié (point de code Unicode) est mis en miroir selon la spécification Unicode. Lors de l'affichage dans un texte de droite à gauche, le caractère en miroir doit avoir son glyphe inversé horizontalement. Par exemple,'\u0028'LEFT PARENTHESIS est défini sémantiquement comme une parenthèse gauche. Il s'affiche comme « ( » dans un texte de gauche à droite, mais comme « ) » dans un texte de droite à gauche.
    Paramètres
    codePoint- le caractère à tester (point de code Unicode). Résultat
    truetrue si le caractère est en miroir, falsesi le caractère n'est pas en miroir ou n'est pas défini. Depuis la version : 1.5
  - compareTo
```
public int compareTo(Character anotherCharacter)
```
    Compare numériquement deux objetsCharacter对象。
    Specified by:
    compareToDans l'interface Comparable<Character>
    Paramètres
    anotherCharacter - la valeur à comparer Character. Valeur renvoyée
    0Si le paramètreCharacterest égal à cetteCharacter; une valeur inférieure si0 est numériquement inférieure àCharacterce paramètre ; une valeur supérieure siCharacterest numériquement supérieure auCharacterparamètre (comparaison non signée), la valeur est supérieure àCharacter. Notez qu'il s'agit d'une comparaison strictement numérique. Elle ne dépend pas des paramètres régionaux. Depuis : 1.20compare
  - compare
```
public static int compare(char x,
                          char y)
```
    . La valeur renvoyée est identique à celle renvoyée par :charParamètres
    Character.valueOf(x).compareTo(Character.valueOf(y))
    - la première
    x valeur à comparer char- la deuxième
    y valeur à comparer Valeur renvoyée charla valeur
    0如果x == yest inférieure à0la valeur ; la valeurx < ysi0la valeur est supérieure àx > y
    Depuis : 1.7
  - reverseBytes
```
public static char reverseBytes(char ch)
```
    Renvoie la valeur obtenue en inversant l'ordre des octets dans la valeurcharspécifiée.
    Paramètres
    ch - la valeur dans laquelle charinverser l'ordre des octets. Valeur renvoyée La valeur obtenue en inversant (ou en échangeant de manière équivalente) les octets dans la valeur
    charspécifiée. Depuis : 1.5
  - getName
```
public static String getName(int codePoint)
```
    Renvoie le nom Unicode du caractèrecodePointspécifié, ou null si le point de code estunassigned, 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);
    
    Paramètres
    codePoint- le caractère (point de code Unicode) Valeur renvoyée Le nom Unicode du caractère spécifié, ou null si le point de code n'est pas attribué. Exceptions
    IllegalArgumentException - 如果指定的 codePointspécifié n'est pas un point de code Unicode valide. Depuis la version : 1.7
  - codePointOf
```
public static int codePointOf(String name)
```
    liefert den Codepunktwert des Unicode-Zeichens, der durch den Namen des angegebenen Unicode-Zeichens bezeichnet wird. Hinweis: Ordnet die UnicodeData-Datei (Teil der Unicode-Zeichendatenbank, die vom Unicode Consortium gepflegt wird) einem Zeichen keinen Namen zu, ergibt sich sein Name aus dem Ausdruck
    
    Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') + " " + Integer.toHexString(codePoint).toUpperCase(Locale.ROOT);
    
    nameLa correspondance ignore la casse et supprime tout caractère d'espacement en début et en fin.
    
    Paramètres
    name- Nom de caractère Unicode Résultat La valeur du point de code du caractère désigné par son nom. Exceptions
    IllegalArgumentException - 如果指定的 namespécifié n'est pas un nom de caractère Unicode valide.
    NullPointerException - 如果 nameest null
    Depuis la version : 9

Classe Character

Représentation des caractères Unicode

嵌套类汇总

字段汇总

构造方法摘要

方法摘要

声明方法的类 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