Java equals не равно: Как сравнивать строки в Java?

Строковый оператор без учета регистра !~ (не равно)

• Статья
• 05/23/2023

Фильтрует набор записей по данным, которые не соответствуют строке без учета регистра.

В следующей таблице приведено == сравнение операторов (equals):

Дополнительные сведения о других операторах и определении того, какой оператор лучше всего подходит для запроса, см. в разделе Строковые операторы типа данных.

Советы по улучшению производительности

Примечание

Производительность зависит от типа поиска и структуры данных. Рекомендации см. в статье Рекомендации по запросам.

По возможности используйте с учетом регистра !=.

Синтаксис

T|whereСтолбца!~(Выражение)

Параметры

Возвращаемое значение

Строки в T, для которых предикат имеет значение true.

Пример

Выполнить запрос

StormEvents
| summarize event_count=count() by State
| where (State !~ "texas") and (event_count > 3000)
| project State, event_count

Выходные данные

equals Указывает, является ли какой-либо другой объект «равным» этому.

В Kotlin существует два типа равенства: Структурное равенство — проверяется с помощью метода equals или оператора == (и его инвертированного аналога != ). a == b переводится в a.

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

Для объектов этот оператор сравнивает, являются ли они одним и тем же объектом, а не содержат ли они одно и то же значение. Вместо этого Kotlin использует оператор ‘==’ для сравнения значений объектов, вызывая метод equals. Для сравнения идентичности, такого как оператор Java ‘==’, Kotlin вводит оператор ‘===’.

kotlin-stdlib / kotlin / Any / равно

open operator fun equals(other: Any?): Boolean

Указывает на то,что какой-то другой объект «равен» этому. Введение должно отвечать следующим требованиям:

• Рефлексивное: для любого ненулевого значения x , x.equals(x) должна возвращать верно.
• Симметричный: для любых значений ненулевых x и y , x.equals(y) должен возвращать истинен тогда и только тогда , когда y.equals(x) возвращает истину.
• Транзитивный: для любых ненулевых значений x , y и z , если x.equals(y) возвращает true, а y.equals(z) возвращает true, то x.equals(z) должен возвращать true.
• Последовательно: для любых ненулевых значений x и y множественные вызовы x.equals(y) последовательно возвращают истину или последовательно возвращают ложь, при условии, что никакая информация, используемая в equals сравнениях для объектов, не изменена.
• Никогда не равен нулю: для любого ненулевого значения x , x. equals(null) должен возвращать ложь.

Узнайте больше о равенстве в Котлине.

• Annotation

  Базовый интерфейс,неявно реализуемый всеми интерфейсами аннотаций.

• <init>

  Корень иерархии классов Kotlin.

• hashCode

  Возвращает значение хэш-кода для объекта.

• Any

  Корень иерархии классов Kotlin.

• 1
• …
• 2613
• 2614
• 2615
• 2616
• 2617
• …
• 4091
• Next

[Глава 4] 4.

Равенство операторы сравнения в Java используются для равенства (==) и операции сравнения не-равно (!=). Операторы сравнения равенства могут появляться в выражении равенства:

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

Ссылки операторы реляционного сравнения; Порядок действий

Оператор эквивалентности ==

Оператор равенства == выполняет сравнение между своими операндами и возвращает логическое значение. Возвращает чистое значение true, если операнды равны друг другу; в противном случае возвращается чистое значение false. Оператор == может появляться как часть равенства выражение. Оператор равенства никогда не генерирует исключение.

Операнды == могут быть любого типа, но они оба должны быть одного типа или времени компиляции возникает ошибка. Если один операнд имеет арифметический тип, то другой также должны быть арифметического типа. Если один операнд имеет тип boolean, другой также должен быть логического типа. Если один операнд является ссылочным типом, другой также должен быть ссылочным тип. Обратите внимание, что ни один из операндов не может быть выражением, вызывающим метод пустоты.

Если оба операнда имеют арифметические типы, то оператор выполняет арифметическое равенство сравнение. Оператор может выполнять преобразования типов операндов:

• Если любой из операндов имеет тип double, то другой операнд преобразуется в двойной.
• В противном случае, если один из операндов имеет тип float, другой операнд преобразуется в число с плавающей запятой.
• В противном случае, если один из операндов имеет тип long, другой операнд преобразуется в длинный.
• В противном случае, оба операнда преобразуются в int.

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

• Если любой из операндов не является числом (NaN), сравнение дает ложь.
• Положительная бесконечность — это отдельное значение, равное самому себе, и не равно никакому другому значению.
• Отрицательная бесконечность это отдельное значение, равное самому себе и не равное никакому другое значение.
• Положительный и отрицательный нуль обрабатываются как равные, поэтому -0.0==0.0 дает истину.

Если оба операнда являются булевыми значениями, оператор выполняет логическое сравнение на равенство. Сравнение возвращает истину, если оба операнда истинны или оба операнда ложны. В противном случае сравнение выдает ложное.

Если оба операнда являются ссылочными типами, оператор выполняет сравнение объектов на равенство. Для выполнения этого типа сравнения должна быть возможность привести значение одного из операндов к типу другого операнд, или возникает ошибка времени компиляции. Сравнение дает истина, если оба его операнда относятся к одному и тому же объект или если оба его операнда равны нулю; в противном случае сравнение дает ложь.

Потому что оператор == определяет, являются ли два объекта один и тот же объект, он не подходит для сравнений, которые требуют чтобы определить, имеют ли два объекта одинаковое содержимое. Например, если вам нужно знать, являются ли два объекта String содержат одинаковые последовательности символов, == оператор не подходит. Вы должны использовать equals() вместо этого метод:[4]

[4] Это похоже на разницу в C между записью string1==string2 и strcmp(строка1, строка2)==0.

string1.equals (string2) // Сравнивает содержимое строк
string1 == string2 // Сравнивает фактические строковые объекты
 

Ссылки арифметические типы; логический тип; Ссылочные типы

Неравный оператор !=

Оператор не равно != выполняет сравнение между своими операндами и возвращает логическое значение ценить. Возвращает чистое значение true, если операнды не равны друг другу; в противном случае он возвращает чистый значение ложно. Оператор != может появляться как часть выражения равенства. Оператор не равно никогда не выдает исключение.

Операнды != может быть любого типа, но они оба должны быть одного типа или возникает ошибка времени компиляции. Если один операнд имеет арифметическое значение тип, другой также должен быть арифметического типа. Если один операнд имеет тип boolean, другой также должен быть типа тип булев. Если один операнд является ссылочным типом, другой также должен быть ссылочным типом. Обратите внимание, что ни один из операндов может быть выражением, которое вызывает метод void.

Если оба операнда имеют арифметический тип, оператор выполняет сравнение арифметического неравенства. Оператор может выполнять тип преобразования операндов:

• Если любой из операндов имеет тип double, тогда другой операнд преобразуется в двойной.
• В противном случае, если любой из операндов имеет тип float, другой операнд преобразуется держаться на плаву.
• В противном случае, если любой из операндов имеет тип long, другой операнд преобразуется долго.
• В противном случае оба операнда преобразуются в внутр.

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

• Если любой из операндов не является числом (NaN), сравнение дает истинный. NaN — единственное значение, которое сравнивается с не равно себе.
• Положительная бесконечность является отличной значение, равное самому себе и не равное никакому другому значению.
• Отрицательная бесконечность — это отдельное значение, равное самому себе, и не равно никакому другому значению.
• Положительный и отрицательный нули рассматриваются как равные, поэтому -0.0!=0.0 дает ЛОЖЬ.

Если оба операнда логические значения, оператор выполняет сравнение логических неравенств. сравнение дает false, если оба операнда истина или оба операнда ложны. В противном случае сравнение дает true.

Если оба операнда являются ссылочными типами, оператор выполняет сравнение объектов на равенство. Для выполнения этого вида сравнения, должна быть возможность привести значение одного из операнды к типу другого операнда или ошибка времени компиляции имеет место. Сравнение дает истину, если оба его операндов относятся к разным объектам, и если оба его операнда не являются нулевыми; в противном случае сравнение дает ЛОЖЬ.

Потому что != оператор определяет, являются ли два объекта разными объектами, это не подходит для сравнений, которые должны определить, являются ли два объекта имеют разное содержание. Например, если вам нужно узнать, два объекта String содержат разные последовательности символов, оператор != не подходит. Вы должны использовать equals() вместо этого метод: [5]

[5] Это похоже на разницу в C между записью string1!=string2 и strcmp(строка1, строка2)!=0.

!string1.equals (string2) // Сравнивает содержимое строк
string1 != string2 // Сравнивает фактические строковые объекты
 

Ссылки арифметические типы; логический тип; Ссылочные типы

Равенство в Котлине («==», «===» и «равно») · Сунит Агравал

Нам часто нужно сравнить данные двух переменных или объектов или ссылки двух объектов в Котлине. Это вызывает еще один вопрос, какую проверку на равенство мы должны использовать в каком случае. Давайте разберемся, какие типы проверок доступны в Kotlin.

Структурное равенство (‘==’) Оператор

== используется для сравнения данных двух переменных. Пожалуйста, не поймите неправильно этот оператор равенства с оператором Java == , поскольку оба они разные. Оператор == в Kotlin сравнивает только данные или переменные, тогда как в Java или других языках == обычно используется для сравнения ссылок. Отрицательный аналог == в Котлине равен != , который используется для сравнения, если оба значения не равны друг другу.

Ссылочное равенство (‘===’)

=== оператор используется для сравнения ссылок двух переменных или объектов. Только будет истинным , если оба объекта или переменные указывают на один и тот же объект. Аннулированный аналог === в Котлине — это !== , который используется для сравнения, если оба значения не равны друг другу. Для значений, которые во время выполнения представляются как примитивные типы (например, Int), === Проверка равенства эквивалентна проверке == .

метод .equals

equals(other: Any?) Метод реализован в классе Any и может быть переопределен в любом расширяющемся классе. Метод .equals также сравнивает содержимое переменных или объектов точно так же, как оператор == , но он ведет себя иначе в случае сравнения Float и Double . Разница между == и .равно в случае сравнения Float и Double , .equals не соответствует стандарту IEEE 754 для арифметики с плавающей запятой.

И что означает несогласие со стандартом IEEE 754 для арифметики с плавающей запятой?

 <ул>
            
NaN считается равным самому себе
            
NaN считается большим, чем любой другой элемент, включая POSITIVE_INFINITY
            
-0.0 считается меньше 0.0
    
 

   
 val int1 = 10 
 val int2 = 10 
 println(int1 == int2) // true 
 println(int1.equals(int2)) // true 
 println(int1 === int2) // true 
 
 

.
   
 val first = Integer(10) 
 val second = Integer(10) 
 println(first == second) //true 
 println(first.equals(second)) //true 
 println(first === second)/ /false 
 
 

   
 class Employee (имя val: String) 
 val emp1 = Employee("Suneet") 
 val emp2 = Employee("Suneet") 
 println(emp1 == emp2) //false 
 println(emp1.equals(emp2)) //ложь 
 println(emp1 === emp2) //ложь 
 
 println(emp1. name == emp2.name) //true 
 println(emp1.name.equals(emp2.name)) //true 
 println(emp1.name === emp2.name) //true 
 
 

   
 класс данных Employee (val name: String) 
 val emp1 = Employee("Suneet") 
 val emp2 = Employee("Suneet") 
 println(emp1 == emp2) //true 
 println(emp1.equals(emp2) ) //true 
 println(emp1 === emp2) //false 
 
 println(emp1.name == emp2.name) //true 
 println(emp1.name.equals(emp2.name)) //true 
 println(emp1.name === emp2.name) //true 
 
 

   
 val negZero = -0.0f 
 val posZero = 0.0f 
 println(negZero == posZero) //true 
 println(negZero.equals(posZero)) //false 
 println(negZero === posZero) //true