равно (...) и равно равно игнорировать (...)

Question

Почему у нас есть equals() и equalsIgnoreCase() как два разных метода, когда equals() мог быть перегружен специальным аргументом ignoreCase для обеспечения equalsIgnoreCase() функциональности?

Answer 1

Метод equals() наследуется от Object, поэтому его сигнатура не должна изменяться. equals() часто может использоваться без фактического знания конкретного класса объекта, например, при переборе коллекций объектов (особенно до обобщений Java 5). Так что тогда вы даже не увидите другой equals(), не опустив сначала ваш объект до String.

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

Более того, ИМО

if (string1.equalsIgnoreCase(string2)) ...

более читабелен, поэтому менее подвержен ошибкам, чем

if (string1.equals(string2, true)) ...

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

Answer 2

equalIgnoreCase() используется для игнорирования чувствительности к регистру нашего String. Но equals() возвращает только true, в то время как string

еи

String value="java";
if(value.equals("JAva")
{
    System.out.println("Return True");
}
else
{
    System.out.println("Return False");
}

Ответ: Возвращает False

но другой,

if(value.equalIgnoreCase("JAva")
{
    System.out.println("Return True");
}
else
{
    System.out.println("Return False");
}

Ответ: Возвращает True

Answer 3

Абсолютно возможно сделать то, что вы предлагаете, но дизайнеры языка решили пойти другим путем, и поэтому у нас есть equalsIgnoreCase(otherString) вместо equals(otherString, StringConstants.IGNORE_CASE) или equals(otherString, true).

Answer 4

    // Demonstrate equals() and equalsIgnoreCase(). 
    class equalsDemo { 
    public static void main(String args[]) { 
    String s1 = "Hello"; 
    String s2 = "Hello"; 
    String s3 = "Good-bye"; 
    String s4 = "HELLO"; 
    System.out.println(s1 + " equals " + s2 + " -> " + 
    s1.equals(s2)); 
    System.out.println(s1 + " equals " + s3 + " -> " + 
    s1.equals(s3)); 
    System.out.println(s1 + " equals " + s4 + " -> " + 
    s1.equals(s4)); 
    System.out.println(s1 + " equalsIgnoreCase " + s4 + " -> " + 
    s1.equalsIgnoreCase(s4)); 
    } 
}

Вывод программы показан здесь:

Hello equals Hello -> true 
Hello equals Good-bye -> false 
Hello equals HELLO -> false 
Hello equalsIgnoreCase HELLO -> true

Answer 5

Основным тестом при переопределении метода дополнительными параметрами является то, что я ожидаю, что любой метод переопределения будет делать то же самое, что и метод, который он переопределяет. Функция Equals (), полученная из Object, имеет контракт, которому она должна следовать. Два объекта, которые равны (), должны иметь идентичные хэш-коды. Я не думаю, что два объекта, которые равны без учета регистра, должны иметь одинаковый хеш-код, поэтому я считаю, что переопределение равенства здесь - неправильная вещь.

Answer 6

Поскольку метод equals() унаследован от Object.

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

public final class String {

    public boolean equals () { ... }

    public boolean equals (boolean ignoreCase) { ... }

} 

И без чтения документации было бы невозможно понять, что делает метод equals() (который без параметра).

Answer 7

Я думаю, что они просто выбрали одну из альтернатив. .NET выбрал другое. StringComparison.InvariantCultureIgnoreCase и т. Д.

Определенно то, что вы предлагаете, и, что еще лучше, реализованное .NET было бы более гибким для разных культур и т. Д. Фактически, я даже не знаю, какую культуру они используют в этом случае игнорирования. Я думаю, текущая культура.