При тестировании на равенство String
в Java я всегда использовал, equals()
потому что мне это кажется наиболее естественным методом для этого. В конце концов, его название уже говорит о том, для чего он предназначен. Однако мой коллега недавно сказал, что меня научили использовать compareTo() == 0
вместо equals()
. Это кажется мне неестественным (поскольку compareTo()
предназначено для упорядочивания, а не сравнения на равенство) и даже несколько опасным (потому compareTo() == 0
что не обязательно подразумевает равенство во всех случаях, хотя я знаю, что это так для String
) для меня.
Он не знал, почему его учили использовать compareTo()
вместо equals()
for String
, и я также не мог найти причины, почему. Это действительно вопрос личного вкуса, или есть реальная причина для любого метода?
.equalsIgnoreCase()
это самое быстрое сравнение, если оно уместно, иначе.equals()
это то, что вы хотите.compareTo() == 0
не обязательно подразумевает равенство во всех случаях». Это абсолютно правильно! Это именно то , что фраза « в соответствии с» равными средствами в спецификации API Java, например , в Сравнительной спецификации класса. Например, метод сравнения String совместим с equals, но метод сравнения BigDecimal несовместим с equals.Ответы:
Разница в том, что
"foo".equals((String)null)
возвращает false, а"foo".compareTo((String)null) == 0
выдает исключение NullPointerException. Поэтому они не всегда взаимозаменяемы даже для струнных.источник
Два основных отличия заключаются в следующем:
equals
примет любой объект в качестве параметра, ноcompareTo
будет принимать только строки.equals
только сообщает вам, равны они или нет, ноcompareTo
дает информацию о лексикографическом сравнении строк.Я взглянул на код класса String , и алгоритм в compareTo и equals выглядит в основном одинаково. Я считаю, что его мнение было всего лишь вопросом вкуса, и я согласен с вами - если все, что вам нужно знать, это равенство строк, а не то, какая из них будет первой лексикографически, то я бы использовал
equals
.источник
При сравнении на равенство вы должны использовать
equals()
, потому что это ясно выражает ваше намерение.compareTo()
имеет дополнительный недостаток: он работает только с объектами, реализующимиComparable
интерфейс.Это применимо в целом, а не только для струнных.
источник
compareTo
должен сделать больше работы, если струны имеют разную длину.equals
может просто вернуть false, ноcompareTo
всегда должен проверять достаточное количество символов, чтобы найти порядок сортировки.источник
compareTo()
применяется не только к строкам, но и к любому другому объекту, посколькуcompareTo<T>
принимает общий аргументT
. String - это один из классов, которые реализовалиcompareTo()
метод путем реализацииComparable
интерфейса. (compareTo () - это метод для сопоставимого интерфейса). Таким образом, любой класс может свободно реализовать интерфейс Comparable.Но
compareTo()
дает порядок объектов , обычно используемый при сортировке объектов в порядке возрастания или убывания, в то время какequals()
будет говорить только о равенстве и сказать, равны они или нет.источник
В контексте строки:
compareTo: лексикографически сравнивает две строки.
равно: сравнивает эту строку с указанным объектом.
compareTo сравнивает две строки по их символам (с одинаковым индексом) и возвращает целое число (положительное или отрицательное) соответственно.
источник
Очень важное различие между compareTo и equals:
equals () проверяет, совпадают ли два объекта или нет, и возвращает логическое значение.
compareTo () (из интерфейса Comparable) возвращает целое число. Он проверяет, какой из двух объектов «меньше», «равен» или «больше» другого. Не все объекты можно упорядочить логически, поэтому метод compareTo () не всегда имеет смысл.
Обратите внимание, что equals () не определяет порядок между объектами, как compareTo ().
Теперь я советую вам просмотреть исходный код обоих методов, чтобы сделать вывод, что equals предпочтительнее, чем compareTo, который включает некоторые математические вычисления.
источник
Похоже, что оба метода в значительной степени делают одно и то же, но метод compareTo () принимает String, а не Object, и добавляет некоторые дополнительные функции поверх обычного метода equals (). Если все, о чем вы заботитесь, - это равенство, тогда метод equals () - лучший выбор просто потому, что он имеет больше смысла для следующего программиста, который взглянет на ваш код. Разница во времени между двумя разными функциями не должна иметь значения, если вы не перебираете огромное количество элементов. CompareTo () действительно полезен, когда вам нужно знать порядок строк в коллекции или когда вам нужно знать разницу в длине между строками, начинающимися с одной и той же последовательности символов.
источник: http://java.sun.com/javase/6/docs/api/java/lang/String.html
источник
equals()
должен быть методом выбора в случае OP.Глядя на реализацию
equals()
иcompareTo()
в java.lang.String в grepcode , мы можем легко увидеть, что equals лучше, если мы просто озабочены равенством двух строк:equals()
:и
compareTo()
:Когда одна из строк является префиксом другой, производительность
compareTo()
ухудшается, так как ей все еще необходимо определять лексикографический порядок, при этомequals()
больше не будет беспокоиться и немедленно вернуть false.На мой взгляд, мы должны использовать эти два по назначению:
equals()
чтобы проверить равенство, иcompareTo()
найти лексический порядок.источник
equals () проверяет, равны ли две строки или нет, и выдает логическое значение. compareTo () проверяет, равен ли строковый объект другому строковому объекту, больше или меньше. Он дает результат как: 1, если строковый объект больше 0, если оба равны -1, если строка меньше другой строки
э:
источник
При переопределении compareTo в Java необходимо помнить об определенных вещах, например, Compareto должно быть согласовано с equals, а вычитание не должно использоваться для сравнения целочисленных полей, поскольку они могут переполняться. проверьте « Что нужно помнить при переопределении компаратора в Java» .
источник
Это эксперимент по некромантии :-)
В большинстве ответов сравнивается производительность и различия API. Они упускают из виду тот фундаментальный момент, что две операции просто имеют разную семантику.
Ваша интуиция верна. x.equals (y) не является взаимозаменяемым с x.compareTo (y) == 0. Первый сравнивает идентичность, а другой сравнивает понятие «размер». Это правда, что во многих случаях, особенно с примитивными типами, эти два совпадают.
Общий случай таков:
Если x и y идентичны, они имеют одинаковый «размер»: если x.equals (y) истинно => x.compareTo (y) равно 0.
Однако, если x и y имеют одинаковый размер, это не означает, что они идентичны.
Если x.compareTo (y) равен 0, это не обязательно означает, что x.equals (y) истинно.
Убедительным примером того, что идентичность отличается от размера, могут быть комплексные числа. Предположим, что сравнение производится по их абсолютному значению. Итак, учитывая два комплексных числа: Z1 = a1 + b1 * i и Z2 = a2 + b2 * i:
Z1.equals (z2) возвращает истину тогда и только тогда, когда a1 = a2 и b1 = b2.
Однако Z1.compareTo (Z2) возвращает 0 и бесконечное количество пар (a1, b1) и (a2, b2), если они удовлетворяют условию a1 ^ 2 + b1 ^ 2 == a2 ^ 2 + b2 ^ 2.
источник
Equals может быть более эффективным, чем compareTo.
Если длина последовательностей символов в String не совпадает, значит, строки не равны, поэтому отклонение может быть намного быстрее.
Более того, если это один и тот же объект (тождественное равенство, а не логическое равенство), он также будет более эффективным.
Если бы они также реализовали кеширование hashCode, было бы еще быстрее отклонять не-равные, если их hashCode не совпадает.
источник
String.equals()
требует вызоваinstanceof
оператора, аcompareTo()
не требует. Мой коллега заметил большое падение производительности, вызванное чрезмерным количествомinstanceof
вызововequals()
метода, однако мой тест оказалсяcompareTo()
лишь немного быстрее.Однако я использовал Java 1.6. В других версиях (или у других поставщиков JDK) разница может быть больше.
Тест сравнивал каждую строку в массивах из 1000 элементов, повторяемых 10 раз.
источник
compareTo()
быстрее, чемequals()
? Но для большинства наборов реальных данныхequals()
это намного быстрее, чемcompareTo() == 0
.equals()
светится, если строки имеют общий префикс, но разную длину, или если они на самом деле являются одним и тем же объектом.equals
может принимать любой объект в качестве параметра, ноcompareTo
может принимать только строку.когда cometo null,
compareTo
вызовет исключениекогда вы хотите узнать, где происходит разница, вы можете использовать
compareTo
.источник
equals
: требуется для проверки равенства и ограничения дублирования. Многие классы библиотеки Java используют это, если хотят найти дубликаты. например,HashSet.add(ob1)
будет добавляться только в том случае, если этого не существует. Поэтому, если вы расширяете такие классы, переопределитеequals()
.compareTo
: требуется для заказа элемента. Опять же, для стабильной сортировки вам требуется равенство, поэтому возвращается 0.источник
Равно -
1- Переопределите метод GetHashCode, чтобы тип мог правильно работать в хеш-таблице.
2- Не создавайте исключения при реализации метода Equals. Вместо этого верните false для нулевого аргумента.
3-
Последовательные вызовы x.Equals (y) возвращают одно и то же значение, если объект, на который ссылаются x и y, не изменяется.
4- Для некоторых типов объектов желательно иметь тест Equals на равенство значений вместо ссылочного равенства. Такие реализации Equals возвращают true, если два объекта имеют одинаковое значение, даже если они не являются одним и тем же экземпляром.
Например -
Вывод :-
в то время как compareTo -
Сравнивает текущий экземпляр с другим объектом того же типа и возвращает целое число, которое указывает, предшествует ли текущий экземпляр, следует за ним или находится в той же позиции в порядке сортировки, что и другой объект.
Он возвращается -
Меньше нуля - этот экземпляр предшествует obj в порядке сортировки. Ноль - этот экземпляр находится в той же позиции в порядке сортировки, что и объект obj. Больше нуля - этот экземпляр следует за obj в порядке сортировки.
Он может вызвать исключение ArgumentException, если объект не того же типа, что и экземпляр.
Например, вы можете посетить здесь.
Поэтому я предлагаю лучше использовать Equals вместо compareTo.
источник
GetHashCode()
метода. Вы имеете в видуhashCode()
?«равно» сравнивает объекты и возвращает истину или ложь, а «сравнивать с» возвращает 0, если истинно, или число [> 0] или [<0], если ложно. Вот пример:
Полученные результаты:
Документация Сравните с: https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html
Документация равна: https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)
источник
Здесь важна одна вещь при использовании
compareTo()
over,equals()
которыйcompareTo
работает для классов, реализующих интерфейс Comparable, иначе он вызовет файлNullPointerException
.String
class реализует интерфейс Comparable, аStringBuffer
не, следовательно, вы можете использовать его"foo".compareTo("doo")
вString
объекте, но не вStringBuffer
объекте.источник
Это печатает -2 и ложь
Это печатает 2 и ложь
Это печатает 0 и истина
equals возвращает логическое значение тогда и только тогда, когда совпадают обе строки.
compareTo предназначен не только для того, чтобы определить, совпадают ли они, но и для определения того, какая строка меньше другой, а также на сколько лексикографически. Это в основном используется при сортировке в коллекции.
источник
Я считаю
equals
иequalsIgnoreCase
методыString
возвратаtrue
иfalse
которые полезны, если вы хотите сравнить значения строкового объекта, но в случае реализацииcompareTo
иcompareToIgnoreCase
методы возвращают положительное, отрицательное и нулевое значение, которое будет полезно в случае сортировки.источник