# Java string compare: Comparar strings em Java

Existem três maneiras práticas de se comparar strings em Java. Além dos métodos Java `equals()` e Java string `compareTo()`, você também pode utilizar o operador `==` para realizar comparações.

## Como comparar strings em Java?

Embora você possa comparar [tipos de dados primitivos em Java](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-primitives/) facilmente com o [operador Java](https://www.ionos.com/digitalguide/websites/web-development/java-operators/ "Operadores em Java") `==`, fazer isso com [strings em Java](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-strings/) é um pouco mais complicado. Embora você possa usar o operador `==`, ele não comparará o conteúdo das strings, mas **apenas a referência ao objeto**. Isso pode ser suficiente ou desejável em alguns casos, mas em outros, você precisará de um método diferente para obter o resultado desejado. Felizmente, a [linguagem de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web") oferece várias opções. As três mais comuns e práticas são:

- Java `equals()`
- Java `compareTo()` para strings
- Operador Java `==`

## Método Java `equals()`

Para comparar o conteúdo de duas strings em Java de forma simples e prática, o método Java `equals()` é a melhor opção. Ele **compara os valores das strings** e retorna `true` se forem iguais ou `false` se forem diferentes. A sintaxe do método é:

```Java
public boolean equals(objeto1 objeto2)
```

O funcionamento desse método pode ser mais bem ilustrado com um exemplo simples. Para isso, criamos três strings e comparamos a primeira string com as outras duas. Na prática, o código ficaria assim:

```Java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esta é uma string";
	String string2 = "Esta é uma string";
	String string3 = "Esta é uma string completamente diferente";
	System.out.println(string1.equals(string2));
	System.out.println(string1.equals(string3));
	}
}
```

Se executarmos esse código com o [comando Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos em Java") `System.out.println`, obteremos o seguinte resultado:

```Java
true
false
```

A `string1` e `string2` são idênticas, mas `string3` difere das outras duas. Enquanto neste exemplo é fácil perceber isso a olho nu, há outros casos em que strings podem parecer semelhantes à primeira vista, mas diferem em algum detalhe. O método Java `equals()` é muito eficaz para evitar erros nessas situações.

## Java string `compareTo()`

O segundo método é um pouco mais complexo, mas também é confiável. O método Java string `compareTo()` compara strings **lexicograficamente com base no valor Unicode dos caracteres individuais** em uma string. Os caracteres são comparados e alinhados. Se uma string for igual à outra, o método retorna 0. Se a primeira string for menor que a segunda, será retornado um valor negativo. Se for maior, será retornado um valor positivo. Esta é a sintaxe do método:

```Java
public int compareTo(String outraString)
```

A funcionalidade é explicada através de um exemplo simples. Criamos novamente três strings e comparamos a primeira com as outras duas. Aqui está o código de exemplo:

```Java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esta é uma string";
	String string2 = "Esta é uma string";
	String string3 = "Esta é uma string completamente diferente";
	System.out.println(string1.compareTo(string2));
	System.out.println(string1.compareTo(string3));
	}
}
```

Ao executarmos este código com `System.out.println`, obtemos o seguinte:

```Java
0
-20
```

Se você deseja que o método Java string `compareTo()` não faça diferenciações entre maiúsculas e minúsculas, deverá combiná-lo ao `compareToIgnoreCase()`. Ele funciona da seguinte maneira:

```Java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esta é uma string";
	String string2 = "Esta é uma string";
	String string3 = "ESTA É UMA STRING";
	System.out.println(string1.compareToIgnoreCase(string2));
	System.out.println(string1.compareToIgnoreCase(string3));
	}
}
```

Observe a diferença no resultado:

```Java
0
0
```

## Operador Java `==`

Como mencionado, você também pode usar o operador `==` para comparar duas strings em Java. Ele compara as referências e não os valores reais. Também vamos ilustrar a situação com um exemplo:

```Java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esta é uma string";
	String string2 = "Esta é uma string";
	String string3 = new String ("Esta é uma string");
	System.out.println(string1==string2);
	System.out.println(string1==string3);
	}
}
```

Como `string1` e `string2` referenciam a mesma instância, a saída é “true”. A `string3`, por outro lado, é criada por `new String()`, o que força a criação de uma **nova instância**, enquanto `string1` e `string2` são literais de string, referenciando a mesma instância no pool. Assim, a saída de `string3` é “false”, embora o valor dentro das strings seja idêntico.

```Java
true
false
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-string-compare/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-string-compare/) for AI/LLM consumption.