String é uma sequência de caracteres. Em Java, os objetos de String são imutáveis, o que significa que são constantes e não podem ser alterados depois de criados.

Abaixo estão 5 maneiras de comparar duas Strings em Java:

  1. Usando a função definida pelo usuário: defina uma função para comparar os valores com as seguintes condições:
    1. se (string1> string2) retorna um valor positivo .
    2. se ambas as strings forem iguais lexicograficamente,
      ou seja, (string1 == string2) ele retorna 0 .
    3. se (string1 <string2) retorna um valor negativo .

    O valor é calculado como (int) str1.charAt (i) - (int) str2.charAt (i)

    Exemplos:

    Entrada 1: GeeksforGeeks
 Entrada 2: Resultado da prática
 : -9

Entrada 1: Geeks
 Input 2: Geeks
 Output: 0

Entrada 1: GeeksforGeeks
 Entrada 2: Geeks
 Saída : 8

    Programa:






    // Java program to Compare two strings
    // lexicographically
    public class GFG {
      
        // This method compares two strings
        // lexicographically without using
        // library functions
        public static int stringCompare(String str1, String str2)
        {
      
            int l1 = str1.length();
            int l2 = str2.length();
            int lmin = Math.min(l1, l2);
      
            for (int i = 0; i < lmin; i++) {
                int str1_ch = (int)str1.charAt(i);
                int str2_ch = (int)str2.charAt(i);
      
                if (str1_ch != str2_ch) {
                    return str1_ch - str2_ch;
                }
            }
      
            // Edge case for strings like
            // String 1="Geeks" and String 2="Geeksforgeeks"
            if (l1 != l2) {
                return l1 - l2;
            }
      
            // If none of the above conditions is true,
            // it implies both the strings are equal
            else {
                return 0;
            }
        }
      
        // Driver function to test the above program
        public static void main(String args[])
        {
            String string1 = new String("Geeksforgeeks");
            String string2 = new String("Practice");
            String string3 = new String("Geeks");
            String string4 = new String("Geeks");
      
            // Comparing for String 1 < String 2
            System.out.println("Comparing " + string1 + " and " + string2
                               + " : " + stringCompare(string1, string2));
      
            // Comparing for String 3 = String 4
            System.out.println("Comparing " + string3 + " and " + string4
                               + " : " + stringCompare(string3, string4));
      
            // Comparing for String 1 > String 4
            System.out.println("Comparing " + string1 + " and " + string4
                               + " : " + stringCompare(string1, string4));
        }
    }
    Saída:
    Comparando Geeksforgeeks e a prática: -9
Comparando Geeks e Geeks: 0
Comparando Geeksforgeeks e Geeks: 8

  2. Usando String.equals(): Em Java, o método string equals() compara as duas strings fornecidas com base nos dados / conteúdo da string. Se todo o conteúdo de ambas as strings for o mesmo, ele retornará verdadeiro. Se algum caractere não corresponder, ele retornará falso.
    Sintaxe:
    str1.equals (str2);
    Aqui str1 e str2 são as strings que devem ser comparadas.
    Exemplos:
    Entrada 1: GeeksforGeeks
 Entrada 2: Resultado da prática
 : falso

Entrada 1: Geeks
 Entrada 2: Geeks
 Saída: verdadeiro

Entrada 1: geeks
 Entrada 2: Geeks
 Saída: falso

    Programa:



    // Java program to Compare two strings
    // lexicographically
    public class GFG {
        public static void main(String args[])
        {
            String string1 = new String("Geeksforgeeks");
            String string2 = new String("Practice");
            String string3 = new String("Geeks");
            String string4 = new String("Geeks");
            String string5 = new String("geeks");
      
            // Comparing for String 1 != String 2
            System.out.println("Comparing " + string1 + " and " + string2
                               + " : " + string1.equals(string2));
      
            // Comparing for String 3 = String 4
            System.out.println("Comparing " + string3 + " and " + string4
                               + " : " + string3.equals(string4));
      
            // Comparing for String 4 != String 5
            System.out.println("Comparing " + string4 + " and " + string5
                               + " : " + string4.equals(string5));
      
            // Comparing for String 1 != String 4
            System.out.println("Comparing " + string1 + " and " + string4
                               + " : " + string1.equals(string4));
        }
    }
    Saída:
    Comparando Geeksforgeeks e Practice: false
Comparando Geeks e Geeks: verdadeiro
Comparando geeks e geeks: falso
Comparando Geeksforgeeks e Geeks: falso

  3. Usando String.equalsIgnoreCase(): O método String.equalsIgnoreCase() compara duas strings, independentemente do caso (inferior ou superior) da string. Este método retorna verdadeiro se o argumento não for nulo e o conteúdo de ambas as Strings for o mesmo, ignorando maiúsculas e minúsculas, caso contrário, será falso.
    Sintaxe:
    str2.equalsIgnoreCase (str1);
    Aqui str1 e str2 são as strings que devem ser comparadas.


    Exemplos:
    Entrada 1: GeeksforGeeks
 Entrada 2: Resultado da prática
 : falso

Entrada 1: Geeks
 Entrada 2: Geeks
 Saída: verdadeiro

Entrada 1: geeks
 Entrada 2: Geeks
 Saída: verdadeiro

    Programa:



    // Java program to Compare two strings
    // lexicographically
    public class GFG {
        public static void main(String args[])
        {
            String string1 = new String("Geeksforgeeks");
            String string2 = new String("Practice");
            String string3 = new String("Geeks");
            String string4 = new String("Geeks");
            String string5 = new String("geeks");
      
            // Comparing for String 1 != String 2
            System.out.println("Comparing " + string1 + " and " + string2
                               + " : " + string1.equalsIgnoreCase(string2));
      
            // Comparing for String 3 = String 4
            System.out.println("Comparing " + string3 + " and " + string4
                               + " : " + string3.equalsIgnoreCase(string4));
      
            // Comparing for String 4 = String 5
            System.out.println("Comparing " + string4 + " and " + string5
                               + " : " + string4.equalsIgnoreCase(string5));
      
            // Comparing for String 1 != String 4
            System.out.println("Comparing " + string1 + " and " + string4
                               + " : " + string1.equalsIgnoreCase(string4));
        }
    }
    Saída:
    Comparando Geeksforgeeks e Practice: false
Comparando Geeks e Geeks: verdadeiro
Comparando geeks e geeks: verdadeiro
Comparando Geeksforgeeks e Geeks: falso

  4. Usando Objects.equals(): o  método Object.equals (Object a, Object b) retorna verdadeiro se os argumentos são iguais entre si e falso caso contrário. Conseqüentemente, se ambos os argumentos forem nulos, true será retornado e se exatamente um argumento for nulo, false será retornado. Caso contrário, a igualdade é determinada usando o método equals() do primeiro argumento.
    Sintaxe:
    public static boolean equals (objeto a, objeto b)
    Aqui, aeb são os objetos string que devem ser comparados.
    Exemplos:
    Entrada 1: GeeksforGeeks
 Entrada 2: Resultado da prática
 : falso

Entrada 1: Geeks
 Entrada 2: Geeks
 Saída: verdadeiro

Entrada 1: nula
 Entrada 2: nula
 Saída: verdadeiro

    Programa:



    // Java program to Compare two strings
    // lexicographically
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            String string1 = new String("Geeksforgeeks");
            String string2 = new String("Geeks");
            String string3 = new String("Geeks");
            String string4 = null;
            String string5 = null;
      
            // Comparing for String 1 != String 2
            System.out.println("Comparing " + string1 + " and " + string2
                               + " : " + Objects.equals(string1, string2));
      
            // Comparing for String 2 = String 3
            System.out.println("Comparing " + string2 + " and " + string3
                               + " : " + Objects.equals(string2, string3));
      
            // Comparing for String 1 != String 4
            System.out.println("Comparing " + string1 + " and " + string4
                               + " : " + Objects.equals(string1, string4));
      
            // Comparing for String 4 = String 5
            System.out.println("Comparing " + string4 + " and " + string5
                               + " : " + Objects.equals(string4, string5));
        }
    }
    Saída:
    Comparando Geeksforgeeks e Geeks: falso
Comparando Geeks e Geeks: verdadeiro
Comparando Geeksforgeeks e null: false
Comparando nulo e nulo: verdadeiro

  5. Usando String.compareTo() :
    Sintaxe:
    int str1.compareTo (String str2)
    Funcionando:
     compara e retorna os seguintes valores da seguinte maneira:


    1. if (string1> string2) retorna um valor positivo .
    2. se ambas as strings forem iguais lexicograficamente, 
      ou seja, (string1 == string2) ele retorna 0 .
    3. if (string1 <string2) retorna um valor negativo .
    Exemplos:
    Entrada 1: GeeksforGeeks
 Entrada 2: Resultado da prática
 : -9

Entrada 1: Geeks
 Entrada 2: Geeks
 Saída: 0

Entrada 1: GeeksforGeeks
 Entrada 2: Saída Geeks
 : 8

    Programa:



    // Java program to Compare two strings
    // lexicographically
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            String string1 = new String("Geeksforgeeks");
            String string2 = new String("Practice");
            String string3 = new String("Geeks");
            String string4 = new String("Geeks");
      
            // Comparing for String 1 < String 2
            System.out.println("Comparing " + string1 + " and " + string2
                               + " : " + string1.compareTo(string2));
      
            // Comparing for String 3 = String 4
            System.out.println("Comparing " + string3 + " and " + string4
                               + " : " + string3.compareTo(string4));
      
            // Comparing for String 1 > String 4
            System.out.println("Comparing " + string1 + " and " + string4
                               + " : " + string1.compareTo(string4));
        }
    }
    Saída:
    Comparando Geeksforgeeks e a prática: -9
Comparando Geeks e Geeks: 0
Comparando Geeksforgeeks e Geeks: 8



Por que não usar == para comparação de Strings?


Em geral, os operadores equals() e “ == ” em Java são usados ​​para comparar objetos para verificar a igualdade, mas aqui estão algumas das diferenças entre os dois:


  • A principal diferença entre o método .equals() e o operador == é que um é o método e o outro é o operador.
  • Pode-se usar operadores == para comparação de referência (comparação de endereço) e método .equals() para comparação de conteúdo .
    Em palavras simples, == verifica se ambos os objetos apontam para a mesma localização da memória enquanto .equals() avalia a comparação de valores nos objetos.
    Exemplo:



    // Java program to understand
    // why to avoid == operator
      
    public class Test {
        public static void main(String[] args)
        {
            String s1 = new String("HELLO");
            String s2 = new String("HELLO");
      
            System.out.println(s1 == s2);
      
            System.out.println(s1.equals(s2));
        }
    }
    Saída:
    falso
verdade

    Explicação: Aqui, dois objetos String estão sendo criados, a saber, s1 e s2.
    • Tanto s1 quanto s2 se referem a objetos diferentes.
    • Quando se usa o operador == para a comparação s1 e s2, o resultado é falso, pois ambos têm endereços diferentes na memória.
    • Usando igual, o resultado é verdadeiro porque é apenas comparando os valores dados em s1 e s2.
    Atenção leitor! Não pare de aprender agora. Obtenha todos os conceitos importantes de Java Foundation e Coleções com o curso Fundamentals of Java e Java Collections a um preço acessível ao aluno e torne-se pronto para a indústria. Para completar sua preparação desde o aprendizado de um idioma até o DS Algo e muitos mais, consulte o Curso Completo de Preparação para Entrevistas .