String é uma classe contida no pacote java.lang e que descende da classe java.lang.Object.

De forma conceitual podemos dizer que é uma “sequência de caracteres usada como uma única unidade”. Os valores armazenados nesse tipo de variável são representados como literais de string – sequência de caracteres entre aspas duplas. Os valores podem ser caracteres normais (letras e números) ou caracteres especiais como +, -, * / e $.

É importante comentar que o objeto String é imutável, portanto significa que seu conteúdo não pode ser alterado depois que é criado, pois não existe nenhuma ação que faça esse tipo de alteração na classe String. Quando for usada a mesma variável com outro conteúdo ou até mesmo realizar uma concatenação, essa variável irá criar mais um espaço na memória, ou seja, vai gerar uma cópia e não irá alterar o conteúdo original.

Anatomia das declarações

O processo de declaração de um tipo string é formado pelos seguintes itens:

Declaração de variável primitiva
Figura 1. Declaração de variável primitiva
Declaração de variável por referência
Figura 2. Declaração de variável por referência
public class DeclaracaoString {
	public static void main(String[] args) {	
		String nome = “José”;
String sobrenome = “Silva”;
		System.out.printf("O nome é.: %s %s”, nome, sobrenome);
	}
}
Listagem 1. Declaração de uma string

Na classe String é possível criar o objeto e passar alguns parâmetros, que são oferecidos pelos construtores da classe, o que ajuda na inicialização dos objetos String. Abaixo é mostrado diversas formas de como podemos instanciar novos objetos String e passar parâmetros utilizando os construtores.

public class TestaConstrutoresStrings {
	public static void main(String[] args) {
		String nome = new String("José Silva");
		String sobrenome = new String();
		String nomeCompleto = new String(nome);
char[] iniciaisMeses = {‘j’,’f’, ’m’, ’a’, ’m’, ’j’, ’j’, ’a’, ’s’, ’o’, ’n’, ’d’};
		String meses = new String(iniciaisMeses);		

		System.out.printf("Nome.: = %s\n ", nome);
System.out.printf("SobreNome.: = %s\n ", sobreNome);
System.out.printf("Nome Completo.: = %s\n ", nomeCompleto);
System.out.printf("Caracteres dos Meses.: = %s\n ", meses);
	}
}
Listagem 2. Criando construtores e variáveis de referência

A String por ser uma classe, possui em sua formação tudo que uma classe possui: construtores, atributos e métodos. Vamos falar sobre os métodos dessa classe, tais como o que retorna o comprimento de uma string, o que recupera um caractere em uma localização específica em uma string ou um conjunto de caracteres como um arrray char.

Método Length

Retorna o tamanho de uma String. Na Listagem 03 está sendo impresso o tamanho da variável e verificando uma condição com o tamanho através do método que a classe String possui.

public class Exemplo_length {
	public static void main(String[] args) {
		String nomeCurso = "Java para Web";

	System.out.printf("\nTamanho da variável nomeCurso: %d", nomeCurso.length());


if(nomeCurso.length() > 13){
			System.out.println("\nTamanho maior que 13");
			
		}else if(nomeCurso.length() == 13){
			System.out.println("\nTamanho igual a 13");
			
		}else{
			System.out.println("\nTamanho menor que 13");
		}
	}
}
Listagem 3. Exemplo do método length

Método charAt

Retorna o caractere em uma localização específica em uma String. Esse método possui um parâmetro do tipo inteiro que é usado como índice, retornando a partir dessa posição inserida nesse parâmetro, sendo que quando percorrido um texto o índice sempre começa a ser contado do número 0 (zero) em diante.

public class Exemplo_charAt {
	public static void main(String[] args) {
		String nomeCurso = "JAVA para Web";

	if(nomeCurso.charAt(1) == ‘A’)
		System.out.println(“O caractere A está na posição 1”);

        	//FORMA DINÂMICA
	char percorreString = nomeCurso.charAt(1);
	System.out.println(“Na posição 1 tem o caractere.: “+percorreString);

	}
}
Listagem 4. Exemplo método charAt

Método getChars

Recupera um conjunto de caracteres de uma String. Esse método possui os seguintes parâmetros de entrada:

  • srcBegin – Índice do primeiro caractere da string a ser copiada.
  • srcEnd - Índice depois da última string a ser copiada.
  • dst – O destino do array.
  • dstBegin – o início do deslocamento no array de destino.
public class Exemplo_getChars {
	public static void main(String[] args) {
		String nomeCurso = new String("Curso Java Web");
		//É A DIFERENÇA DO 1º E 2º PARÂMETRO DO MÉTODO getChars
//SE DIMINUIR OS 2 O RESULTADO TEM QUE SER O MESMO INICIADO NO ARRAY
char[] numIndice = new char[7];

		nomeCurso.getChars(2, 9, numIndice, 0);
       		System.out.print("Valores Copiados \n");
         
        		for(char caracter : numIndice) 
        	 		System.out.print("["+caracter+"]");
         
        		System.out.println("\n\n Abaixo Índice demonstrativo dos
        		valores copiados\n");
         
         		int[] b = {0,1,2,3,4,5,6};
         		for(int i = 0; i < b.length; i++)
        	 		System.out.print("["+b[i]+"]");
	}
}
Listagem 5. Exemplo do método getChars

Métodos de Comparação

A classe String fornece vários métodos para comparar strings. Quando é realizada uma comparação entre strings, o compilador compara os números dos caracteres das partes, pois cada letra é representada por um número. As comparações com o operador de igualdade (==) servem para comparar valores de tipos primitivos, o resultado é verdadeiro true se ambos os valores forem idênticos. Se as referências forem comparadas com sinal de igualdade (==), o resultado será verdadeiro (true) se as duas referências indicam o mesmo objeto na memória.

public class Ex_Atribuicao_Referencias {

	public static void main(String[] args) {
		String a = new String("ab");
        		String b = a;

        		if(a == b)
       		        System.out.println("A e B são iguais!");

}
}
Listagem 6. Exemplo de atribuição de referências

Para comparar o conteúdo real das variáveis de instância, é chamado o método especial para esse tipo de ação conhecido como equals.

Método Equals

É um método da classe Object sobrescrito na clase String, que serve para testar dois objetos.

public class Testa_Metodo_Equals {

	public static void main(String[] args) {
		String nome1 = new String("Carlos");
		String nome2 = new String("Carla");
		
		Character letraA = new Character('a');
		Character letraB = new Character('a');
		
		if(nome1.equals(nome2)){
			System.out.println("Os nomes são iguais!");
		}else{
			System.out.println("Os nomes são diferentes!");
		}
		
		if(letraA.equals(letraB)){
			System.out.println("As letras 'A' e 'B' são iguais!");
		}else{
			System.out.println("As letras 'A' e 'B' são diferentes!");
		}
	}
}
Listagem 7. Exemplo de comparação com método equals

Método compareTo

Esse método pode retornar 0 se as strings forem iguais, um número negativo se a string que invoca o compareTo for menor que a string que é passada como um argumento e um número positivo se a string que invoca o compareTo for maior que a string que é passada como argumento.

 
public class Testa_Metodo_Equals {
	public static void main(String[] args) {
String nome1 = new String("Carlos");
		String nome2 = new String("Carla");
		
		Character letraA = new Character('a');
		Character letraB = new Character('a');
		
		System.out.println("letraA.compareTo(letraB) = "+letraA.compareTo(letraB));
		System.out.println("nome2.compareTo(nome1) = "+nome2.compareTo(nome1));
		System.out.println("nome1.compareTo(nome2) = "+nome1.compareTo(nome2));
}
}
Listagem 8. Exemplo do método compareTo

Método equalsIgnoreCase

Esse método ignora a distinção entre letras maiúsculas e minúsculas nas duas strings comparadas.

public class Testa_Metodo_equalsIgnoreCase {
	public static void main(String[] args) {
String nome1 = new String("Carlos");
	String nome2 = new String("carlos");
		
	if(nome1.equalsIgnoreCase(nome2))
		System.out.println("Os nomes tem o mesmo significado!"); 
}
}
Listagem 9. Exemplo do método equalsIgnoreCase

Métodos startsWith e endswith

Os métodos startsWith e endsWith aceitam uma string e um número inteiro como argumentos, retornando um valor booleano que indica se a string inicia ou termina, respectivamente, com o texto informado a partir da posição dada.

public class String_Metodos_StartWith_e_EndsWith {
	public static void main(String[] args) {	
		String[] nomes = { "iniciado", "iniciando", "finalizado", "finalizando"};
		for(String recebeNomes : nomes){
	   		if(recebeNomes.startsWith("in"))
	      		System.out.printf("\"%s\" inicia com \"in\" \n", recebeNomes);
		}
		System.out.println();

		//TESTA MÉTODO STARWITH INICIANDO DA POSIÇÃO 2 DE STRING
		for(String recebeNomes : nomes){
	  		 if(recebeNomes.startsWith("ici",2))
			System.out.printf("\"%s\" inicia com \"ici\" na posição 2 \n", recebeNomes);
		}
		System.out.println();

		for(String recebeNomes : nomes)	{
	   		if(recebeNomes.endsWith("ado"))
			System.out.printf("\"%s\" termina com \"ado\" \n", recebeNomes);
		}
  	}
} 
Listagem 10. Exemplo do método startsWith e endswith

Métodos indexOf e lastIndexOf

Permitem a localização de caracteres e substrings especificados em strings.

indexOf

Localiza a primeira ocorrência de um caractere em uma string. Se o método localizar o caractere, é retornado o índice do caractere na String, caso contrário retorna -1. Existem duas versões do indexOf que procuram caracterers em uma String.

  • 1ª versão – aceita um inteiro que é conhecido como o número do índice na String.
  • 2ª versão – aceita dois argumentos inteiros – o caractere e o índice inicial em que a pesquisa da String deve iniciar.

lastIndexOf

Localiza a última ocorrência de um caractere em uma string. O método procura do fim da string em direção ao começo, se encontrar o caractere é retornado o seu índice na string, caso contrário retorna -1. Existem duas versões do lastIndexOf que pesquisam por caracteres em uma string.

  • 1ª versão – utiliza um inteiro do caractere.
  • 2ª versão – aceita 2 argumentos – um inteiro de caractere e o índice a partir do qual iniciar a pesquisa de trás para frente.
public class Testa_Metodo_Localiza_Caracteres {
public static void main(String[] args) {        
        String letras = "abcadefghijklmcopqrsdeftuvz";
        //TESTA indexOf PARA LOCALIZAR UM CARACTERE EM UM STRING
        System.out.printf("Último 'c' está localizado no index %d\n", letras.indexOf('c'));
        System.out.printf("Último 'a' está localizado no index %d \n", letras.indexOf('a',1));
 
         //-1 NÃO EXISTE
        System.out.printf("'$' está localizado no index %d\n\n", letras.indexOf('$'));
         
            //TESTA lastIndexOf PARA LOCALIZAR UM CARACTERE EM UMA STRING
        System.out.printf("Último 'c' está localizado no index %d\n",letras.lastIndexOf('c'));
        System.out.printf("Último 'a' está localizado no index %d\n",letras.lastIndexOf('a',5));
        System.out.printf("Último '$' está localizado no index %d\n", letras.lastIndexOf('$'));
         
        //TESTA indexOf PARA LOCALIZAR UMA SUBSTRING EM UMA STRING
    System.out.printf("\"def\" está localizado no index %d\n", letras.indexOf("def"));
         
        //2 argumento string e outro o ponto inicial que começará a pesquisa
        System.out.printf("\"def\" está localizado no index %d\n", letras.indexOf("def", 7)); 
        System.out.printf("\"hello\" está localizado no index %d\n\n",letras.indexOf("hello"));
         
}
}
Listagem 11. Exemplo dos métodos indexOf e lastIndexOf

Método substring

Permite extrair substrings de strings e fornece 2 métodos substring para permitir que um novo objeto seja criado copiando parte de um objeto string existente. Cada método retorna um novo objeto desse tipo. Neste método existem duas versões desse método que são:

  • 1ª versão – aceita um argumento inteiro, esse número especifica o índice inicial na string especificada, a partir da qual os caracteres devem ser copiados. A substring retornada contém uma cópia dos caracteres desde o índice inicial até o final da string.
  • 2ª versão – aceita dois argumentos do tipo inteiro – o índice inicial a partir do qual copia os caracteres da string original e o índice um a mais além do último caractere que será copiado (copiar até, mas não incluindo, esse índice na String). A substring retornada contém uma cópia dos caracteres especificados da string original.
public class Testa_Metodo_substring {
    public static void main(String[] args) {
String nome = "José Silveira"; 
System.out.println("String : " + nome);
 
String substring = nome.substring(5);
System.out.println("String depois da 3º index: " + "["+substring+"]");
  
substring = nome.substring(1, 6);
System.out.println("Substring (1,6): " + "["+substring+"]");
 
}
}
Listagem 12. Exemplo do método substring

Método replace

Retorna um novo objeto contendo a string original com um trecho especificado substituído por outra expressão indicada. Esse método deixa a string original inalterada. A versão sobrecarregada do método replace permite substituir substrings em vez de caracteres individuais.

public class Testa_Metodo_replace {
public static void main(String[] args) {
String nome = "mesquita";
        String nomeAlterado = nomee.replace('e', 'o');
        System.out.println(nomeAlterado);
}
}
Listagem 13. Exemplo do método replace

Método toUpperCase

Retorna uma nova string com o conteúdo da original convertido para letras maiúsculas, mantendo a original inalterada.

Método toLowerCase

De forma semelhante ao anterior, o toLowerCase retorna uma cópia de uma string com todas as letras convertidas para minúsculo, mantendo a original inalterada.

public class Testa_Metodo_replace {
public static void main(String[] args) {
String nomeA = "joaquina";
        String nomeB = “Paulo”;
     
System.out.println(nomeA.toUpperCase());
System.out.println(nomeB.toLowerCase());
 
}
}
Listagem 14. Exemplo do método toLowerCase e toUpperCase

Método trim

Gera um novo objeto string, removendo todos os caracteres de espaço em branco que aparecem no início ou no fim da string em que o método opera. O método retorna um novo objeto string contendo a string sem espaço em branco inicial ou final. A string original permanece inalterada.

Método toCharArray

Cria um novo array de caracteres que contém uma cópia dos caracteres da variável apontada.

public class Testa_Metodo_ trim_E_toCharArray {
public static void main(String[] args) {
String s1 = "olá";
        String s2 = "TCHAU";
        String s3 = " espaços    ";
         
        System.out.println("s1 = "+ s1 + "\n" + "s2 = "+ s2 + "\n" + "s3 = "+s3);
         
        //MÉTODO REPLACE
        System.out.printf("Replace 'l' por 'L' no s1: %s\n\n", s1.replace('l', 'L'));
         
        //MÉTODO UPPER E LOWERCASE
        System.out.printf("s1.toUpperCase() = %s\n", s1.toUpperCase());
        System.out.printf("s2.toUpperCase() = %s\n\n", s2.toLowerCase());
         
        //MÉTODO TRIM - REMOVE OS ESPAÇOS
        System.out.printf("s3 depois do trim = \"%s\"\n\n", s3.trim());
 
                //CONVERTERU O olá PARA CHAR
        char[] charArray = s1.toCharArray(); 
        System.out.printf("s1 como um caracter array = ");
         
        for(char caracter : charArray)
            System.out.print(caracter);
}
}
Listagem 15. Exemplo do método trim e toCharArray

Concatenando strings

O método concat concatena dois objetos string e retorna um novo objeto string que contém os caracteres das duas strings originais.

public class Testa_Metodo_ trim_E_toCharArray {
public static void main(String[] args) {
String s1 = "olá";
		String s2 = "TCHAU";
		String s3 = " espaços    ";
		
		System.out.println("s1 = "+ s1 + "\n" + "s2 = "+ s2 + "\n" + "s3 = "+s3);
		
		//MÉTODO REPLACE
		System.out.printf("Replace 'l' por 'L' no s1: %s\n\n", s1.replace('l', 'L'));
		
		//MÉTODO UPPER E LOWERCASE
		System.out.printf("s1.toUpperCase() = %s\n", s1.toUpperCase());
		System.out.printf("s2.toUpperCase() = %s\n\n", s2.toLowerCase());
		
		//MÉTODO TRIM - REMOVE OS ESPAÇOS
		System.out.printf("s3 depois do trim = \"%s\"\n\n", s3.trim());

            	//CONVERTERU O olá PARA CHAR
		char[] charArray = s1.toCharArray(); 
		System.out.printf("s1 como um caracter array = ");
		
		for(char caracter : charArray)
			System.out.print(caracter);
}
}
Listagem 16. Exemplo do método concat

Método String.valueOf

Converte os tipos primitivos em um objeto do tipo String.

public class Testa_Metodo_valueOf {
public static void main(String[] args) {
double d = 102939939.939;
            boolean b = true;
             long l = 1232874;
             char[] arrayChar = {'a', 'b', 'c', 'd', 'e', 'f','g' };
 
            System.out.println("Retorna Valor : " + String.valueOf(d) );
             System.out.println("Retorna Valor: " + String.valueOf(b) );
            System.out.println("Retorna Valor : " + String.valueOf(l) );
            System.out.println("Retorna Valor : " + String.valueOf(arrayChar) );
 
}
}
Listagem 17. Exemplo do método valueOf