Classe String

Q: P: Por que usar equals para comparação de strings?

R: Porque == compara endereços de objetos, enquanto equals() compara conteúdo.

Strings são um dos tipos de dados mais comumente usados. Esta lição cobre como usar a classe String em Java.

Criando Strings

Duas Formas de Criar

JAVA

// Método 1: Literal de string (recomendado)
String s1 = "Hello";

// Método 2: palavra-chave new
String s2 = new String("Hello");

Diferença

JAVA

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1 == s2);      // true (mesmo objeto)
System.out.println(s1 == s3);      // false (objetos diferentes)
System.out.println(s1.equals(s3)); // true (mesmo conteúdo)

💡 Recomendação: Use literais de string para criar strings—são mais eficientes. Java armazena literais de string em cache.

Características das Strings

Imutabilidade

Uma vez que um objeto String é criado, seu conteúdo não pode ser alterado.

JAVA

String s = "Hello";
s = s + " World";  // Cria um novo objeto, não modifica o original

Exemplo: Imutabilidade da String

JAVA

public class StringImmutable {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = s1.concat(" World");
        
        System.out.println(s1);  // Hello (original inalterado)
        System.out.println(s2);  // Hello World (novo objeto)
    }
}

▶ Experimente

Métodos Comuns

Comprimento e Verificações

Método	Descrição	Exemplo
`length()`	Comprimento da string	`"Hello".length()` → 5
`isEmpty()`	É string vazia	`"".isEmpty()` → true
`isBlank()`	É em branco (apenas espaços)	`" ".isBlank()` → true
`contains()`	Contém substring	`"Hello".contains("ell")` → true
`startsWith()`	Começa com	`"Hello".startsWith("He")` → true
`endsWith()`	Termina com	`"Hello".endsWith("lo")` → true

Exemplo: Comprimento e Verificações

JAVA

public class StringCheck {
    public static void main(String[] args) {
        String s = "Hello, World!";
        
        System.out.println("Comprimento: " + s.length());          // 13
        System.out.println("Contém World: " + s.contains("World")); // true
        System.out.println("Começa com Hello: " + s.startsWith("Hello")); // true
        System.out.println("Termina com !: " + s.endsWith("!"));       // true
    }
}

▶ Experimente

Busca

Método	Descrição	Exemplo
`indexOf()`	Primeira ocorrência	`"Hello".indexOf("l")` → 2
`lastIndexOf()`	Última ocorrência	`"Hello".lastIndexOf("l")` → 3
`charAt()`	Caractere no índice	`"Hello".charAt(1)` → 'e'

Exemplo: Busca

JAVA

public class StringSearch {
    public static void main(String[] args) {
        String s = "Hello, World!";
        
        System.out.println("indexOf('l'): " + s.indexOf('l'));       // 2
        System.out.println("lastIndexOf('l'): " + s.lastIndexOf('l')); // 10
        System.out.println("charAt(0): " + s.charAt(0));            // H
    }
}

▶ Experimente

Substring

Método	Descrição	Exemplo
`substring(int begin)`	Do início ao fim	`"Hello".substring(2)` → "llo"
`substring(int begin, int end)`	Do início ao fim (exclusivo)	`"Hello".substring(1,4)` → "ell"

Exemplo: Substring

JAVA

public class StringSubstring {
    public static void main(String[] args) {
        String s = "Hello, World!";
        
        System.out.println(s.substring(7));       // World!
        System.out.println(s.substring(0, 5));    // Hello
    }
}

▶ Experimente

Conversão

Método	Descrição	Exemplo
`toUpperCase()`	Para maiúsculas	`"Hello".toUpperCase()` → "HELLO"
`toLowerCase()`	Para minúsculas	`"Hello".toLowerCase()` → "hello"
`trim()`	Remover espaços início/fim	`" Hi ".trim()` → "Hi"
`strip()`	Remover espaços (mais forte)	`" Hi ".strip()` → "Hi"

Substituição

Método	Descrição	Exemplo
`replace()`	Substituir todos	`"Hello".replace("l","L")` → "HeLLo"
`replaceAll()`	Substituição regex	`"a1b2c".replaceAll("\\d","")` → "abc"
`replaceFirst()`	Substituir primeiro	`"a1b1".replaceFirst("1","X")` → "aXb1"

Divisão e Junção

Método	Descrição	Exemplo
`split()`	Dividir string	`"a,b,c".split(",")` → ["a","b","c"]
`join()`	Juntar strings	`String.join("-","a","b")` → "a-b"
`concat()`	Concatenar	`"Hello".concat(" World")` → "Hello World"

Exemplo: Divisão e Junção

JAVA

public class StringSplitJoin {
    public static void main(String[] args) {
        // Dividir
        String csv = "Alice,Bob,Charlie";
        String[] names = csv.split(",");
        for (String name : names) {
            System.out.println(name);
        }
        
        // Juntar
        String joined = String.join(" | ", names);
        System.out.println(joined);  // Alice | Bob | Charlie
    }
}

▶ Experimente

Comparação de Strings

== vs equals

JAVA

String s1 = "Hello";
String s2 = "Hello";
String s3 = new String("Hello");

System.out.println(s1 == s2);      // true (mesmo objeto)
System.out.println(s1 == s3);      // false (objetos diferentes)
System.out.println(s1.equals(s3)); // true (mesmo conteúdo)

⚠️ Importante: Sempre use equals() para comparar strings, não ==. == compara endereços, equals() compara conteúdo.

compareTo()

Comparar strings em ordem de dicionário.

JAVA

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b));  // Negativo (a vem antes de b)
System.out.println(b.compareTo(a));  // Positivo (b vem depois de a)
System.out.println(a.compareTo(a));  // 0 (igual)

equalsIgnoreCase()

Comparar ignorando maiúsculas/minúsculas.

JAVA

String s1 = "Hello";
String s2 = "hello";

System.out.println(s1.equals(s2));            // false
System.out.println(s1.equalsIgnoreCase(s2));   // true

Formatação

String.format()

JAVA

String name = "Alice";
int age = 25;
double score = 95.5;

String info = String.format("Nome: %s, Idade: %d, Pontuação: %.1f", name, age, score);
System.out.println(info);  // Nome: Alice, Idade: 25, Pontuação: 95.5

Especificadores de Formato

Especificador	Descrição	Exemplo
`%s`	String	`%s` → "Hello"
`%d`	Inteiro	`%d` → 42
`%f`	Ponto flutuante	`%.2f` → 3.14
`%n`	Nova linha	—

Strings e Arrays

JAVA

// String → array de caracteres
String s = "Hello";
char[] chars = s.toCharArray();

// array de caracteres → String
String s2 = new String(chars);

// String → array de bytes
byte[] bytes = s.getBytes();

// array de bytes → String
String s3 = new String(bytes);

StringBuilder

Quando você precisa modificar strings frequentemente, StringBuilder é mais eficiente.

JAVA

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();  // "Hello World"

💡 Recomendação: Use + para concatenações únicas. Use StringBuilder para múltiplas concatenações.

❓ Perguntas Frequentes

P: Como escolher entre String, StringBuilder e StringBuffer? R: String é imutável, adequada para poucas operações. StringBuilder é mutável, use em contextos de thread única. StringBuffer é mutável e thread-safe.

P: Por que usar equals para comparação de strings? R: Porque == compara endereços de objetos, enquanto equals() compara conteúdo.

P: substring cria um novo objeto? R: Sim. substring retorna um novo objeto String.

📖 Resumo

String é imutável—toda modificação cria um novo objeto
Use literais de string para criação (mais eficiente)
Sempre use equals() para comparação de strings
Métodos comuns: length/charAt/substring/equals/indexOf/trim/replace/split
Use StringBuilder para modificações frequentes

📝 Exercícios

Operações com string: Conte quantas vezes um caractere específico aparece em uma string
Inverter string: Escreva um método para inverter uma string
Contagem de palavras: Conte o número de palavras em uma string (separadas por espaços)

Próxima Lição

Na próxima lição, aprenderemos sobre StringBuilder — usando strings mutáveis.