Elettracompany.com

Компьютерный справочник
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Java string equalsignorecase

Java String equalsIgnoreCase Method

The Java String equalsIgnoreCase method compares a string with user-specified string to check whether they both represent the same sequence of characters or not. Based on the result, it will return Boolean True or False. Remember, while comparing two strings, this Java qualsIgnoreCase method will ignore the case differences (Case sensitivity).

In this article, we will show how to write Java equalsIgnoreCase method with an example. The syntax of the Java String equalsIgnoreCase in Java Programming language is as shown below.

Java String equalsIgnoreCase Method syntax

The following Java String equalsIgnoreCase method accepts the string data as the argument. Next, it performs a case-insensitive comparison on existing string with this new string to check whether they are equal or not.

  • String_Object: Please specify the valid string. It will compare against the another_String
  • another_String: Please specify the valid string. It is the string we are going to compare with String_Object.

Java String equalsIgnoreCase Example

In this Java program, we use the String equalsIgnoreCase in Java to check whether this string and user-specified one is equal or not.

OUTPUT

ANALYSIS

The following Java String equalsIgnoreCase statement will call the public boolean equals (Object Obj) method to compare the string str1 with str2. From the above screenshot, observe that it is returning False because they are different in Case.

It will call the public boolean equalsIgnorecase (String another_String) method to perform a case-insensitive comparison on string str1 and str2. From the above screenshot, see that it is returning TRUE because they both are equal.

Next, we checked for non-equivalent values using Java equalsIgnoreCase. Here “Tutorial GateWay” is not at all equals to “Java Program”.

Lastly, we used the System.out.println statements to print the output

Java equalsIgnoreCase Example 2

In this Java program, We are going to ask the user to enter any word. Based on the user entered string value, it displays the message.

OUTPUT

Let us enter different word

ANALYSIS

The following statement will ask the user to enter any word. Then we are going to assign the user entered value to string variable str.

Next, we used the Java If Else Statement to compare the user entered string with the String Object “Tutorial gateway” and check whether they are equal or not.

Java: String: equalsIgnoreCase vs переключение всего на верхний / нижний регистр

Мне пришло в голову, что существует несколько способов сравнения строк в Java.

Я просто давно привык использовать equalsIgnoreCase , чтобы избежать проблем с чувствительными к регистру строками.

Другие, напротив, предпочитают передавать все в верхнем или нижнем регистре.

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

Знает ли кто-нибудь, что одна практика лучше другой? И если да, то почему?

8 Ответов

Используйте equalsIgnoreCase , потому что это более читабельно, чем преобразование обеих строк в верхний регистр перед сравнением. Читабельность козыри микро-оптимизации .

Что может быть более читабельным?

Я думаю, мы все можем согласиться, что equalsIgnoreCase более удобочитаема.

equalsIgnoreCase позволяет избежать проблем, связанных с Locale-специфическими различиями (например, в Turkish Locale есть две разные прописные буквы «i»). С другой стороны, карты используют только метод equals().

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

Ни то, ни другое не лучше, они оба имеют свое применение в разных сценариях.

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

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

Производительность мудрая оба одинаковы в соответствии с этим постом:

Поэтому я бы решил, основываясь на читаемости кода, в некоторых случаях toLowerCase() было бы лучше, если бы я всегда передавал значение одному методу для создания объектов, в противном случае equalsIgnoreCase() имеет больше смысла.

Это зависит от варианта использования.

Если вы выполняете сравнение строк один к одному, то equalsIgnoreCase, вероятно, быстрее, так как внутри он просто прописывает каждый символ при итерации по строкам (ниже код от java.lang.String), что немного быстрее, чем верхний или нижний регистр их всех перед выполнением того же сравнения:

Но когда у вас есть ситуация, когда вы хотите выполнить поиск по структуре данных, полной строк (особенно строк, которые все находятся в пространстве US Latin/ASCII) в нечувствительном к регистру порядке, будет быстрее обрезать/заглавные строки, чтобы проверить их и поместить их в что-то вроде HashSet или HashMap.

Это лучше, чем вызов equalsIgnoreCase для каждого элемента списка, потому что небольшое увеличение производительности equalsIgnoreCase() отменяется тем фактом, что вы в основном делаете модифицированную версию contains() против массива, который является O(n). С предварительно нормализованной строкой вы можете проверить весь список строк с помощью одного вызова contains(), который выполняется в O (1).

Читать еще:  Javascript заполнение таблицы

equalsIgnoreCase документация в jdk 8

Сравнивает эту строку с другой строкой, игнорируя регистр рассмотрения. Две строки считаются равными в том случае, если они имеют одинаковую длину и соответствующие символы в двух строках равны игнорированию случая.

Два символа c1 и c2 считаются одинаковыми игнорирование случая, если верно хотя бы одно из следующих условий:

  • Эти два символа являются одинаковыми (по сравнению с оператором == )
  • Применение метода java.lang.CharactertoUpperCase(char)к каждому символу приводит к одному и тому же результату
  • Применение метода java.lang.CharactertoLowerCase(char) к каждому символу дает тот же результат

Поэтому, используя equalsIgnoreCase, мы перебираем строки (только если их значения размера совпадают), сравнивая каждый символ. В худшем случае, мы будем производительность будет O (3cn), где n = размер ваших строк. Мы не будем использовать дополнительное пространство.

Используя toUpper(), затем сравнивая, если строки равны, вы ALWAYS проходите через каждую строку один раз, Преобразуя все строки в верхнюю, а затем выполняете проверку эквивалентности по ссылке (equals()). Это тета(2n + c). Но просто помните, что когда вы делаете toUpperCase(), вы фактически должны создать две новые строки, потому что строки в Java являются неизменяемыми.

Поэтому я бы сказал, что equalsIgnoreCase одновременно более эффективен и легче читается.

И снова я хотел бы рассмотреть вариант использования, потому что это было бы то, к чему он сводится для меня. Подход toUpper может быть верен в некоторых случаях использования, но 98% из них я использую equalsIgnoreCase().

Когда я работаю только с английскими символами, я всегда запускаю toUpperCase() или toLowerCase() , прежде чем начать сравнение, если я вызываю .equalsIgnoreCase() более одного раза или если я использую оператор switch . Таким образом, он выполняет операцию изменения регистра только один раз, и поэтому более эффективен.

Например, в Заводском шаблоне:

(Использование оператора switch немного быстрее, чем блоков if..else if..else для сравнения строк)

Похожие вопросы:

Я новичок в Java и только начинаю изучать язык, но я попадаю в несколько коряг по пути, и я надеялся, что вы можете дать мне какое-то направление по вопросу, который у меня есть. Я знаю, что Java.

Имеет ли значение, используется ли верхний или нижний регистр a для массивов php? Например: array() против Array()

Как я могу изменить все URLs на верхний / нижний регистр или изменить соглашение об именах по умолчанию? Напр.. от: http://our.umbraco.org/projects/backoffice-extensions/ к.

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

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

Я хочу преобразовать первый символ строки в верхний регистр,а rest символов-в Нижний. Как я могу это сделать? Пример: String inputval=ABCb OR a123BC_DET or aBcd String outputval=Abcb or A123bc_det.

можем ли мы использовать команду sed для замены нижнего регистра на нижний регистр и верхний регистр с суффиксом изменения верхнего регистра с этими строками в одной команде ?. например, я хочу.

Я пытаюсь сравнить строку в Java SE Eclipse, которую пользователь дает как ID к строке в моем Derby DB. Строка, которую пользователь дает, является textStudentID , и она сравнивается с ID в базе.

Я хотел бы написать perl regex, чтобы заменить какой-то шаблон на другой шаблон. Исходный шаблон является строчным, за которым следует верхний регистр. Шаблон назначения-это нижний регистр, за.

В VS-коде документы для создания пользовательских фрагментов упоминают некоторые Grammar , которые включают параметры для /upcase , /downcase и /capitalize , но я не могу понять, как его.

equalsIgnoreCase() In Java Example | Java String equalsIgnoreCase()

Java String equalsIgnoreCase() method compares two strings irrespective of the case (lower or upper) of the string. As you can see from its name also that the name is equalsIgnoreCase and hence there must be something like equality checking and IgnoreCase shows that Case should be ignored means that we have to compare the equality of two things without considering their cases.

equalsIgnoreCase() In Java

The equalsIgnoreCase() method returns true if the argument is not null and it represents an equivalent String ignoring case, else false.

It is like equals() method but it doesn’t check the case like upper or lower. If any character is not matched, then it returns false otherwise it returns true.

The equalsIgnoreCase() method is a primary method that mainly does the work of comparing two different strings without taking into account the case in which it was written.

It is similar to the equals method in java, but the only difference is that it does not care about the case in which it is written but equals method takes care of the case in which they were written.

Читать еще:  Java lang illegalstateexception что это

After comparing if all the characters are matched, then it will return true else, it will return false just like the boolean that happen.

Let’s see how we can declare this method equalsIgnoreCase.

This is the syntax of method equalsIgnoreCase() where we are doing the work of comparing our two strings that are string1 and string2.

Now you want to know what will be the results after executing the statement so I should clarify that also that this method will return true if both of them string1 and string2 are equivalent after ignoring the Case else it will return us false.

Two strings are necessary for this method to work as there is a comparison between these two strings.

#Example

It will give us the output true.

Don’t confuse with equals() and equalsIgnoreCase() as they are both are almost the same, but the difference is of the only Case that in equals() method case is also taken in the account whereas in case of equalsIgnoreCase() method case does not matter.

Let’s see this or try to understand through a diagram as it is the best way to understand any of the things.

The equalsIgnoreCase( ) method is the method mainly performed on strings to check whether they are identical or not. But equalsIgnoreCase( ) method only exists in java programming language and not in C, C++ etc.

The equalsIgnoreCase( ) method is the method that shows its output in the boolean form that is in true or false rather than any specific output.

For a better understanding of this topic, we have to prefer an example.

See the following output.

#Java String equalsIgnoreCase() Method Example

Let’s see another example. This time we will take a Java ArrayList.

In the above example, there we are comparing the string Millie Bobby Brown with all the ArrayList elements, and if it finds the match, then it will go ahead and print the if condition’s statement.

See the following output.

In this way, we have learned equalsIgnoreCase() In Java Example Tutorial.

Ankit Lathiya is a Master of Computer Application by education and Android and Laravel Developer by profession and one of the authors of this blog.

Java: String: equalsIgnoreCase vs переключение всего в верхний / нижний регистр

мне пришло в голову, что существует несколько способов сравнения строк в Java.

Я просто привык много лет назад использовать equalsIgnoreCase чтобы избежать проблем с учетом регистра строки.

другие, с другой стороны, предпочитают передавать все в верхнем или нижнем регистре.

С, где я стою (даже если технически я сижу), я не вижу реальной разницы.

8 ответов

использовать equalsIgnoreCase потому что это более читабельно, чем преобразование обеих строк в верхний регистр перед сравнением. читаемость превосходит микро-оптимизацию.

что более читабельно?

Я думаю, мы все можем согласиться, что equalsIgnoreCase более читабельным.

equalsIgnoreCase позволяет избежать проблем, связанных с различиями в локали (например, в турецком языке есть две разные прописные буквы «i»). С другой стороны, карты используют только метод equals ().

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

не лучше, они оба используются в различных сценариях.

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

Если, с другой стороны, вы просто хотите сделать «на лету» нечувствительное к регистру сравнение двух строк, то не стесняйтесь использовать equalsIgnoreCase , вот что его там все-таки. Я бы предостерег, однако, что если вы видите много equalsIgnoreCase Это может быть код запах.

производительность мудрые оба одинаковы в соответствии с этим сообщением:

поэтому я бы решил, основываясь на readabilty кода, в некоторых случаях toLowerCase() было бы лучше, если бы я всегда передавал значение одному методу для создания объектов, иначе equalsIgnoreCase() имеет больше смысла.

когда я работаю с английскими символами, я всегда запускаю toUpperCase() или toLowerCase() прежде чем я начну делать сравнения, если я звоню .equalsIgnoreCase() еще раз или если я использую switch заявление. Таким образом, он выполняет операцию изменения регистра только один раз, и поэтому более эффективен.

например, в Заводском шаблоне:

(через switch заявление немного быстрее, чем if..else if..else блоки для сравнения строк)

Это зависит от варианта использования.

Если вы делаете сравнение один к одному, equalsIgnoreCase, вероятно, быстрее, так как внутри он просто прописными буквами каждый символ при итерации по строкам (ниже код из java.ленг.Строку), что немного быстрее, чем uppercasing или строчной их всех прежде, чем выполнить аналогичное сравнение:

но когда у вас есть ситуация, когда вы хотите выполнить поиск по структуре данных, полной строк (особенно строки, которые находятся в пространстве US Latin/ASCII) в нечувствительном к регистру порядке, будет быстрее обрезать / строчные буквы строк, которые будут проверены, и поместить их во что-то вроде HashSet или HashMap.

Читать еще:  Nosuchelementexception java что это

это лучше, чем вызов equalsIgnoreCase для каждого элемента списка, потому что небольшое увеличение производительности equalsIgnoreCase() отменяется тем фактом, что вы в основном делаете измененную версию contains() против массива, который является O(n). С предварительно нормализованная строка вы можете проверить весь список строк с помощью одного вызова contains (), который выполняется в O (1).

документация equalsIgnoreCase в jdk 8

сравнивает эту строку с другой строкой, игнорируя регистр рассмотрения. Две строки считаются равными, игнорируя случай, если они имеют одинаковую длину и соответствующие символы в двух строках равны без учета регистра.

два символа c1 и c2 считаются одинаковыми игнорируя случае, если хотя бы одно из следующих условий:

  • два символы одинаковы (по сравнению с оператором == )
  • применение метода java.ленг.CharactertoUpperCase (char)для каждого символа дает тот же результат
  • применение метода java.ленг.CharactertoLowerCase (char) для каждого символа дает тот же результат

поэтому, используя equalsIgnoreCase, мы перебираем строки (только если их значения размера одинаковы), сравнивая каждый шар. В худшем случае производительность будет O( 3cn), где n = размер ваших строк. Мы не будем использовать дополнительное пространство.

используя toUpper (), затем сравнивая, если строки равны, вы всегда перебираете каждую строку один раз, Преобразуя все строки в верхние, а затем выполняете эквивалентность по ссылке (equals ()). Это тета (2n + c). Но просто помните, что когда вы делаете toUpperCase (), вам фактически нужно создать две новые строки, потому что строки в Java неизменный.

поэтому я бы сказал, что equalsIgnoreCase является более эффективным и легче читать.

снова я бы рассмотрел вариант использования, потому что это было бы то, что для меня. Подход toUpper может быть действительным в некоторых случаях использования, но 98% времени я использую equalsIgnoreCase().

Java: String: equalsIgnoreCase против переключения всего на верхний/нижний регистр

Мне пришло в голову, что существует несколько способов сравнения строк в Java.

Я только что привык к тому, что использовал equalsIgnoreCase , чтобы избежать проблем с строками, чувствительными к регистру.

Другие, с другой стороны, предпочитают передавать все в верхнем или нижнем регистре.

Откуда я стою (даже если технически я сижу), я не вижу реальной разницы.

Кто-нибудь знает, лучше ли одна практика, чем другая? И если да, то почему?

java string string-comparison

7 ответов

46 Решение Asaph [2010-12-15 07:23:00]

Используйте equalsIgnoreCase , потому что это более читаемо, чем преобразование обеих строк в верхний регистр перед сравнением. Микро-оптимизация удобочитаемости.

Что более читаемо?

Я думаю, мы все можем согласиться с тем, что equalsIgnoreCase более читаем.

8 koljaTM [2013-04-18 15:41:00]

equalsIgnoreCase избегает проблем, связанных с различиями в локали (например, в турецком языке есть два разных прописных буквы «i» ). С другой стороны, Maps использует метод equals().

Но проблема в последнем, когда вы принимаете предположение, которое передается в верхнем или нижнем регистре, вы не можете слепо доверять вызывающему. Поэтому вам нужно включить инструкцию ASSERT в начале метода, чтобы убедиться, что вход всегда в том случае, если вы ожидаете.

Также не лучше, они оба используют свои приложения в разных сценариях.

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

Если, с другой стороны, вы просто хотите выполнить «безрезультатное» сравнение двух строк без учета регистра, то не стесняйтесь использовать equalsIgnoreCase , что его там для всех. Однако я бы предупредил, что если вы видите много equalsIgnoreCase , это может быть запах кода.

1 Sileria [2012-06-27 12:35:00]

Показатели производительности одинаковы в соответствии с этим постом:

Итак, я бы решил, основываясь на читабельности кода, в некоторых случаях toLowerCase() было бы лучше, если бы я передавал значение всегда одному методу создания объектов, иначе equalsIgnoreCase() имеет больше смысла.

0 4castle [2016-05-13 09:01:00]

Когда я работаю с английскими символами, я всегда запускаю toUpperCase() или toLowerCase() , прежде чем начинать выполнять сравнения, если я вызываю .equalsIgnoreCase() более одного раза, или если я ‘используя оператор switch . Таким образом, он выполняет операцию изменения case только один раз, и, следовательно, более эффективен.

Например, в шаблоне factory:

(Использование оператора switch выполняется немного быстрее, чем if..else if..else блоков для сравнения строк)

0 Jim W [2016-11-02 19:31:00]

Это зависит от варианта использования.

Если вы выполняете сравнение строк с одним или несколькими, equalsIgnoreCase, вероятно, быстрее, так как внутри он просто аппроксимирует каждый символ, когда он выполняет итерацию по строкам (ниже код из java.lang.String), что немного быстрее, чем перед тем, как выполнить то же сравнение:

Но если у вас есть ситуация, когда вы хотите выполнять поиск по структуре данных, полной строк (особенно строк, которые все находятся в латинском/ASCII-пространстве США) нечувствительным к регистру, быстрее будет обрезать/строки, которые нужно проверить, и помещать их в нечто вроде HashSet или HashMap.

Это лучше, чем вызов equalsIgnoreCase для каждого элемента списка, потому что небольшое увеличение производительности equalsIgnoreCase() отменяется из-за того, что вы в основном делаете модифицированную версию contains() для массива, которая равна O (п). С предварительно нормированной строкой вы можете проверить весь список строк с помощью одного вызова contains(), который выполняется в O (1).

Ссылка на основную публикацию
Adblock
detector