Comparação de strings: equals, equalsIgnoreCase, compareTo

1. Comparação de referências e conteúdo

Em Java, strings são objetos, não primitivos. Quando você escreve as variáveis a e b, elas podem apontar para a mesma string no pool de strings. Já c, criada via construtor, é outro objeto. O operador == compara as referências, não o texto.

String a = "hello";
String b = "hello";
String c = new String("hello");

System.out.println(a == b); // true (provavelmente string internada)
System.out.println(a == c); // false (objetos diferentes)

Demonstração do erro

String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2); // false

Embora as strings pareçam idênticas, são objetos diferentes na memória.

2. equals(): comparação do conteúdo das strings

Para comparar o conteúdo em si, use o método equals() — ele compara caractere a caractere (considerando maiúsculas/minúsculas).

String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1.equals(s2)); // true

Exemplo: comparação de senhas

String inputPassword = "Secret123";
String realPassword = "Secret123";
if (inputPassword.equals(realPassword)) 
{
    System.out.println("Acesso permitido!");
} 
else 
{
    System.out.println("Senha incorreta.");
}

Importante!

Se ao menos um objeto for null, chamar equals() levará a NullPointerException. Padrão seguro:

if ("algo".equals(someString)) { ... }

3. equalsIgnoreCase(): comparação sem diferenciar maiúsculas/minúsculas

Quando é importante ignorar o caso (por exemplo, entrada do usuário), use equalsIgnoreCase().

String name1 = "Ivan";
String name2 = "ivan";
System.out.println(name1.equalsIgnoreCase(name2)); // true

Exemplo: comparação de endereços de e-mail

String email1 = "User@Example.com";
String email2 = "user@example.com";
if (email1.equalsIgnoreCase(email2))
{
    System.out.println("Os e-mails coincidem!");
}

Resumindo: equals vs equalsIgnoreCase

equals()

false

equalsIgnoreCase()

true

4. compareTo(): comparação lexicográfica de strings

O método compareTo() realiza uma comparação lexicográfica (como em dicionários). Retorna um número negativo se a primeira string for “menor”, 0 — iguais, positivo — se for “maior”.

System.out.println("apple".compareTo("banana")); // < 0
System.out.println("apple".compareTo("apple"));  // 0
System.out.println("banana".compareTo("apple")); // > 0

a.compareTo(b) →
   < 0 — esli a idyot ran’she b
   0   — esli ravny
   > 0 — esli a idyot posle b

Como isso funciona?

• A comparação vai da esquerda para a direita pelos códigos Unicode dos caracteres.
• Na primeira diferença, é retornada a diferença entre os códigos dos caracteres.
• Se uma string for prefixo da outra, a mais curta é “menor”.

System.out.println("cat".compareTo("catalog")); // < 0 ("cat" é mais curta)
System.out.println("catalog".compareTo("cat")); // > 0

Exemplo: ordenação de um array de strings

String[] fruits = {"banana", "apple", "pear"};
Arrays.sort(fruits); // internamente usa compareTo()
System.out.println(Arrays.toString(fruits)); // [apple, banana, pear]

compareToIgnoreCase()

System.out.println("Java".compareToIgnoreCase("java")); // 0

5. Métodos startsWith() e endsWith()

Os métodos startsWith() e endsWith() verificam o início e o fim da string, retornando true/false.

String fileName = "document.pdf";
String url = "https://www.google.com";

System.out.println(fileName.startsWith("doc"));  // true
System.out.println(fileName.endsWith(".txt"));   // false
System.out.println(url.startsWith("https://"));  // true

Para que serve: validação de formatos (nomes de arquivo, URLs) e filtragem por prefixos/sufixos (por exemplo, todos ".jpg").

6. Método contains(): procurando uma substring

contains(CharSequence s) — uma forma simples de verificar a presença de uma substring. É sensível a maiúsculas/minúsculas.

String text = "Bem-vindo ao mundo Java!";
System.out.println(text.contains("mundo"));   // true
System.out.println(text.contains("C++"));     // false

Para ignorar o caso, converta ambas as strings para o mesmo caso: toLowerCase()/toUpperCase().

7. Métodos toLowerCase() e toUpperCase()

Retornam uma nova string convertida para minúsculas ou maiúsculas. Útil para comparação sem diferenciar maiúsculas/minúsculas e formatação.

String title = "Java Programming";
String lower = title.toLowerCase();
String upper = title.toUpperCase();

System.out.println(lower); // java programming
System.out.println(upper); // JAVA PROGRAMMING

8. Método split(): dividindo a string em partes

split(String regex) divide a string por um delimitador (expressão regular) e retorna um array String[].

Exemplo 1: por vírgulas

String names = "Alex,Maria,Ivan,Elena";
String[] nameArray = names.split(",");
for (String name : nameArray) 
{
    System.out.println(name.trim()); // trim() remove possíveis espaços
}
// Saída:
// Alex
// Maria
// Ivan
// Elena

Exemplo 2: por espaços

String sentence = "Eu estudo Java";
String[] words = sentence.split(" ");
for (String word : words) 
{
    System.out.println(word);
}
// Saída:
// Eu
// estudo
// Java

Observações:

• O separador é uma regex. Caracteres especiais precisam ser escapados (por exemplo, ponto: "\\.").
• O método sempre retorna um array, mesmo com um único elemento.

9. Prática: comparando strings em um aplicativo real

String registeredEmail = "user@example.com";
String registeredPassword = "Secret123";

Scanner console = new Scanner(System.in);

System.out.print("Digite o e-mail: ");
String email = console.nextLine();

System.out.print("Digite a senha: ");
String password = console.nextLine();

// Comparamos o e-mail sem diferenciar maiúsc./minúsc., e a senha — diferenciando
if (email.equalsIgnoreCase(registeredEmail) && password.equals(registeredPassword))
{
    System.out.println("Bem-vindo!");
}
else
{
    System.out.println("E-mail ou senha incorretos.");
}

Comentários: para o e-mail usamos equalsIgnoreCase(), e para a senha — estritamente equals(). O operador == não deve ser usado com strings — ele compara referências.

10. Erros comuns ao comparar strings

Erro nº 1: comparar strings com == em vez de equals()
O operador == compara referências, não o conteúdo, portanto o resultado pode ser inesperado.

Erro nº 2: chamar equals() em um objeto que pode ser null
Chame o método em um objeto certamente não nulo ou use Objects.equals(a, b).

Erro nº 3: ignorar maiúsculas/minúsculas quando isso é importante
Por exemplo, senhas devem ser comparadas considerando maiúsculas/minúsculas. Especifique os requisitos.

Erro nº 4: comparar strings com objetos de outros tipos
"123" e 123 não são a mesma coisa. equals() não faz conversão de tipos automaticamente.

Erro nº 5: ordenar strings com casos diferentes
Letras maiúsculas vêm antes das minúsculas. Para ordenar sem considerar o caso, use Arrays.sort(array, String.CASE_INSENSITIVE_ORDER).