Какие знаешь случаи, при которых допустимо использовать == сравнивая строки?

Использование == для сравнения строк в Java

Это классический вопрос, который часто задают на собеседованиях. == сравнивает ссылки на объекты, а не содержимое, поэтому использовать его неправильно для сравнения строк. Однако есть специфические случаи, когда это допустимо.

Почему == неправильно использовать для строк?

== сравнивает адреса в памяти (ссылки), а не значения:

String s1 = new String("hello");
String s2 = new String("hello");

if (s1 == s2) {  // false, разные объекты в памяти
    System.out.println("Equal");
}

if (s1.equals(s2)) {  // true, одинаковое содержимое
    System.out.println("Equal");
}

Правильный способ сравнения строк

Всегда используй .equals() для сравнения содержимого:

String s1 = "hello";
String s2 = "hello";

if (s1.equals(s2)) {  // Правильно
    System.out.println("Strings are equal");
}

// Если регистр не важен
if (s1.equalsIgnoreCase(s2)) {  // Правильно
    System.out.println("Strings are equal (ignore case)");
}

Допустимые случаи для использования ==

Хотя это и не рекомендуется, есть несколько случаев, когда == может работать:

1. Сравнение с null

String s = null;

// Правильно использовать ==
if (s == null) {  // Проверяем, null ли значение
    System.out.println("String is null");
}

// Или через Objects.isNull()
if (Objects.isNull(s)) {
    System.out.println("String is null");
}

Это единственный по-настоящему допустимый случай для ==.

2. String literals (строковые литералы)

Java компилятор использует String Pool — внутреннее хранилище строк. Строковые литералы помещаются в pool и переиспользуются:

String s1 = "hello";  // Создается в String Pool
String s2 = "hello";  // Ссылается на тот же объект в Pool

if (s1 == s2) {  // true, одна и та же ссылка
    System.out.println("Same reference");
}

ОДНАКО, это ОЧЕНЬ ненадежно! Это работает только потому что оба значения это литералы. Не полагайся на это поведение:

String s1 = "hello";
String s2 = "hel" + "lo";  // Компилятор оптимизирует в литерал "hello"

if (s1 == s2) {  // true, потому что компилятор оптимизировал
    System.out.println("Works by luck!");
}

// Но если использовать переменные:
String prefix = "hel";
String s3 = prefix + "lo";  // Runtime конкатенация

if (s1 == s3) {  // false, разные объекты!
    System.out.println("Equal");
} else {
    System.out.println("Not equal (even though content is same)");
}

3. Interned strings (явный интерн)

Можно использовать .intern() для размещения строки в pool:

String s1 = new String("hello").intern();
String s2 = new String("hello").intern();

if (s1 == s2) {  // true, обе интернированы
    System.out.println("Same reference");
}

ОДНАКО, это очень редко используется и может привести к проблемам с памятью!

4. Сравнение с известным объектом

Если ты знаешь точный объект:

String s = getConfigValue();  // Может вернуть null или определенное значение

// Иногда компилятор может оптимизировать
if (s == "DEBUG_MODE") {  // Работает только если это точно литерал
    System.out.println("Debug mode");
}

// Но это плохая практика! Используй:
if ("DEBUG_MODE".equals(s)) {  // Правильно
    System.out.println("Debug mode");
}

Проблемы с использованием == для строк

1. Непредсказуемое поведение

String a = "hello";
String b = "hello";
System.out.println(a == b);  // true (по удаче)

String c = new String("hello");
String d = new String("hello");
System.out.println(c == d);  // false (ожидаемо)

// Но что если:
String e = new String("hello").intern();
String f = "hello";
System.out.println(e == f);  // true (confusing!)

2. Зависимость от JVM

Разные JVM реализации могут по-разному работать с String Pool:

// Может работать на одной JVM и не работать на другой
String s1 = "test";
String s2 = "test";

if (s1 == s2) {  // Непредсказуемо
    System.out.println("Equal");
}

3. Нарушение контракта equals()

// Если класс переопределяет equals(), но используется ==:
String s1 = new String("test");
String s2 = new String("test");

System.out.println(s1.equals(s2));  // true
System.out.println(s1 == s2);       // false

// Это нарушает транзитивность

Лучшие практики

1. Всегда используй .equals() для сравнения содержимого

// Правильно
if (userName.equals("admin")) {
    // ...
}

2. Используй == только для null проверок

// Правильно
if (value == null) {
    // ...
}

// Или лучше
if (Objects.isNull(value)) {
    // ...
}

3. Если строка не может быть null, используй .equalsIgnoreCase()

// Для нечувствительного к регистру сравнения
if (mode.equalsIgnoreCase("DEBUG")) {
    // ...
}

4. Для null-safe сравнения

// Будет работать и если value null
if (Objects.equals(value, "expected")) {
    // ...
}

// Эквивалентно
if (value != null ? value.equals("expected") : false) {
    // ...
}

Итоговая таблица

Заключение

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