Programação Orientada a

Objetos em Java

Manipulação de String
Concatenando Strings

Usando o operador ‘+’

String h = “Hello”;

String helloWorld = h + “ World!!!”;

Usando a função concat()

String h = “Hello”;

String helloWorld = h.concat(“ World!!!”);
String

Java possui uma biblioteca que contém a
classe String (java.lang.String).

Portanto, em Java String não é um tipo primitivo.

Em Java, strings são implementadas como
sequências de valores char, que são valores
de representação Unicode.

Ex. de strings:

String e = “” ; //string vazia

String hello = “hello!!” ;
Comparando Strings

Método equals, retorna true se a comparação for
verdadeira e false caso contrario.

"Hello".equals(greeting)

// false

Método equalsIgnoreCase, não faz distinção entre

letra maiúscula e minúscula.

"Hello".equalsIgnoreCase("hello")

// true
Comparando Strings

Método compareTo, compara valores
numéricos dos caracteres que compõem a
string.

Retorna um número negativo caso a string seja
menor, 0 se igual, e um número positivo caso a
string atual seja maior que a comparada.

“aaaa". compareTo(“bbbb")

// valor de retorno é negativo
Comparando Strings

Método regionMatches, compara partes de
dois objetos strings.

string_0.regionMatches(indice_0, string_1,
indice_1, quantidadeDeCaracter);

// retorna true se forem iguais

string_0.regionMatches(true, indice_0, string_1,
indice_1, quantidadeDeCaracter);

// retorna true se forem iguais independente de
letras maiúsculas e minúsculas
Comparando Strings

Método startsWith, determina se uma string
inicia com os caracteres da string passada no
argumento.

“hello”.startsWith(“hel”); // true

“hello”.startsWith(“ll”, 2); // true /*índice de inicio
da comparação*/

Método endsWith, determina se uma string
termina com os caracteres da string passada
no argumento.

“hello”.endsWith(“llo”); // true
Localizando caracter e
substrings em Strings

Retorna o índice da primeira ocorrência do caracter
ou substring, caso contrário retorna -1;

int indexOf(String str);

int indexOf(String str, int indice_inicio);

int indexOf(int cp);

int indexOf(int cp, int indice_inicio);

Retorna o índice da ultima ocorrência do caracter ou
substring, caso contrário retorna -1;

int lastIndexOf(String str);

int lastIndexOf(String str, int indice_inicio);

int lastindexOf(int cp);

int lastindexOf(int cp, int indice_inicio);
Extraindo substring a partir de
Strings

Método substring, permite a criação de
um novo objeto String a partir de um
objeto String existente.

Recebe um argumento

letras.substring(indice_inicial); // índice inicial a
partir do qual os caracteres vão ser copiados

letras.substring(indice_inicial, indice_final); //
índice existente alem do ultimo caracter a ser
copiado.
Métodos diversos

String replace(CharSequence oldString,
CharSequence newString) ; // substitui o
valor da string antiga pela nova

String toLowerCase() ; // retorna uma string
com todos os caracteres minúsculos

String toUpperCase() ; // retorna uma string
com todos os caracteres maiúsculos

String trim() ; // tira espaços em branco

int length(); // retorna o tamanho da string
Métodos diversos

char charAt(int index); // retorna o
caracter localizado naquele índice

int codePointAt(int index) ; // retorna o
valor correspondente ao caracter
localizado naquele índice
Método valueOf

O método valueOf transforma o valor
passado em um objeto string.

String.valueOf( charArray );

String.valueOf( charArray, indice,
quantidade );

Existem outras sete versões, que
recebem argumentos do tipo boolean,
char, int, long, float, double e Object.
Método intern

O método intern retorna uma referência
da string que chamou o método.

String s = s1.intern();

If ( s == s1 )
// true;
String Tokenizers

Ao ler uma linha da entrada, nós pegamos
uma única string longa. Quando queremos
dividi-la em strings individuais usamos a
classe

StringTokenizer tokenizer = new
StringTokenizer(line, "|");

Construtores

StringTokenizer(String str, String delim)

StringTokenizer(String str) // delimitador default "
\t\n\r" ;
String Tokenizers

Se não for especificado um grupo de
delimitadores, os delimitadores default são "
\t\n\r", que são, todos caracteres em branco
(espaço, tab, nova linha, e ENTER);

while (tokenizer.hasMoreTokens())
{
String token = tokenizer.nextToken();
process token
}
String Tokenizers

Métodos

boolean hasMoreTokens() // retorna true
se existe mais tokens

String nextToken() // retorna próximo
token; lança um NoSuchElementException
se não houver mais tokens.

String nextToken(String delim) // o novo
grupo de delimitador é usado

int countTokens() // retorna o número de
tokens
StringBuffer

String mutável.

StringBuffer sb = new StringBuffer(“Hello”);

System.out.println(“buffer = ”+ sb);

System.out.println(“tamanho = ”+
sb.length()); // tamanho = 5

System.out.println(“capacidade =”+
sb.capacity()); // capacidade = 5 + 16
StringBuffer

ensureCapacity

StringBuffer sb = new StringBuffer(“Hello”);

System.out.println(“buffer = ”+ sb);

System.out.println(“tamanho = ”+ sb.length());

sb.ensureCapacity(40);

System.out.println(“capacidade =”+ sb.capacity()); //
capacidade = 44 (21 * 2 + 2)
StringBuffer

setLength

StringBuffer sb = new StringBuffer(“Hello”);

sb.setLength(3);

System.out.println(“buffer = ”+ sb);

System.out.println(“tamanho = ”+
sb.length()); // tamanho = 3

System.out.println(“capacidade =”+
sb.capacity()); // capacidade = 21
StringBuffer

setCharAt

StringBuffer sb = new StringBuffer(“Hello”);

sb.setCharAt(1,’a’);

System.out.println(“buffer = ”+ sb); // Hallo

System.out.println(“tamanho = ”+
sb.length()); // tamanho = 5

System.out.println(“capacidade =”+
sb.capacity()); // capacidade = 21
StringBuffer

append

StringBuffer sb = new StringBuffer(“Hello”);

sb.append(“ World!”);

System.out.println(“buffer = ”+ sb); // Hello
World!

System.out.println(“tamanho = ”+
sb.length()); // tamanho = 12

System.out.println(“capacidade =”+
sb.capacity()); // capacidade = 21
StringBuffer

insert

StringBuffer sb = new StringBuffer(“Hello World!”);

sb.insert(6,“ there ”);

System.out.println(“buffer = ”+ sb);

// Hello there World!

System.out.println(“tamanho = ”+ sb.length()); // 20

System.out.println(“capacidade =”+ sb.capacity()); //
29
StringBuffer

insert

StringBuffer sb = new StringBuffer(“Hello World!”);

sb.deleteCharAt(12);

sb.delete (2, 5);

System.out.println(“buffer = ”+ sb);

// He World

System.out.println(“tamanho = ”+ sb.length()); // 9

System.out.println(“capacidade =”+ sb.capacity()); //
29