toChars(int codePoint, char[] dst, int dstIndex)
toChars(int codePoint, char[] dst, int dstIndex) – Converte o caractere especificado (ponto de código Unicode) em sua representação UTF-16.
public static char[] toChars(int codePoint) – Converte o caractere especificado (ponto de código Unicode) em sua representação UTF-16 armazenada em uma matriz char. Se o ponto de código especificado for um valor BMP (Basic Multilingual Plane ou Plane 0), a matriz char resultante terá o mesmo valor que codePoint. Se o ponto de código especificado for um ponto de código suplementar, a matriz de char resultante terá o par substituto correspondente.
Parâmetros:
codePoint – um ponto de código Unicode
Retorno:
uma matriz char tendo a representação UTF-16 do codePoint.
Lança:
IllegalArgumentException – se o codePoint especificado não for um ponto de código Unicode válido.
Esse método existe desde a versão 1.5.
Fonte do código:http://www.java2s.com/example/java-utility-method/char-create/tochars-int-codepoint-char-dst-int-dstindex-a300e.html
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
//package com.java2s; //License from project: Open Source License public class Main { /**// www . jav a2 s . co m * The minimum value of a Unicode high-surrogate code unit in the * UTF-16 encoding. A high-surrogate is also known as a * <i>leading-surrogate</i>. * * @since 1.5 */ public static final char MIN_HIGH_SURROGATE = '\uD800'; /** * The minimum value of a Unicode low-surrogate code unit in the * UTF-16 encoding. A low-surrogate is also known as a * <i>trailing-surrogate</i>. * * @since 1.5 */ public static final char MIN_LOW_SURROGATE = '\uDC00'; /** * The minimum value of a supplementary code point. * * @since 1.5 */ public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000; /** * The maximum value of a Unicode code point. * * @since 1.5 */ public static final int MAX_CODE_POINT = 0x10ffff; /** * Converts the specified character (Unicode code point) to its * UTF-16 representation. If the specified code point is a BMP * (Basic Multilingual Plane or Plane 0) value, the same value is * stored in <code>dst[dstIndex]</code>, and 1 is returned. If the * specified code point is a supplementary character, its * surrogate values are stored in <code>dst[dstIndex]</code> * (high-surrogate) and <code>dst[dstIndex+1]</code> * (low-surrogate), and 2 is returned. * * @param codePoint the character (Unicode code point) to be converted. * @param dst an array of <code>char</code> in which the * <code>codePoint</code>'s UTF-16 value is stored. * @param dstIndex the start index into the <code>dst</code> * array where the converted value is stored. * @return 1 if the code point is a BMP code point, 2 if the * code point is a supplementary code point. * @exception IllegalArgumentException if the specified * <code>codePoint</code> is not a valid Unicode code point. * @exception NullPointerException if the specified <code>dst</code> is null. * @exception IndexOutOfBoundsException if <code>dstIndex</code> * is negative or not less than <code>dst.length</code>, or if * <code>dst</code> at <code>dstIndex</code> doesn't have enough * array element(s) to store the resulting <code>char</code> * value(s). (If <code>dstIndex</code> is equal to * <code>dst.length-1</code> and the specified * <code>codePoint</code> is a supplementary character, the * high-surrogate value is not stored in * <code>dst[dstIndex]</code>.) * @since 1.5 */ public static int toChars(int codePoint, char[] dst, int dstIndex) { if (codePoint < 0 || codePoint > MAX_CODE_POINT) { throw new IllegalArgumentException(); } if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) { dst[dstIndex] = (char) codePoint; return 1; } toSurrogates(codePoint, dst, dstIndex); return 2; } /** * Converts the specified character (Unicode code point) to its * UTF-16 representation stored in a <code>char</code> array. If * the specified code point is a BMP (Basic Multilingual Plane or * Plane 0) value, the resulting <code>char</code> array has * the same value as <code>codePoint</code>. If the specified code * point is a supplementary code point, the resulting * <code>char</code> array has the corresponding surrogate pair. * * @param codePoint a Unicode code point * @return a <code>char</code> array having * <code>codePoint</code>'s UTF-16 representation. * @exception IllegalArgumentException if the specified * <code>codePoint</code> is not a valid Unicode code point. * @since 1.5 */ public static char[] toChars(int codePoint) { if (codePoint < 0 || codePoint > MAX_CODE_POINT) { throw new IllegalArgumentException(); } if (codePoint < MIN_SUPPLEMENTARY_CODE_POINT) { return new char[] { (char) codePoint }; } char[] result = new char[2]; toSurrogates(codePoint, result, 0); return result; } static void toSurrogates(int codePoint, char[] dst, int index) { int offset = codePoint - MIN_SUPPLEMENTARY_CODE_POINT; dst[index + 1] = (char) ((offset & 0x3ff) + MIN_LOW_SURROGATE); dst[index] = (char) ((offset >>> 10) + MIN_HIGH_SURROGATE); } } |
toCodePoint(char high, char low)
toCodePoint(char high, char low) – Converte o par substituto especificado em seu valor de ponto de código suplementar.
public static int toCodePoint(char high, char low) – Converte o par substituto especificado em seu valor de ponto de código suplementar. Este método não valida o par substituto especificado. O chamador deve validá-lo usando isSurrogatePair, se necessário.
Parâmetros:
alto – a unidade de código substituto alto
baixo – a unidade de código substituto baixo
Retorno:
o ponto de código suplementar composto do par substituto especificado.
Esse método existe desde a versão 1.5.
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/2860__Character.toCodePoint_char_high_char_low_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class Main { //w ww .jav a2s. c o m public static void main(String[] args) { char ch1 = '\ud800', ch2 = '\udc00'; int cp = Character.toCodePoint(ch1, ch2); String str = "Supplementary code point value is " + cp; System.out.println(str); } } |
toLowerCase(char ch)
toLowerCase(char ch) – Converte o argumento de caractere em minúsculas usando informações de mapeamento de caso do arquivo UnicodeData.
public static char toLowerCase(char ch) – Converte o argumento de caractere em minúsculas usando informações de mapeamento de caso do arquivo UnicodeData.
Observe que Character.isLowerCase (Character.toLowerCase (ch)) nem sempre retorna true para alguns intervalos de caracteres, particularmente aqueles que são símbolos ou ideogramas.
Em geral, String.toLowerCase () deve ser usado para mapear caracteres em minúsculas. Os métodos de mapeamento de caso de string têm vários benefícios sobre os métodos de mapeamento de caso de caractere. Os métodos de mapeamento de maiúsculas e minúsculas podem realizar mapeamentos sensíveis ao local, mapeamentos sensíveis ao contexto e mapeamentos de caracteres 1: M, enquanto os métodos de mapeamento de maiúsculas não podem.
Nota: Este método não pode manipular caracteres suplementares. Para suportar todos os caracteres Unicode, incluindo caracteres suplementares, use o método toLowerCase (int).
Parâmetros:
ch – o caractere a ser convertido.
Retorno:
o equivalente em minúsculas do caractere, se houver; caso contrário, o próprio personagem.
Veja também:
isLowerCase(char), String.toLowerCase()
Fonte do código: http://www.java2s.com/Code/JavaAPI/java.lang/CharactertoLowerCasecharch.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class Main { public static void main(String[] arg) { String phrase = "The quick brown fox jumped over the lazy dog."; int vowels = 0; for(char ch : phrase.toCharArray()) { ch = Character.toLowerCase(ch); if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') { ++vowels; } } System.out.println("The phrase contains " + vowels + " vowels."); } } |
toLowerCase(int codePoint)
toLowerCase(int codePoint) – Converte o argumento do caractere (ponto de código Unicode) em minúsculas usando as informações de mapeamento de caso do arquivo UnicodeData.
public static int toLowerCase(int codePoint) – Converte o argumento do caractere (ponto de código Unicode) em minúsculas usando as informações de mapeamento de caso do arquivo UnicodeData.
Observe que Character.isLowerCase (Character.toLowerCase (codePoint)) nem sempre retorna true para alguns intervalos de caracteres, particularmente aqueles que são símbolos ou ideogramas.
Em geral, String.toLowerCase () deve ser usado para mapear caracteres em minúsculas. Os métodos de mapeamento de caso de string têm vários benefícios sobre os métodos de mapeamento de caso de caractere. Os métodos de mapeamento de maiúsculas e minúsculas podem realizar mapeamentos sensíveis ao local, mapeamentos sensíveis ao contexto e mapeamentos de caracteres 1: M, enquanto os métodos de mapeamento de maiúsculas não podem.
Parâmetros:
codePoint – o caractere (ponto de código Unicode) a ser convertido.
Retorno:
o equivalente em minúsculas do caractere (ponto de código Unicode), se houver; caso contrário, o próprio personagem.
Esse método existe desde a versão 1.5.
Veja também:
isLowerCase(int), String.toLowerCase()
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/Java_Character_toLowerCase_int_codePoint_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class Main { /*from ww w .ja v a 2 s. c o m*/ public static void main(String[] args) { int cp1 = 0x0050; int cp2 = 0x2100; int cp3 = Character.toLowerCase(cp1); int cp4 = Character.toLowerCase(cp2); String str1 = "Lowercase equivalent of cp1 is " + cp3; String str2 = "Lowercase equivalent of cp2 is " + cp4; System.out.println(str1); System.out.println(str2); } } |
toString()
toString() – Retorna um objeto String que representa o valor deste personagem.
public String toString() – Retorna um objeto String que representa o valor deste personagem. O resultado é uma string de comprimento 1 cujo único componente é o valor char primitivo representado por este objeto Character.
Sobreescreve:
toString na classe Object
Retorno:
uma representação de string deste objeto.
Fonte do código: http://www.java2s.com/Code/JavaAPI/java.lang/CharactertoString.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class Main { public static void main(String args[]) { Character a = new Character('a'); Character a2 = new Character('a'); Character b = new Character('b'); int difference = a.compareTo(b); if (difference == 0) { System.out.println("a is equal to b."); } else if (difference < 0) { System.out.println("a is less than b."); } else if (difference > 0) { System.out.println("a is greater than b."); } System.out.println("a is " + ((a.equals(a2)) ? "equal" : "not equal") + " to a2."); System.out.println("The character " + a.toString() + " is " + (Character.isUpperCase(a.charValue()) ? "upper" : "lower") + "case."); } } |
toString(char c)
toString(char c) – Retorna um objeto String que representa o caractere especificado.
public static String toString(char c) – Retorna um objeto String que representa o caractere especificado. O resultado é uma string de comprimento 1 consistindo apenas no caractere especificado.
Nota da API:
Este método não pode lidar com caracteres suplementares. Para suportar todos os caracteres Unicode, incluindo caracteres suplementares, use o método toString (int).
Parâmetros:
c – o caractere a ser convertido
Retorno:
a representação da string do caractere especificado
Esse método existe desde a versão 1.4.
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/2940__Character.toString_char_c_.htm
|
1 2 3 4 5 6 7 |
public class Main { public static void main(String[] argv) { Character character2 = new Character('b'); System.out.println(Character.toString(character2)); } } |
toString(int codePoint)
toString(int codePoint) – Retorna um objeto String que representa o caractere especificado (ponto de código Unicode).
public static String toString(int codePoint) – Retorna um objeto String que representa o caractere especificado (ponto de código Unicode). O resultado é uma string de comprimento 1 ou 2, consistindo apenas no codePoint especificado.
Parâmetros:
codePoint – o codePoint a ser convertido
Retorno:
a representação de string do codePoint especificado
Lança:
IllegalArgumentException – se o codePoint especificado não for um ponto de código Unicode válido.
Esse método existe desde a versão 1.1.
Fonte do código: https://www.tutorialspoint.com/java/lang/character_tochars.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package com.tutorialspoint; import java.lang.*; public class CharacterDemo { public static void main(String[] args) { // create a char array ch char ch[]; // create an int primitive cp and assign value int cp = 0x006e; // assign result of toChars on cp to ch ch = Character.toChars(cp); String str = "Char array having cp's UTF-16 representation is "; System.out.print( str ); // use a for loop to print ch for (int i = 0; i < ch.length; i++) { System.out.print( ch[i] ); } } } |
toTitleCase(char ch)
toTitleCase(char ch) – Converte o argumento de caractere em titlecase usando informações de mapeamento de caso do arquivo UnicodeData.
public static char toTitleCase(char ch) – Converte o argumento de caractere em titlecase usando informações de mapeamento de caso do arquivo UnicodeData. Se um caractere não tem mapeamento de titlecase explícito e não é ele próprio um caracter de titlecase de acordo com UnicodeData, o mapeamento em maiúsculas é retornado como um mapeamento de titlecase equivalente. Se o argumento char já for um caractere titlecase, o mesmo valor char será retornado.
Observe que Character.isTitleCase (Character.toTitleCase (ch)) nem sempre retorna verdadeiro para alguns intervalos de caracteres.
Nota: Este método não pode manipular caracteres suplementares. Para oferecer suporte a todos os caracteres Unicode, incluindo caracteres suplementares, use o método toTitleCase (int).
Parâmetros:
ch – o caractere a ser convertido.
Retorno:
o equivalente em caso de título do caractere, se houver; caso contrário, o próprio personagem.
Esse método existe desde a versão 1.0.2.
Veja também:
isTitleCase(char), toLowerCase(char), toUpperCase(char)
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/Java_Character_toTitleCase_char_ch_.htm
|
1 2 3 4 5 6 7 |
//from w ww . jav a2s . co m public class Main{ public static void main(String[] argv){ System.out.println(Character.toTitleCase('t')); } } |
toTitleCase(int codePoint)
toTitleCase(int codePoint) – Converte o argumento de caractere (ponto de código Unicode) em titlecase usando informações de mapeamento de caso do arquivo UnicodeData.
public static int toTitleCase(int codePoint) – Converte o argumento de caractere (ponto de código Unicode) em titlecase usando informações de mapeamento de caso do arquivo UnicodeData. Se um caractere não tem mapeamento de titlecase explícito e não é ele próprio um caracter de titlecase de acordo com UnicodeData, o mapeamento em maiúsculas é retornado como um mapeamento de titlecase equivalente. Se o argumento do caractere já for um caractere de caixa de título, o mesmo valor do caractere será retornado.
Observe que Character.isTitleCase (Character.toTitleCase (codePoint)) nem sempre retorna verdadeiro para alguns intervalos de caracteres.
Parâmetros:
codePoint – o caractere (ponto de código Unicode) a ser convertido.
Retorno:
o equivalente em caso de título do caractere, se houver; caso contrário, o próprio personagem.
Esse método existe desde a versão 1.5.
Veja também:
isTitleCase(int), toLowerCase(int), toUpperCase(int)
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/Java_Character_toTitleCase_int_codePoint_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class Main { //from ww w. j ava 2 s .c o m public static void main(String[] args) { int cp1 = 0x0068; int cp2 = 0x005c; int cp3 = Character.toTitleCase(cp1); int cp4 = Character.toTitleCase(cp2); String str1 = "Titlecase equivalent of " + cp1 + " is " + cp3; String str2 = "Titlecase equivalent of " + cp2 + " is " + cp4; System.out.println(str1); System.out.println(str2); } } |
toUpperCase(char ch)
toUpperCase(char ch) – Converte o argumento de caractere em maiúsculas usando as informações de mapeamento de maiúsculas do arquivo UnicodeData.
public static char toUpperCase(char ch) – Converte o argumento de caractere em maiúsculas usando as informações de mapeamento de maiúsculas do arquivo UnicodeData.
Observe que Character.isUpperCase (Character.toUpperCase (ch)) nem sempre retorna true para alguns intervalos de caracteres, particularmente aqueles que são símbolos ou ideogramas.
Em geral, String.toUpperCase () deve ser usado para mapear caracteres em maiúsculas. Os métodos de mapeamento de caso de string têm vários benefícios sobre os métodos de mapeamento de caso de caractere. Os métodos de mapeamento de maiúsculas e minúsculas podem realizar mapeamentos sensíveis ao local, mapeamentos sensíveis ao contexto e mapeamentos de caracteres 1: M, enquanto os métodos de mapeamento de maiúsculas não podem.
Nota: Este método não pode manipular caracteres suplementares. Para oferecer suporte a todos os caracteres Unicode, incluindo caracteres suplementares, use o método toUpperCase (int).
Parâmetros:
ch – o caractere a ser convertido.
Retorno:
o equivalente em maiúsculas do caractere, se houver; caso contrário, o próprio personagem.
Veja também:
isUpperCase(char), String.toUpperCase()
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/3000__Character.toUpperCase_char_ch_.htm
|
1 2 3 4 5 6 |
public class Main{ public static void main(String[] argv){ System.out.println(Character.toUpperCase('t')); } } |
toUpperCase(int codePoint)
toUpperCase(int codePoint) – Converte o argumento do caractere (ponto de código Unicode) em maiúsculas usando as informações de mapeamento de maiúsculas do arquivo UnicodeData.
public static int toUpperCase(int codePoint) – Converte o argumento do caractere (ponto de código Unicode) em maiúsculas usando as informações de mapeamento de maiúsculas do arquivo UnicodeData.
Observe que Character.isUpperCase (Character.toUpperCase (codePoint)) nem sempre retorna true para alguns intervalos de caracteres, particularmente aqueles que são símbolos ou ideogramas.
Em geral, String.toUpperCase () deve ser usado para mapear caracteres em maiúsculas. Os métodos de mapeamento de caso de string têm vários benefícios sobre os métodos de mapeamento de caso de caractere. Os métodos de mapeamento de maiúsculas e minúsculas podem realizar mapeamentos sensíveis ao local, mapeamentos sensíveis ao contexto e mapeamentos de caracteres 1: M, enquanto os métodos de mapeamento de maiúsculas não podem.
Parâmetros:
codePoint – o caractere (ponto de código Unicode) a ser convertido.
Retorno:
o equivalente em maiúsculas do caractere, se houver; caso contrário, o próprio personagem.
Esse método existe desde a versão 1.5.
Veja também:
isUpperCase(int), String.toUpperCase()
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/Java_Character_toUpperCase_int_codePoint_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class Main { //w w w . ja v a 2 s. c om public static void main(String[] args) { int cp1 = 0x0071; int cp2 = 0x0570; int cp3 = Character.toUpperCase(cp1); int cp4 = Character.toUpperCase(cp2); String str1 = "Uppercase equivalent of " + cp1 + " is " + cp3; String str2 = "Uppercase equivalent of " + cp2 + " is " + cp4; System.out.println(str1); System.out.println(str2); } } |
valueOf(char c)
valueOf(char c) – Retorna uma instância de Character que representa o valor char especificado.
public static Character valueOf(char c) – Retorna uma instância de Character que representa o valor char especificado. Se uma nova instância de Character não for necessária, esse método geralmente deve ser usado em preferência ao Character construtor (char), pois esse método provavelmente renderá um desempenho de espaço e tempo significativamente melhor, armazenando em cache os valores solicitados com frequência. Este método sempre armazenará em cache os valores no intervalo ‘\ u0000’ a ‘\ u007F’, inclusive, e pode armazenar em cache outros valores fora desse intervalo.
Parâmetros:
c – um valor char.
Retorno:
uma instância de personagem representando c.
Esse método existe desde a versão 1.5.
Fonte do código: http://www.java2s.com/Tutorials/Java/java.lang/Character/Java_Character_valueOf_char_c_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// w w w.j a v a 2 s . co m public class Main { public static void main(String[] args) { char ch1 = 'i', ch2 = 65; Character c1 = Character.valueOf(ch1); Character c2 = Character.valueOf(ch2); String str1 = "Character value of " + ch1 + " is " + c1; String str2 = "Character value of " + ch2 + " is " + c2; System.out.println( str1 ); System.out.println( str2 ); } } |
Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Character.html
Deixe um comentário