Сравнение двух идентичных строк с == возвращает false

Ответ 1

TL; DR

Вы написали (это не работает):

realName == "Maaz"

Вы имели в виду это:

realname.equals("Maaz")

или это:

realname.equalsIgnoreCase("Maaz")

объяснение

В Java (и многих других объектно-ориентированных языках программирования) объект не совпадает с типом данных. Типы данных распознаются средой выполнения как тип данных.

Примеры типов данных: int, float, short.

Нет никаких методов или свойств, связанных с типом данных. Например, это вызовет ошибку, потому что типы данных не являются объектами:

int x = 5;
int y = 5;
if (x.equals(y)) {
    System.out.println("Equal");
}

Ссылка - это, по сути, кусок памяти, который явно сообщает среде выполнения, что это за блок данных. Среда выполнения не знает, как это интерпретировать; это предполагает, что программист делает.

Например, если бы мы использовали Integer вместо int в предыдущем примере, это сработало бы:

Integer x = new Integer(5);
Integer y = new Integer(5);
if (x.equals(y)) {
    System.out.println("Equal");
}

Принимая во внимание, что это не дало бы ожидаемого результата (условие if оценило бы как ложное):

Integer x = new Integer(5);
Integer y = new Integer(5);
if (x == y) {
    System.out.println("Equal");
}

Это связано с тем, что два объекта Integer имеют одинаковое значение, но не являются одним и тем же объектом. Двойное равенство в основном проверяет, являются ли два объекта одной и той же ссылкой (что имеет свои применения).

В вашем коде вы сравниваете Object с строковым литералом (также объектом), который отличается от сравнения значений обоих.

Давайте посмотрим на другой пример:

String s = "Some string";
if (s == "Some string") {
    System.out.println("Equal");
}

В этом случае блок if, вероятно, будет иметь значение true. Почему это?

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

Строковый литерал "Some string" в первой строке, вероятно, будет распознан как эквивалент "Some string" литерала во второй строке и будет использовать одно и то же место в памяти для каждого. Проще говоря, он создаст объект String и подключит его к обоим экземплярам "Some string". На это нельзя полагаться, поэтому использование String.equals всегда является лучшим методом проверки эквивалентности, если вас интересуют только значения.

Ответ 2

использовать

if(realName.equals("Maaz"))

используйте == с примитивным типом данных, например int boolean .... etc

но если вы хотите сравнить объект в java, вы должны использовать метод equals

Ответ 3

сделайте это вместо

if (realName.equals("Maaz"))

equals() должен использоваться для всех не примитивных объектов, таких как String в этом случае

'==' следует использовать только при выполнении примитивных сравнений, таких как int и long

Ответ 4

Вы должны сравнивать объекты с realName.equals ("Maaze"), а не с ==.

Ответ 5

Лучше всего сравнивать строки с помощью str.equals(str2), а не str == str2. Как вы заметили, вторая форма не работает много времени. Напротив, первая форма всегда работает.

Единственные случаи, когда подход == всегда будет работать, - это когда строки сравниваются:

• строковые литералы или ссылки на строковые литералы или
• которые были "интернированы" кодом приложения, вызывающим str = str.intern();.

(И нет, строки по умолчанию не интернированы.)

Так как обычно сложно написать программы, которые гарантируют эти предварительные условия для всех строк, лучше использовать equals, если нет необходимости в настройке, чтобы ставить ваши строки и использовать ==.

До этого вы решаете, что интернирование - хорошая идея, вам нужно сравнить преимущества интернирования с затратами. Эти затраты включают затраты на поиск строки в хэш-таблице пулов строк и накладные расходы пространства и GC для поддержания пула строк. Они нетривиальны по сравнению с типичными затратами только на использование обычной строки и сравнение с использованием equals.

Ответ 6

== проверяет неглубокое равенство. Он проверяет, ссылаются ли два объекта на одно и то же место в памяти.

Ответ 7

Вы также можете использовать

realname.equalsIgnoreCase("Maaz")

Таким образом, вы можете принять Maaz, maaz, maaZ, mAaZ и т.д.

Ответ 8

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

final String str1 = new String("Maaz");
final String str2 = new String("Maaz");
System.out.println(str1 == str2); // Prints false

final String str3 = "Laaz";
final String str4 = "Laaz";
System.out.println(str3 == str4); // Prints true

Ответ 9

Поскольку вы работаете над строками, вы должны использовать equals для equalsIngnorecase метода класса String. "==" будет только сравнивать, если оба объекта указывают на то же место в памяти, в вашем случае оба объекта различаются и не будут равны, поскольку они не указывают на одно и то же местоположение. С другой стороны, метод equals класса String выполняет сравнение на основе значения, которое содержит объект. Следовательно, если вы будете использовать метод equals, ваше условие if будет удовлетворено.

Ответ 10

== сравнивает ссылки на объекты или примитивные типы (int, char, float...)

equals(), вы можете переопределить этот метод, чтобы сравнить, как оба объекта равны.

для класса String, его метод equal() будет сравнивать содержимое внутри, если они одинаковые или нет.

Если ваши примеры, обе строки не имеют одинаковых ссылок на объекты, поэтому они возвращают false, == не сравнивают символы в обеих строках.

Ответ 11

Кажется, никто еще не указал, что наилучшей практикой сравнения объекта с константой в Java является вызов метода equals константы, а не объекта переменной:

if ("Maaz".equals (realName)) {}

Таким образом, вам не нужно дополнительно проверять, является ли переменная realName нулевой.

Ответ 12

if(realName.compareTo("Maaz") == 0) {
    // I dont think theres a better way do to do this.
}