Java | ==, es igual a(), compareTo(), es igual a IgnorarCase() y compare()

Hay muchas formas de comparar dos strings en Java: 
 

• Usando el operador ==
• Usando el método equals()
• Usando el método compareTo()
• Usando el método compareToIgnoreCase()
• Usando el método comparar()
  • Método 1: usar el operador == El operador
    doble igual se usa para comparar dos o más de dos objetos. Si se refieren al mismo objeto, devuelve verdadero, de lo contrario, devuelve falso. La string es inmutable en java. Cuando se crean dos o más objetos sin una nueva palabra clave, ambos objetos hacen referencia al mismo valor. El operador de doble igual en realidad compara referencias de objetos. 
     

• El siguiente ejemplo ilustra el uso de == para la comparación de strings en Java:
   

// Java program to demonstrate
// use of == operator in Java
 
class GFG {
    public static void main(String[] args)
    {
 
        // Get some Strings to compare
        String s1 = "A";
        String s2 = "A";
        String s3 = "A";
        String s4 = new String("A");
 
        // Compare s1 and s2
        // It should return true as they both
        // refer to same object in memory
        System.out.println(s1 + " == " + s2
                         + ": " + (s1 == s2));
 
        // Compare s1 and s3
        // It should return true as they both
        // refer to same object in memory
        System.out.println(s1 + " == " + s3
                         + ": " + (s1 == s3));
 
        // Compare s2 and s3
        // It should return true as they both
        // refer to same object in memory
        System.out.println(s2 + " == " + s3
                         + ": " + (s2 == s3));
 
        // Compare s1 and s4
        // It should return false as they both
        // refer to different object in memory
        System.out.println(s1 + " == " + s4
                         + ": " + (s1 == s4));
    }
}

A == A: true
A == A: true
A == A: true
A == A: false

•  
• Método 2: Usar el método equals()
  En Java, el método string equals() compara las dos strings dadas en función de los datos/contenido de la string. Si todos los contenidos de ambas strings son iguales, devuelve verdadero. Si todos los caracteres no coinciden, devuelve falso. 
   

• El siguiente ejemplo ilustra el uso de .equals para la comparación de strings en Java:
   

// Java program to demonstrate
// use of .equals operator in Java
 
class GFG {
    public static void main(String[] args)
    {
 
        // Get some Strings to compare
        String s1 = "A";
        String s2 = "A";
        String s3 = "a";
        String s4 = new String("A");
 
        // Compare s1 and s2
        // It should return true as they both
        // have the same content
        System.out.println(s1 + " .equals " + s2
                         + ": " + s1.equals(s2));
 
        // Compare s1 and s3
        // It should return false as they both
        // have the different content
        System.out.println(s1 + " .equals " + s3
                         + ": " + s1.equals(s3));
 
        // Compare s2 and s3
        // It should return false as they both
        // have the different content
        System.out.println(s2 + " .equals " + s3
                         + ": " + s2.equals(s3));
 
        // Compare s1 and s4
        // It should return true as they both
        // have the same content
        System.out.println(s1 + " .equals " + s4
                         + ": " + s1.equals(s4));
    }
}

A .equals A: true
A .equals a: false
A .equals a: false
A .equals A: true

•  
• Método 3: Usar el método compareTo()
  En la interfaz Comparable de Java compara valores y devuelve un int, estos valores int pueden ser menores, iguales o mayores que. La string java compare two se basa en el valor Unicode de cada carácter en las strings. Si dos strings son diferentes, entonces tienen caracteres diferentes en algún índice que es un índice válido para ambas strings, o sus longitudes son diferentes, o ambas cosas. 
  Suponiendo que el índice ‘i’ es donde los caracteres son diferentes, compareTo() devolverá firstString.charAt(i)-secondString.charAt(i) .
   

• El siguiente ejemplo ilustra el uso de .compareTo para la comparación de strings en Java:
   

// Java program to demonstrate
// use of .compareTo operator in Java
 
class GFG {
    public static void main(String[] args)
    {
 
        // Get some Strings to compare
        String s1 = "A";
        String s2 = "A";
        String s3 = "a";
        String s4 = new String("A");
 
        // Compare s1 and s2
        // It should return 0 as they both
        // have the same ASCII value
        System.out.println(s1 + " .compareTo " + s2
                         + ": " + s1.compareTo(s2));
 
        // Compare s1 and s3
        // It should return -32 as they both
        // have the different ASCII value
        System.out.println(s1 + " .compareTo " + s3
                         + ": " + s1.compareTo(s3));
 
        // Compare s3 and s2
        // It should return 32 as they both
        // have the different ASCII value
        System.out.println(s3 + " .compareTo " + s2
                         + ": " + s3.compareTo(s2));
 
        // Compare s1 and s4
        // It should return 0 as they both
        // have the same ASCII value
        System.out.println(s1 + " .compareTo " + s4
                         + ": " + s1.compareTo(s4));
    }
}

A .compareTo A: 0
A .compareTo a: -32
a .compareTo A: 32
A .compareTo A: 0

•  
• Método 4: Usar el método equalsIgnoreCase() El método
  Java String equalsIgnoreCase() es muy similar al método equals(), excepto que el caso se ignora como en el ejemplo anterior El objeto String s4 se compara con s3 y luego el método equals() devuelve falso, pero aquí por si acaso de equalsIgnoreCase() devolverá verdadero. Por lo tanto, el método equalsIgnoreCase() no distingue entre mayúsculas y minúsculas. 
   

• El siguiente ejemplo ilustra el uso de .equalsIgnoreCase para la comparación de strings en Java:
   

// Java program to demonstrate
// use of .equalsIgnoreCase operator in Java
 
class GFG {
    public static void main(String[] args)
    {
 
        // Get some Strings to compare
        String s1 = "A";
        String s2 = "A";
        String s3 = "a";
        String s4 = new String("A");
 
        // Compare s1 and s2
        // It should return true as they both
        // have the same content
        System.out.println(s1 + " .equalsIgnoreCase " + s2
                         + ": " + s1.equalsIgnoreCase(s2));
 
        // Compare s1 and s3
        // It should return true as they both
        // have the same content being case insensitive
        System.out.println(s1 + " .equalsIgnoreCase " + s3
                         + ": " + s1.equalsIgnoreCase(s3));
 
        // Compare s2 and s3
        // It should return true as they both
        // have the same content being case insensitive
        System.out.println(s2 + " .equalsIgnoreCase " + s3
                         + ": " + s2.equalsIgnoreCase(s3));
 
        // Compare s1 and s4
        // It should return true as they both
        // have the same content
        System.out.println(s1 + " .equalsIgnoreCase " + s4
                         + ": " + s1.equalsIgnoreCase(s4));
    }
}

A .equalsIgnoreCase A: true
A .equalsIgnoreCase a: true
A .equalsIgnoreCase a: true
A .equalsIgnoreCase A: true

•  
• Método 5: Uso del método compare()
  En Java para una comparación específica de la configuración regional, se debe usar la clase Collator que se encuentra en el paquete java.text . La característica más importante de la clase Collator es la capacidad de definir nuestras propias reglas de comparación personalizadas.
   

• El siguiente ejemplo ilustra el uso del método compare() en Java para comparar strings:
   

// Java program to demonstrate
// use of collator.compare operator in Java
 
import java.text.Collator;
 
class GFG {
    public static void main(String[] args)
    {
 
        // Get Collator instance
        Collator collator = Collator.getInstance();
 
        // Get some Strings to compare
        String s1 = "A";
        String s2 = "A";
        String s3 = "a";
        String s4 = new String("A");
 
        // Compare s1 and s2
        // It should return 0 as they both
        // have the same ASCII value
        System.out.println(s1 + " collator.compare " + s2
                         + ": " + collator.compare(s1, s2));
 
        // Compare s1 and s3
        // It should return 1
        System.out.println(s1 + " collator.compare " + s3
                         + ": " + collator.compare(s1, s3));
 
        // Compare s3 and s2
        // It should return -1
        System.out.println(s3 + " collator.compare " + s2
                         + ": " + collator.compare(s3, s2));
 
        // Compare s1 and s4
        // It should return 0 as they both
        // have the same ASCII value
        System.out.println(s1 + " collator.compare " + s4
                         + ": " + collator.compare(s1, s4));
    }
}

A collator.compare A: 0
A collator.compare a: 1
a collator.compare A: -1
A collator.compare A: 0