# Las mejores opciones para comparar con Java: String Compare

Hay tres opciones prácticas para comparar strings entre sí. Además de la opción de Java equals(), puedes usar el operador == y compareTo().

## ¿Cómo se comparan strings en Java?

Si bien comparar [tipos de datos primitivos en Java](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/primitivos-de-java/) es bastante sencillo con el [operador de Java](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/operadores-java/) ==, con los [strings de Java](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/java-strings/) la cosa se complica ligeramente. El operador == puede utilizarse también para eso, pero no comparará el contenido de los strings sino **solo la referencia del objeto correspondiente**. En algunos casos puede ser suficiente o incluso deseado, pero en otros se necesitará otro método para conseguir el resultado que se quiere. Por suerte, este [lenguaje de programación](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/lenguajes-de-programacion-web/) ofrece múltiples opciones. Las siguientes tres son especialmente prácticas y comunes:

- Java equals()
- Java compareTo() para strings
- Java operador ==

## El método de Java equals()

La manera más sencilla y práctica de comparar el contenido de dos strings es con el método equals() en Java. Lo que hace realmente **es comparar ambos valores**. Si coinciden exactamente, el método confirma con “true”. Si difieren en algo, devuelve un “false”. Esta es la sintaxis del método:

```java
public boolean equals(Objeto otroObjeto)
```

Con un simple ejemplo puedes entender el funcionamiento de este método. Hemos creado tres strings y comparamos el primero con los otros dos. En la práctica, se ve así:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esto es un String";
	String string2 = "Esto es un String";
	String string3 = "Esto es un String diferente";
	System.out.println(string1.equals(string2));
	System.out.println(string1.equals(string3));
	}
}
```

Si ahora se imprime este código con el [comando Java](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/comandos-java/) `System.out.println`, se recibe esto:

```java
true
false
```

`string1` y `string2` son idénticos, pero `string3` es diferente a los otros dos. Aunque en este ejemplo se reconozca a simple vista, hay strings que inicialmente pueden parecerse mucho pero acabar siendo diferentes. Java equals() es una herramienta útil para evitar este fallo.

## Java compareTo() para strings

El segundo método es algo más complicado pero también fiable. compareTo() con Java compara strings **lexicográficamente según el valor de Unicode de cada carácter** de un string. Los caracteres se comparan entre sí y emparejan. Si un string coincide con el otro, el método devuelve 0 como respuesta. Si el primer string es más corto que el segundo, obtienes un valor negativo. Si por el contrario es más largo, obtienes un valor positivo. Esta es la sintaxis del método:

```java
public int compareTo(String andererString)
```

A continuación, verás cómo funciona con un ejemplo. Creamos de nuevo tres strings y comparamos el primero con los otros dos. El código es el siguiente:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esto es un String";
	String string2 = "Esto es un String";
	String string3 = "Esto es un String diferente";
	System.out.println(string1.compareTo(string2));
	System.out.println(string1.compareTo(string3));
	}
}
```

Si se imprime el código con `System.out.println`, se obtiene el siguiente resultado:

```java
0
-20
```

Si quieres usar compareTo() en Java para comparar Strings ignorando las mayúsculas y minúsculas, usa para ello `compareToIgnoreCase()`. Funciona de esta manera:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esto es un String";
	String string2 = "Esto es un String";
	String string3 = "ESTO ES UN STRING";
	System.out.println(string1.compareToIgnoreCase(string2));
	System.out.println(string1.compareToIgnoreCase(string3));
	}
}
```

Como consecuencia, el resultado cambia:

```java
0
0
```

## El operador == de Java

Como se comenta arriba, en principio también puedes recurrir al operador == para comparar dos strings. Con ello se compararán las referencias, no los valores reales. Ilustramos el funcionamiento con otro ejemplo:

```java
public class Main {
	public static void main(String[] args) {
	String string1 = "Esto es un String";
	String string2 = "Esto es un String";
	String string3 = new String ("Esto es un String");
	System.out.println(string1==string2);
	System.out.println(string1==string3);
	}
}
```

Como `string1` y `string2` se refieren a la misma instancia, el operador devuelve “true”. El `string3`, en cambio, se refiere a **otra instancia**. Por tanto, devuelve el valor “false” aunque el valor o el texto que contienen los strings sea idéntico.

```java
true
false
```


This is a markdown version of: [https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/string-compare-en-java/](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/string-compare-en-java/) for AI/LLM consumption.