В чем разница между String#equals
методом и String#contentEquals
методом?
152
В чем разница между String#equals
методом и String#contentEquals
методом?
Он String#equals()
не только сравнивает содержимое строки, но также проверяет, является ли другой объект также экземпляром String
. String#contentEquals()
Только сравнивает содержимое (последовательность символов) и не не проверить , если другой объект также является экземпляром String
. Это может быть что угодно , до тех пор , как это реализация CharSequence
которых охватывает ао String
, StringBuilder
, StringBuffer
, CharBuffer
и т.д.
==
(contentEquals) и===
(равно) в JavaScript?==
оператор разрешает сравнивать только ссылки, а не содержимое двух объектов.==
упомянутый только JavaScript; это никогда не упоминается в отношении Java.==
в JavaScript гораздо слабее, чемcontentEquals
, например, не будет касаться цифр), но вы правильноequals
проверяете точное совпадение типов сStrings
(другие классы могут быть слабее с типами в ихequals
методах) ,Проще говоря:
String.contentEquals()
это умный братString.equals()
, потому что он может быть более свободным в реализации, чемString.equals()
.Есть несколько причин, почему существует отдельный
String.contentEquals()
метод. Самая важная причина, я думаю, это:equals
Метод должен быть рефлексивными. Это означает , что:x.equals(y) == y.equals(x)
. Это подразумевает, чтоaString.equals(aStringBuffer)
должно быть так же, какaStringBuffer.equals(aString)
. Это потребует от разработчиков Java API создания специальной реализации для Strings вequals()
методах StringBuffer, StringBuilder и CharSequence. Это было бы беспорядок.Это где
String.contentEquals
приходит. Это метод автономного , который никак не должен следовать строгим требованиям и правилам дляObject.equals
. Таким образом, вы можете более свободно реализовать смысл «равного содержания» . Это позволяет вам делать интеллектуальные сравнения, например, между StringBuffer и String.И сказать, в чем именно разница:
String.contentEquals()
может сравнить содержимое aString
, aStringBuilder
, aStringBuffer
, aCharSequence
и всех производных классов из них. Если параметр имеет тип String, тоString.equals()
выполняется.String.equals()
сравнивает только строковые объекты. Все остальные типы объектов считаются не равными.String.contentEquals()
Можно сравнитьStringBuffer
иStringBuilder
по-умному. Он не вызывает тяжелыйtoString()
метод, который копирует весь контент в новый объект String. Вместо этого он сравнивается с базовымchar[]
массивом, и это здорово.источник
Этот ответ уже был опубликован dbw, но он удалил его, но у него были очень веские баллы для разницы при сравнении времени выполнения, какие исключения выбрасываются,
Если вы посмотрите на исходный код String # equals и String # contentEquals, становится ясно, что есть два переопределенных метода,
String#contentEquals
один из которых принимает,StringBuilder
а другой - нетCharSequence
.Разница между ними,
String#contentEquals
скинет NPE, если заданный аргумент есть,null
ноString#equals
вернетfalse
String#equals
сравнивает содержимое только в томinstance of String
случае, если задан аргумент, иначе он вернетсяfalse
во всех других случаях, но с другой стороныString#contentEquals
проверяет содержимое всех объектов, которые реализуют интерфейсCharSequence
.Вы также можете настроить код так, чтобы он
String#contentEquals
возвращал неправильный результат или результат, который вы хотите, переопределивequals
метод аргумента, переданного, как показано ниже, но вы не можете сделать эти изменения сString#equals
.Приведенный ниже код всегда будет отображаться
true
до тех пор, пока онs
содержитstring
3 символа.String#contentEquals
будет медленнее, чемString#Equals
в случае, если предоставленный аргумент равен,instance of String
а длина обоихString
одинакова, но содержимое не равно.Пример, если строка есть
String s = "madam"
иString argPassed = "madan"
затемs.contentEquals(argPassed)
в этом случае займет почти вдвое больше времени по сравнению сs.equals(argPassed)
Если длина содержимого не одинакова для обеих строк, тогда функция
String#contentEquals
будет иметь лучшую производительность, чемString#Equals
почти во всех возможных случаях.Еще один момент, чтобы добавить к его ответу
String#contentEquals
изString
объекта также будет сравнить сStringBuilder
содержанием и обеспечить соответствующий результат то время какString#Equals
ВЕРНЕТСЯfalse
источник
String
equals(Object o)
метод класса делает толькоString
сравнение. НоcontentEquals(CharSequence cs)
проверка на классы распространяетсяAbstractStringBuilder
ИЭStringBuffer
,StringBuilder
иString
класс также (все они имеют типCharSequence
).вывод:
Выход первого зЬтЬ это
false
потому , чтоbuilder
не относится к типуString
такequals()
возвращается ,false
но наcontentEquals()
проверку на содержание всех типов , какStringBuilder
,StringBuffer
,String
и , как содержание такой же поэтомуtrue
.contentEquals
сгенерирует,NullPointerException
если задан аргумент,null
ноequals()
вернет false, потому что equals () проверяет instanceOf (if (anObject instance of String)
), который возвращает false, если аргумент равенnull
.источник
contentEquals(CharSequence cs)
:java.lang.CharacterSequence
(например,CharBuffer
,Segment
,String
,StringBuffer
,StringBuilder
)equals(Object anObject)
:java.lang.String
толькоRTFC :)
Поскольку чтение исходного кода - лучший способ понять его, я делюсь реализацией обоих методов (по состоянию на jdk 1.7.0_45)
Есть еще один метод String # contentEquals ():
источник
equals()
иcontentEquals()
два метода вString
классе, чтобы сравнить дваstrings
иstring
сStringBuffer
.Параметры
contentEquals()
естьStringBuffer
иString(charSequence)
.equals()
используется для сравнения двухstrings
иcontentEquals()
используется для сравнения содержимогоString
иStringBuffer
.Метод
contentEquals
иequals
являютсяВот код, который описывает оба метода
Вывод:
источник
String # equals принимает Object в качестве аргумента и проверяет, является ли он экземпляром объекта String или нет. Если аргументом является объект String, он сравнивает содержимое символ за символом. Возвращает true, если содержимое обоих строковых объектов одинаково.
String # contentEquals принимает интерфейс CharSequence в качестве аргумента. CharSequence может быть реализован двумя способами: с помощью i) класса String или (ii) AbstractStringBuilder (родительский класс StringBuffer, StringBuilder)
В contentEquals () длина сравнивается перед проверкой любого экземпляра объекта. Если длина одинакова, то проверяется, является ли объект аргумента экземпляром AbstractStringBuilder или нет. Если это так (т.е. StringBuffer или StringBuilder), то содержимое проверяется посимвольно. Если аргумент является экземпляром объекта String, тогда String # equals вызывается из String # contentEquals.
Короче говоря,
String # equals сравнивает содержимое символ за символом в случае, если аргумент также является объектом String. And String # contentEquals сравнивает содержимое в случае, если объект аргумента реализует интерфейс CharSequence.
String # contentEquals работает медленнее, если мы сравниваем два строковых содержимого одинаковой длины, так как String # contentEquals внутренне вызывает String # equals для объекта String.
Если мы пытаемся сравнить объекты с разной длиной содержимого (скажем, «abc» с «abcd»), то String # contentEquals быстрее, чем String # равно. Потому что длина сравнивается перед проверкой экземпляра объекта.
источник
В
contentEquals()
проверяет метод является содержание же между аString
,StringBuffer
и т.д. , которые какое - то последовательность полукокса.источник
Кстати, историческая причина разницы в том, что String изначально не имел суперкласса, поэтому String.equals () принимает String в качестве аргумента. Когда CharSequence был представлен в качестве суперкласса String, он нуждался в собственном тесте на равенство, который работал бы во всех реализациях CharSequence и который не вступал бы в конфликт с equals (), уже используемым String ... поэтому мы получили CharSequence.contentEquals ( ), который наследуется String.
Если бы CharSequence присутствовал в Java 1.0, мы, вероятно, имели бы только CharSequence.equals (), и String просто реализовал бы это.
Ах, радости развивающихся языков ...
источник