LabEx
ВходРегистрация

Как проверить, равна ли одна строка другой в Java

JavaBeginner
Практиковаться сейчас

Введение

В этом практическом занятии (лабораторной работе) вы научитесь эффективно сравнивать строки на Java. Понимание сравнения строк является фундаментальным для различных программистских задач. Мы рассмотрим стандартный метод equals(), который используется для проверки того, имеют ли две строки одинаковую последовательность символов, даже если они представляют собой разные объекты в памяти.

Кроме того, вы узнаете, как обрабатывать потенциальные проблемы с NullPointerException при сравнении строк, которые могут быть равны null. Наконец, мы рассмотрим метод equalsIgnoreCase(), который позволяет выполнять сравнение строк без учета регистра символов, обеспечивая гибкость в тех случаях, когда регистр символов не имеет значения для вашей логики сравнения.

Сравнение строк с использованием метода equals()

На этом этапе мы научимся сравнивать строки на Java с помощью метода equals(). Сравнение строк является фундаментальной операцией в программировании, и понимание того, как делать это правильно, имеет решающее значение.

В Java строки являются объектами, а не примитивными типами данных, такими как целые числа или булевы значения. Это означает, что при сравнении строк вы сравниваете сами объекты, а не только их значения. Использование оператора == для сравнения строк проверяет, ссылаются ли две переменные строк на один и тот же объект в памяти. Однако часто вам нужно проверить, имеют ли две строки одинаковую последовательность символов, даже если они являются разными объектами. Для этого вы должны использовать метод equals().

Создадим простую программу на Java, чтобы продемонстрировать это.

  1. Откройте файл HelloJava.java в редакторе WebIDE, если он еще не открыт.

  2. Замените весь текст файла следующим кодом:

    public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));
    }
}

    В этом коде:

    • Мы объявляем три переменные строк: str1, str2 и str3.
    • str1 и str2 создаются с использованием строковых литералов. Java часто оптимизирует строковые литералы таким образом, чтобы одинаковые литералы ссылались на один и тот же объект.
    • str3 создается с использованием конструктора new String(), который явно создает новый объект строки в памяти, даже если его содержимое совпадает с существующими литералами.
    • Мы используем equals() для сравнения содержимого строк.
    • Мы используем == для проверки, ссылаются ли переменные строк на один и тот же объект.

  3. Сохраните файл (Ctrl+S или Cmd+S).

  4. Теперь скомпилируем нашу программу. Откройте терминал внизу WebIDE и убедитесь, что вы находитесь в директории ~/project. Выполните следующую команду:

    javac StringComparison.java

    Если компиляция прошла успешно, вы не увидите никакого вывода. В директории ~/project будет создан файл StringComparison.class.

  5. Наконец, запустите скомпилированную программу с помощью команды java:

    java StringComparison

    Вы должны увидеть вывод, похожий на следующий:

    Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false

    Обратите внимание, что str1.equals(str2) и str1.equals(str3) возвращают true, потому что содержимое строк совпадает. Однако str1 == str3 возвращает false, потому что str1 и str3 ссылаются на разные объекты строк в памяти, даже если они содержат одинаковые символы. str1 == str2 возвращает true в этом конкретном случае из-за оптимизации строковых литералов, но использование == для сравнения строк в целом не рекомендуется, так как это может привести к неожиданным результатам.

Это демонстрирует, почему использование метода equals() является правильным способом сравнения содержимого строк на Java.

Обработка null-строк при проверке равенства

На этом этапе мы рассмотрим, как обрабатывать null-строки при выполнении проверок на равенство в Java. null-строка означает, что переменная строки не ссылается на какой-либо объект. Попытка вызвать метод для переменной, равной null, приведет к NullPointerException, что является распространенной ошибкой в Java.

При сравнении строк важно учитывать возможность того, что одна или обе строки могут быть равны null. Если вы вызовете метод equals() для null-строки, ваша программа аварийно завершится.

Давайте модифицируем нашу предыдущую программу, чтобы увидеть, как это работает и как безопасно обрабатывать такие ситуации.

  1. Откройте файл StringComparison.java в редакторе WebIDE.

  2. Измените метод main, чтобы включить null-строку:

    public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null; // This string is null

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Let's try comparing with the null string
        // System.out.println("Comparing str1 and str4 using equals(): " + str1.equals(str4)); // This line would cause a NullPointerException
        // System.out.println("Comparing str4 and str1 using equals(): " + str4.equals(str1)); // This line would also cause a NullPointerException

        // Correct way to compare when one string might be null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));
    }
}

    В модифицированном коде:

    • Мы добавили null-строку str4.
    • Мы закомментировали строки, которые при выполнении вызовут NullPointerException.
    • Мы добавили примеры того, как безопасно сравнивать строки, когда одна из них может быть равна null. Самый безопасный способ - проверить, что строка, для которой вы вызываете метод equals(), не равна null перед вызовом этого метода. Общим шаблоном является (stringVariable != null && stringVariable.equals(anotherString)). В качестве альтернативы, если это возможно, вы можете вызвать equals() для известной не-null строки, например "hello".equals(str4).

  3. Сохраните файл (Ctrl+S или Cmd+S).

  4. Скомпилируйте модифицированную программу в терминале:

    javac StringComparison.java

  5. Запустите скомпилированную программу:

    java StringComparison

    Вы должны увидеть вывод, похожий на следующий:

    Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

    Вывод показывает, что безопасные сравнения корректно обрабатывают null-строку без возникновения ошибки. Сравнение между str1 и str4 (которая равна null) правильно оценивается как false.

На этом этапе подчеркивается важность обработки значений null при работе с объектами в Java, особенно с строками, чтобы избежать ошибок NullPointerException.

Использование метода equalsIgnoreCase() для регистронезависимого сравнения

На этом последнем этапе мы узнаем о методе equalsIgnoreCase(), который используется для сравнения строк без учета регистра символов. Это очень полезно, когда вам нужно проверить, совпадают ли две строки, независимо от того, являются ли буквы заглавными или строчными.

Метод equals(), который мы использовали на предыдущих этапах, выполняет регистрозависимое сравнение. Это означает, что "hello" не равно "Hello" при использовании equals(). Метод equalsIgnoreCase() игнорирует регистр, поэтому "hello" и "Hello" будут считаться равными.

Давайте модифицируем нашу программу в последний раз, чтобы продемонстрировать использование equalsIgnoreCase().

  1. Откройте файл StringComparison.java в редакторе WebIDE.

  2. Добавьте несколько новых переменных строк с разным регистром и используйте equalsIgnoreCase() для их сравнения:

    public class StringComparison {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = null;
        String str5 = "Hello"; // Different casing
        String str6 = "HELLO"; // All uppercase

        System.out.println("Comparing str1 and str2 using equals(): " + str1.equals(str2));
        System.out.println("Comparing str1 and str3 using equals(): " + str1.equals(str3));
        System.out.println("Comparing str1 and str2 using ==: " + (str1 == str2));
        System.out.println("Comparing str1 and str3 using ==: " + (str1 == str3));

        // Safe comparison with null
        System.out.println("Comparing str1 and str4 safely: " + (str1 != null && str1.equals(str4)));
        System.out.println("Comparing str4 and str1 safely: " + (str4 != null && str4.equals(str1)));
        System.out.println("Comparing str4 and null safely: " + (str4 == null));

        System.out.println("\n--- Case-Insensitive Comparisons ---");
        System.out.println("Comparing str1 and str5 using equals(): " + str1.equals(str5));
        System.out.println("Comparing str1 and str5 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str5));
        System.out.println("Comparing str1 and str6 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str6));
        System.out.println("Comparing str5 and str6 using equalsIgnoreCase(): " + str5.equalsIgnoreCase(str6));

        // equalsIgnoreCase() also handles null safely if called on a non-null string
        System.out.println("Comparing str1 and str4 using equalsIgnoreCase(): " + str1.equalsIgnoreCase(str4));
        // System.out.println("Comparing str4 and str1 using equalsIgnoreCase(): " + str4.equalsIgnoreCase(str1)); // This would still cause a NullPointerException
    }
}

    В обновленном коде:

    • Мы добавили str5 и str6 с разным регистром.
    • Мы добавили новые инструкции вывода, чтобы продемонстрировать разницу между equals() и equalsIgnoreCase().
    • Мы также показываем, что вызов equalsIgnoreCase() для не-null строки с аргументом null не вызывает ошибки, как и в случае с equals(). Однако вызов equalsIgnoreCase() для null переменной строки по-прежнему приведет к NullPointerException.

  3. Сохраните файл (Ctrl+S или Cmd+S).

  4. Скомпилируйте программу в терминале:

    javac StringComparison.java

  5. Запустите скомпилированную программу:

    java StringComparison

    Вы должны увидеть вывод, похожий на следующий:

    Comparing str1 and str2 using equals(): true
Comparing str1 and str3 using equals(): true
Comparing str1 and str2 using ==: true
Comparing str1 and str3 using ==: false
Comparing str1 and str4 safely: false
Comparing str4 and str1 safely: false
Comparing str4 and null safely: true

--- Case-Insensitive Comparisons ---
Comparing str1 and str5 using equals(): false
Comparing str1 and str5 using equalsIgnoreCase(): true
Comparing str1 and str6 using equalsIgnoreCase(): true
Comparing str5 and str6 using equalsIgnoreCase(): true
Comparing str1 and str4 using equalsIgnoreCase(): false

    Вывод четко показывает, что equalsIgnoreCase() возвращает true при сравнении строк с одинаковыми символами, но разным регистром, в то время как equals() возвращает false.

Теперь вы узнали, как сравнивать строки на Java с использованием equals() для регистрозависимого сравнения, как безопасно обрабатывать null-строки и как использовать equalsIgnoreCase() для регистронезависимого сравнения. Это важные навыки для работы со строками на Java.

Резюме

В этом практическом занятии (лабораторной работе) мы научились сравнивать строки на Java. Мы начали с понимания различия между сравнением объектов строк с использованием оператора == и сравнением их содержимого с помощью метода equals(). Мы увидели, что оператор == проверяет идентичность объектов, в то время как метод equals() проверяет равенство последовательностей символов.

Затем мы рассмотрели, как обрабатывать потенциальную ошибку NullPointerException при сравнении строк, убеждаясь, что строка, для которой вызывается метод equals(), не равна null. Наконец, мы научились выполнять регистронезависимые сравнения строк с использованием метода equalsIgnoreCase().

Связанные Java Курсы
Java для начинающих

Java для начинающих

java
Упражнения по программированию на Java

Упражнения по программированию на Java

java
Массовая вставка данных в расписание курсов

Массовая вставка данных в расписание курсов

java