offsetByCodePoints(int index, int codePointOffset)
offsetByCodePoints(int index, int codePointOffset) – Retorna o índice dentro dessa String que é deslocado do índice fornecido pelos pontos de código codePointOffset.
public int offsetByCodePoints(int index, int codePointOffset) – Retorna o índice dentro dessa String que é deslocado do índice fornecido pelos pontos de código codePointOffset. Substitutos não pareados dentro do intervalo de texto fornecido pelo índice e codePointOffset contam como um ponto de código cada.
Parâmetros:
índice – o índice a ser compensado
codePointOffset – o deslocamento em pontos de código
Retornos:
o índice dentro desta String
Lançamentos:
IndexOutOfBoundsException – se o índice for negativo ou maior que o comprimento dessa String, ou se codePointOffset for positivo e a subseqüência iniciando com index tiver menos que pontos de código codePointOffset, ou se codePointOffset for negativo e a subseqüente codePointOffset for menor que o valor absoluto de pontos de código codePointOffset.
Esse método existe desde a versão 1.5.
Código fonte: https://www.tutorialspoint.com/java/lang/string_offsetbycodepoints.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.tutorialspoint; import java.lang.*; public class StringDemo { public static void main(String[] args) { String str = "aacdefaa"; System.out.println("string = " + str); // returns the index within this String int retval = str.offsetByCodePoints(2, 4); // prints the index System.out.println("index = " + retval); } } |
regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) – Testa se duas regiões de sequência são iguais.
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) – Testa se duas regiões de sequência são iguais.
Uma substring desse objeto String é comparada com uma substring do argumento other. O resultado é verdadeiro se essas substrings representam seqüências de caracteres iguais, ignorando maiúsculas e minúsculas se e somente se ignoreCase for verdadeiro. A substring desse objeto String a ser comparado começa no índice toffset e tem comprimento len. A subcadeia de outros a serem comparados começa no índice ooffset e tem comprimento len. O resultado é falso se e somente se pelo menos um dos seguintes for verdadeiro:
toffset é negativo.
ooffset é negativo.
toffset + len é maior que o comprimento desse objeto String.
ooffset + len é maior que o comprimento do outro argumento.
ignoreCase é false e há algum número inteiro não negativo k menor que len, de modo que:
this.charAt(toffset+k) != other.charAt(ooffset+k)
ignoreCase é true e há algum número inteiro não negativo k menor que len, de modo que:
|
1 2 |
Character.toLowerCase(Character.toUpperCase(this.charAt(toffset+k))) != Character.toLowerCase(Character.toUpperCase(other.charAt(ooffset+k))) |
Observe que esse método não leva em consideração a localidade e resultará em resultados insatisfatórios para determinadas localidades quando ignoreCase for verdadeiro. A classe Collator fornece comparação sensível ao código do idioma.
Parâmetros:
ignoreCase – se verdadeiro, ignore maiúsculas e minúsculas ao comparar caracteres.
toffset – o deslocamento inicial da sub-região nessa sequência.
outro – o argumento da string.
ooffset – o deslocamento inicial da sub-região no argumento string.
len – o número de caracteres para comparar.
Retornos:
true se a sub-região especificada dessa string corresponder à sub-região especificada do argumento da string; false caso contrário. Se a correspondência é exata ou não diferencia maiúsculas de minúsculas depende do argumento ignoreCase.
Código fonte: https://beginnersbook.com/2013/12/java-string-regionmatches-method-example/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class RegionMatchesExample{ public static void main(String args[]){ String str1 = new String("Hello, How are you"); String str2 = new String("How"); String str3 = new String("HOW"); System.out.print("Result of Test1: " ); System.out.println(str1.regionMatches(7, str2, 0, 3)); System.out.print("Result of Test2: " ); System.out.println(str1.regionMatches(7, str3, 0, 3)); System.out.print("Result of Test3: " ); System.out.println(str1.regionMatches(true, 7, str3, 0, 3)); } } |
regionMatches(int toffset, String other, int ooffset, int len)
regionMatches(int toffset, String other, int ooffset, int len)– Testa se duas regiões de sequência são iguais.
public boolean regionMatches(int toffset, String other, int ooffset, int len) – Testa se duas regiões de sequência são iguais.
Uma substring desse objeto String é comparada com uma substring do argumento other. O resultado é verdadeiro se essas substrings representam sequências de caracteres idênticas. A substring desse objeto String a ser comparado começa no índice toffset e tem comprimento len. A subcadeia de outros a serem comparados começa no índice ooffset e tem comprimento len. O resultado é falso se e somente se pelo menos um dos seguintes for verdadeiro:
toffset é negativo.
ooffset é negativo.
toffset + len é maior que o comprimento desse objeto String.
ooffset + len é maior que o comprimento do outro argumento.
Existe algum número inteiro não negativo k menor que len, de modo que: this.charAt (toffset + k)! = Other.charAt (ooffset + k)
Observe que esse método não leva em consideração o código do idioma. A classe Collator fornece comparação sensível ao código do idioma.
Parâmetros:
toffset – o deslocamento inicial da sub-região nessa sequência.
outro – o argumento da string.
ooffset – o deslocamento inicial da sub-região no argumento string.
len – o número de caracteres para comparar.
Retornos:
true se a sub-região especificada dessa string corresponder exatamente à sub-região especificada do argumento da string; false caso contrário.
Código fonte: https://www.tutorialspoint.com/java/java_string_regionmatches.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.io.*; public class Test { public static void main(String args[]) { String Str1 = new String("Welcome to Tutorialspoint.com"); String Str2 = new String("Tutorials"); String Str3 = new String("TUTORIALS"); System.out.print("Return Value :" ); System.out.println(Str1.regionMatches(11, Str2, 0, 9)); System.out.print("Return Value :" ); System.out.println(Str1.regionMatches(11, Str3, 0, 9)); } } |
repeat(int count)
repeat(int count) – Retorna uma sequência cujo valor é a concatenação desta sequência de tempos de contagem repetidos.
public String repeat(int count) – Retorna uma sequência cujo valor é a concatenação desta sequência de tempos de contagem repetidos.
Se essa sequência estiver vazia ou a contagem for zero, a sequência vazia será retornada.
Parâmetros:
count – número de vezes para repetir
Retornos:
Uma sequência composta por esta sequência repetida vezes a contagem ou a sequência vazia se esta sequência estiver vazia ou a contagem for zero
Lança:
IllegalArgumentException – se a contagem for negativa.
Esse método existe desde a versão 11.
Código fonte: https://howtodoinjava.com/java11/repeat-string-n-times/
|
1 2 3 4 5 6 7 8 9 |
public class Main { public static void main(String[] args) { String str = "Abc"; System.out.println( str.repeat(3) ); } } |
replace(char oldChar, char newChar)
replace(char oldChar, char newChar) – Retorna uma string resultante da substituição de todas as ocorrências de oldChar nessa string por newChar.
public String replace(char oldChar, char newChar) – Retorna uma string resultante da substituição de todas as ocorrências de oldChar nessa string por newChar.
Se o caractere oldChar não ocorrer na sequência de caracteres representada por este objeto String, será retornada uma referência a esse objeto String. Caso contrário, é retornado um objeto String que representa uma sequência de caracteres idêntica à sequência representada por esse objeto String, exceto que toda ocorrência de oldChar é substituída por uma ocorrência de newChar.
Exemplos:
|
1 2 3 4 5 6 7 |
"mesquite in your cellar".replace('e', 'o') returns "mosquito in your collar" "the war of baronets".replace('r', 'y') returns "the way of bayonets" "sparring with a purple porpoise".replace('p', 't') returns "starring with a turtle tortoise" "JonL".replace('q', 'x') returns "JonL" (no change) |
Parâmetros:
oldChar – o personagem antigo.
newChar – o novo personagem.
Retornos:
uma sequência derivada dessa sequência, substituindo todas as ocorrências de oldChar por newChar.
Código fonte: https://www.javatpoint.com/java-string-replace
|
1 2 3 4 5 6 |
public class ReplaceExample1{ public static void main(String args[]){ String s1="javatpoint is a very good website"; String replaceString=s1.replace('a','e');//replaces all occurrences of 'a' to 'e' System.out.println(replaceString); }} |
replace(CharSequence target, CharSequence replacement)
replace(CharSequence target, CharSequence replacement) – Substitui cada substring dessa sequência que corresponde à sequência de destino literal pela sequência de substituição literal especificada.
public String replace(CharSequence target, CharSequence replacement) – Substitui cada substring dessa sequência que corresponde à sequência de destino literal pela sequência de substituição literal especificada. A substituição prossegue do início da sequência até o final, por exemplo, substituir “aa” por “b” na sequência “aaa” resultará em “ba” em vez de “ab”.
Parâmetros:
target – A sequência de valores de caracteres a serem substituídos
substituição – A sequência de substituição dos valores de caracteres
Retornos:
A sequência resultante
Esse método existe desde a versão 1.5.
Código fonte: http://www.java2s.com/Tutorials/Java/java.lang/String/Java_String_replace_CharSequence_target_CharSequence_replacement_.htm
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class Main { public static void main(String[] args) { String str = "java2s.com"; System.out.println("string = " + str); CharSequence s1 = "j"; CharSequence s2 = "b"; String replaceStr = str.replace(s1, s2); System.out.println("new string = " + replaceStr); } } |
replaceAll(String regex, String replacement)
replaceAll(String regex, String replacement) – Substitui cada substring dessa string que corresponde à expressão regular especificada pela substituição especificada.
public String replaceAll(String regex, String replacement) – Substitui cada substring dessa string que corresponde à expressão regular especificada pela substituição especificada.
Uma invocação desse método no formato str.replaceAll (regex, repl) produz exatamente o mesmo resultado que a expressão
Pattern.compile(regex).matcher(str).replaceAll(repl)
Observe que barras invertidas () e cifrões ($) na cadeia de substituição podem fazer com que os resultados sejam diferentes do que se estivessem sendo tratados como uma cadeia de substituição literal; consulte Matcher.replaceAll. Use Matcher.quoteReplacement (java.lang.String) para suprimir o significado especial desses caracteres, se desejado.
Parâmetros:
regex – a expressão regular à qual essa sequência deve ser correspondida
substituição – a sequência a ser substituída para cada partida
Retornos:
A String resultante
Lança:
PatternSyntaxException – se a sintaxe da expressão regular for inválida
Esse método existe desde a versão 1.4.
Veja também:
Código fonte: https://www.javatpoint.com/java-string-replaceall
|
1 2 3 4 5 6 |
public class ReplaceAllExample1{ public static void main(String args[]){ String s1="javatpoint is a very good website"; String replaceString=s1.replaceAll("a","e");//replaces all occurrences of "a" to "e" System.out.println(replaceString); }} |
replaceFirst(String regex, String replacement)
replaceFirst(String regex, String replacement) – Substitui a primeira substring dessa string que corresponde à expressão regular especificada pela substituição especificada.
public String replaceFirst(String regex, String replacement) – Substitui a primeira substring dessa string que corresponde à expressão regular especificada pela substituição especificada.
Uma invocação desse método no formato str.replaceFirst (regex, repl) produz exatamente o mesmo resultado que a expressão
Pattern.compile(regex).matcher(str).replaceFirst(repl)
Observe que barras invertidas () e cifrões ($) na cadeia de substituição podem fazer com que os resultados sejam diferentes do que se estivessem sendo tratados como uma cadeia de substituição literal; consulte Matcher.replaceFirst (java.lang.String). Use Matcher.quoteReplacement (java.lang.String) para suprimir o significado especial desses caracteres, se desejado.
Parâmetros:
regex – a expressão regular à qual essa sequência deve ser correspondida
substituição – a sequência a ser substituída pela primeira partida
Retornos:
A String resultante
Lança:
PatternSyntaxException – se a sintaxe da expressão regular for inválida
Esse método existe desde a versão 1.4.
Veja também:
Código fonte: https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/
|
1 2 3 4 5 6 7 8 9 10 11 |
public class JavaExample{ public static void main(String args[]){ String str = new String("Site is BeginnersBook.com"); System.out.print("String after replacing com with net :" ); System.out.println(str.replaceFirst("com", "net")); System.out.print("String after replacing Site name:" ); System.out.println(str.replaceFirst("Beginners(.*)", "XYZ.com")); } } |
resolveConstantDesc(MethodHandles.Lookup lookup)
resolveConstantDesc(MethodHandles.Lookup lookup) – Resolve esta instância como um ConstantDesc, cujo resultado é a própria instância.
public String resolveConstantDesc(MethodHandles.Lookup lookup) – Resolve esta instância como um ConstantDesc, cujo resultado é a própria instância.
Especificado por:
resolveConstantDesc na interface ConstantDesc
Parâmetros:
pesquisa – ignorada
Retornos:
a instância String
Esse método existe desde a versão 12.
Código fonte: https://www.dariawan.com/tutorials/java/java-12-new-methods-string/
|
1 2 3 4 5 6 7 8 9 |
public class StringResolveConstantDesc { public static void main(String[] args) { String s1 = "Life is short, and it is here to be lived."; String s2 = s1.resolveConstantDesc(null); System.out.println(s2.equals(s1)); System.out.println(s2 == s1); } } |
split(String regex)
split(String regex) – Divide essa string em torno das correspondências da expressão regular especificada.
public String[] split(String regex) – Divide essa string em torno das correspondências da expressão regular especificada.
Esse método funciona como se invocando o método de divisão de dois argumentos com a expressão fornecida e um argumento de limite igual a zero. As seqüências de caracteres vazias à direita, portanto, não são incluídas na matriz resultante.
A cadeia “boo: and: foo”, por exemplo, produz os seguintes resultados com estas expressões:
Parâmetros:
regex – a expressão regular delimitante
Retornos:
a matriz de strings calculada dividindo essa string em torno de correspondências da expressão regular especificada
Lança:
PatternSyntaxException – se a sintaxe da expressão regular for inválida
Esse método existe desde a versão 1.4.
Veja também:
Código fonte: https://www.geeksforgeeks.org/split-string-java-examples/
|
1 2 3 4 5 6 7 8 9 10 |
public class GFG { public static void main(String args[]) { String str = "geekss@for@geekss"; String[] arrOfStr = str.split("@", 5); for (String a : arrOfStr) System.out.println(a); } } |
split(String regex, int limit)
split(String regex, int limit) – Divide essa string em torno das correspondências da expressão regular especificada.
public String[] split(String regex, int limit) – Divide essa string em torno das correspondências da expressão regular especificada.
A matriz retornada por esse método contém cada substring dessa string que é finalizada por outra substring que corresponde à expressão especificada ou é finalizada no final da string. As substrings na matriz estão na ordem em que ocorrem nessa sequência. Se a expressão não corresponder a nenhuma parte da entrada, a matriz resultante terá apenas um elemento, a saber, essa sequência.
Quando houver uma correspondência de largura positiva no início dessa sequência, uma subseqüência inicial vazia será incluída no início da matriz resultante. Uma correspondência de largura zero no início, no entanto, nunca produz essa substring inicial vazia.
O parâmetro limit controla o número de vezes que o padrão é aplicado e, portanto, afeta o comprimento da matriz resultante.
Se o limite for positivo, o padrão será aplicado no máximo – 1 vezes, o comprimento da matriz não será maior que o limite e a última entrada da matriz conterá toda a entrada além do último delimitador correspondente.
Se o limite for zero, o padrão será aplicado quantas vezes for possível, a matriz pode ter qualquer comprimento e as seqüências vazias à direita serão descartadas.
Se o limite for negativo, o padrão será aplicado tantas vezes quanto possível e a matriz poderá ter qualquer comprimento.
A cadeia “boo: and: foo”, por exemplo, produz os seguintes resultados com estes parâmetros:
Uma invocação desse método no formato str.split (regex, n) produz o mesmo resultado que a expressão
Pattern.compile(regex).split(str, n)
Parâmetros:
regex – a expressão regular delimitante
limite – o limite do resultado, conforme descrito acima
Retornos:
a matriz de strings calculada dividindo essa string em torno de correspondências da expressão regular especificada
Lança:
PatternSyntaxException – se a sintaxe da expressão regular for inválida
Esse método existe desde a versão 1.4.
Veja também:
Código fonte: https://www.tutorialspoint.com/java/java_string_split_regexlimit.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 |
import java.io.*; public class Test { public static void main(String args[]) { String Str = new String("Welcome-to-Tutorialspoint.com"); System.out.println("Return Value :" ); for (String retval: Str.split("-", 2)) { System.out.println(retval); } System.out.println(""); System.out.println("Return Value :" ); for (String retval: Str.split("-", 3)) { System.out.println(retval); } System.out.println(""); System.out.println("Return Value :" ); for (String retval: Str.split("-", 0)) { System.out.println(retval); } System.out.println(""); } } |
startsWith(String prefix)
startsWith(String prefix) – Testa se essa sequência começa com o prefixo especificado.
public boolean startsWith(String prefix) – Testa se essa sequência começa com o prefixo especificado.
Parâmetros:
prefixo – o prefixo.
Retornos:
true se a sequência de caracteres representada pelo argumento for um prefixo da sequência de caracteres representada por esta sequência; false caso contrário. Observe também que true será retornado se o argumento for uma string vazia ou for igual a esse objeto String, conforme determinado pelo método equals (Object).
Esse método existe desde a versão 1.0.
Código fonte: https://beginnersbook.com/2013/12/java-string-startswith-method-example/
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class JavaExample{ public static void main(String args[]){ //given string String s = "This is just a sample string"; //checking whether the given string starts with "This" System.out.println(s.startsWith("This")); //checking whether the given string starts with "Hi" System.out.println(s.startsWith("Hi")); } } |
Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/String.html
Deixe um comentário