Embedded Files
Métodos importantes de string
A classe String possui dezenas de métodos. Felizmente, você precisa saber apenas um punhado para o exame. Os criadores do exame escolhem a maioria dos métodos usados pelos desenvolvedores no mundo real.
Para todos esses métodos, você precisa lembrar que uma string é uma sequência de caracteres e Java conta a partir de 0 quando indexado. A Figura 3.1 mostra como cada caractere na string "animals" é indexado.
Vamos ver treze métodos da classe String. Muitos deles são diretos então não vamos discuti-los detalhadamente. Você precisa saber como usar esses métodos.
length()
O método length() retorna o número de caracteres na String. A assinatura do método é a seguinte:
int length()O código a seguir mostra como usar length():
String string = "animals"; System.out.println(string.length()); // 7Espere. Ele gera 7? Nós não dissemos apenas que Java conta a partir de 0? A diferença é que essa contagem zero acontece apenas quando você está usando índices ou posições dentro de uma lista. Quando está determinando o tamanho ou comprimento total, o Java usa a contagem normal novamente.
charAt ()
O método charAt() permite consultar a string para descobrir qual caractere está em um determinado índice. A assinatura do método é a seguinte:
char charAt(int index)O código a seguir mostra como usar charAt():
String string = "animals"; System.out.println(string.charAt(0)); // a System.out.println(string.charAt(6)); // s System.out.println(string.charAt(7)); // throws exceptionComo os índices começam contando com 0, charAt(0) retorna o “primeiro” caractere da seqüência. Da mesma forma, charAt (6) retorna o caractere “sétimo” na sequência. charAt(7) é um problema. Ele pede o “oitavo” caractere na seqüência, mas existem apenas sete caracteres presentes. Quando algo está errado, o Java não sabe como lidar, ele lança uma exceção, como mostrado aqui. Você aprenderá mais sobre exceções no Capítulo 6, "Exceções".
java.lang.StringIndexOutOfBoundsException: String index out of range: 7indexOf()
O método indexOf () analisa os caracteres na string e encontra o primeiro índice que corresponde ao valor desejado. indexOf pode trabalhar com um caractere individual ou uma string inteira como entrada. Também pode começar a partir de uma posição solicitada. As assinaturas do método são as seguintes:
int indexOf(char ch) int indexOf(char ch, index fromIndex) int indexOf(String str) int indexOf(String str, index fromIndex)O código a seguir mostra como usar indexOf () :
String string = "animals"; System.out.println(string.indexOf('a')); // 0 System.out.println(string.indexOf("al")); // 4 System.out.println(string.indexOf('a', 4)); // 4 System.out.println(string.indexOf("al", 5)); // -1Como os índices começam com 0, o primeiro 'a' corresponde a essa posição. A segunda declaração procura por uma string mais específica e então combina mais tarde. A terceira declaração diz ao Java que não deve sequer olhar para os caracteres até chegar ao índice 4. A declaração final não encontra nada porque começa a cuidar do ocorrido. Ao contrário de charAt() , o método indexOf() não lança uma exceção se não puder encontrar uma correspondência. indexOf() retorna –1 quando nenhuma correspondência for encontrada. Como os índices começam com 0, o chamador sabe que –1 não seja um índice válido. Isso torna um valor comum para um método identificar que o chamador não encontrou nenhuma correspondência.
substring()
O método substring () também procura caracteres em uma string. Retorna partes da string. O primeiro parâmetro é o índice para começar com a string retornada. Como de costume, esta é uma índice baseado em zero. Existe um segundo parâmetro opcional, que é o índice final que você deseja parar.
Observe que dissemos "parar em" em vez de "incluir". Isso significa que o parâmetro endIndex é permitido ser 1 após o final da sequência se você quiser parar no final da sequência. Isso seria redundante, já que você poderia omitir o segundo parâmetro inteiramente neste caso. Em seu próprio código, você deve evitar essa redundância. Não se surpreenda se o exame usa-lo embora. As assinaturas do método são as seguintes:
int substring(int beginIndex) int substring(int beginIndex, int endIndex)O código a seguir mostra como usar substring () :
String string = "animals"; System.out.println(string.substring(3)); // mals System.out.println(string.substring(string.indexOf('m'))); // mals System.out.println(string.substring(3, 4)); // m System.out.println(string.substring(3, 7)); // malsO método substring() é o método String mais complicado no exame. O primeiro exemplo diz para levar os caracteres começando com o índice 3 até o final, o que nos dá "mals". O segundo exemplo faz a mesma coisa: chama indexOf () para obter o índice em vez de hard-coding. Esta é uma prática comum ao codificar porque você pode não conhecer o indexar antecipadamente.
O terceiro exemplo diz para pegar os caracteres começando com o índice 3 até, mas não incluindo o caracter no índice 4 - que é uma maneira complicada de dizer que queremos uma String com um caractere: o do índice 3. Isso resulta em "m". O último exemplo diz para levar o caracteres começando com o índice 3 até chegarmos ao índice 7. Como o índice 7 é o mesmo que o final da string, é equivalente ao primeiro exemplo.
Esperamos que isso não seja muito confuso. Os próximos exemplos são menos óbvios:
System.out.println(string.substring(3, 3)); // empty string System.out.println(string.substring(3, 2)); // throws exception System.out.println(string.substring(3, 8)); // throws exceptionO primeiro exemplo neste conjunto imprime uma string vazia. A solicitação é para caracteres iniciantes com índice 3 até chegar ao índice 3. Já que começamos e terminamos com o mesmo índice, não há caracteres no meio. O segundo exemplo neste conjunto lança uma exceção porque os índices não podem ser atrasados. Java sabe perfeitamente bem que nunca chegará ao índice 2 se começa com o índice 3. O terceiro exemplo diz continuar até o oitavo caractere. Não há oitava posição, então o Java lança uma exceção. Concedido, que não há sétimo caractere também, mas pelo menos existe a posição invisível do “fim da string”.
Vamos rever isso mais uma vez, pois substring() é muito complicado. O método retorna o string a partir do índice solicitado. Se um índice final for solicitado, ele para imediatamente antes desse índice. Caso contrário, vai para o final da string.
toLowerCase() and toUpperCase()
Ufa. Depois desse exercício mental, é bom ter métodos que façam exatamente o que eles soa como bom! Esses métodos facilitam a conversão de seus dados. As assinaturas do método são as seguintes:
String toLowerCase(String str) String toUpperCase(String str)O código a seguir mostra como usar esses métodos:
String string = "animals"; System.out.println(string.toUpperCase()); // ANIMALS System.out.println("Abc123".toLowerCase()); // abc123Esses métodos fazem o que eles dizem. toUpperCase() converte todos os caracteres minúsculos para maiúsculas na string retornada. toLowerCase() converte qualquer caractere maiúsculo para minúsculo na string retornada. Esses métodos deixam sozinhos quaisquer outros caracteres além de letras. Além disso, lembre-se de que as strings são imutáveis, portanto a string original permanece a mesma.
equals() and equalsIgnoreCase()
O método equals() verifica se dois objetos String contêm exatamente os mesmos caracteres na mesma ordem. O método equalsIgnoreCase() verifica se duas cadeias objetos contêm os mesmos caracteres, com a exceção de que ele converterá os caracteres caso, se necessário. As assinaturas do método são as seguintes:
boolean equals(String str) boolean equalsIgnoreCase(String str)O código a seguir mostra como usar esses métodos:
System.out.println("abc".equals("ABC")); // false System.out.println("ABC".equals("ABC")); // true System.out.println("abc".equalsIgnoreCase("ABC")); // trueEste exemplo deve ser razoavelmente intuitivo. No primeiro exemplo, os valores não são exatamente mesmo. No segundo, eles são exatamente os mesmos. No terceiro, diferem apenas por caso, mas está tudo bem porque nós chamamos o método que ignora diferenças no caso.
startsWith() and endsWith()
Os métodos startsWith () e endsWith () observam se o valor fornecido corresponde com parte da String . As assinaturas do método são as seguintes:
boolean startsWith(String prefix) boolean endsWith(String suffix)O código a seguir mostra como usar esses métodos:
System.out.println("abc".startsWith("a")); // true System.out.println("abc".startsWith("A")); // false System.out.println("abc".endsWith("c")); // true System.out.println("abc".endsWith("a")); // falseMais uma vez, nada de surpreendente aqui. Java está fazendo uma verificação com diferenciação de maiúsculas e minúsculas nos valores fornecidos.
contains()
O método contains () também procura correspondências na String. Não é tão particular quanto startsWith() e endsWith() - a correspondência pode estar em qualquer lugar na String. O método assinatura é a seguinte:
boolean contains(String str)O código a seguir mostra como usar esses métodos:
System.out.println("abc".contains("b")); // true System.out.println("abc".contains("B")); // falseNovamente, temos uma pesquisa que diferencia maiúsculas de minúsculas na String. O método contains () é um método conveniente assim você não tem que escrever str.indexOf (otherString) != -1 .
replace()
O método replace () faz uma pesquisa simples e substitui a string. Há uma versão que leva parâmetros de char, bem como uma versão que leva parâmetros CharSequence. Um CharSequence é uma maneira geral de representar várias classes, incluindo String e StringBuilder. É chamado de interface, que abordaremos no Capítulo 5, "Design de classe".
As assinaturas do método são as seguintes:
String replace(char oldChar, char newChar) String replace(CharSequence oldChar, CharSequence newChar)O código a seguir mostra como usar esses métodos:
System.out.println("abcabc".replace('a', 'A')); // AbcAbc System.out.println("abcabc".replace("a", "A")); // AbcAbcO primeiro exemplo usa a primeira assinatura do método, passando parâmetros char. O segundo exemplo usa a segunda assinatura do método, passando em parâmetros String .
trim()
Você conseguiu passar por todos os métodos String que você precisa conhecer, exceto um. Nós deixamos o mais fácil para o final. O método trim () remove espaços em branco do começo e do fim de uma string. Em termos do exame, o espaço em branco consiste em espaços junto com o \t (tab) e \n (nova linha) caracteres. Outros caracteres, como \r (retorno de carriage), também estão incluídos o que é cortado. A assinatura do método é a seguinte:
public String trim()O código a seguir mostra como usar este método:
System.out.println("abc".trim()); // abc System.out.println("\t a b c\n".trim()); // a b cO primeiro exemplo imprime a string original porque não há caracteres em branco no começo ou no fim. O segundo exemplo se livra da guia principal, dos espaços subseqüentes, e a nova linha à direita. Deixa os espaços que estão no meio da string.
Google Sites
Report abuse