Oc-windows.ru

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

Java string equalsignorecase

Java: String: equalsIgnoreCase vs switching everything to Upper/Lower Case

It came to my attention that there a several ways to compare strings in Java.

I just got in the habit ages ago to use equalsIgnoreCase to avoid having problems with case sensitive strings.

Others on the other hand prefer passing everything in upper or lower case.

From where I stand (even if technically I’m sitting), I don’t see a real difference.

Does anybody know if one practice is better than the other? And if so why?

8 Answers 8

Use equalsIgnoreCase because it’s more readable than converting both Strings to uppercase before a comparison. Readability trumps micro-optimization.

What’s more readable?

I think we can all agree that equalsIgnoreCase is more readable.

equalsIgnoreCase avoids problems regarding Locale-specific differences (e.g. in Turkish Locale there are two different uppercase «i» letters). On the other hand, Maps only use the equals() method.

But the issue in the latter, where you make an assumption that either upper or lower case is passed, you cannot blindly trust the caller. So you have to include an ASSERT statement at the start of the method to make sure that the input is always in the case your are expecting.

Neither is better, they both have their uses in different scenarios.

Many times when you have to do string comparisons there is the opportunity to massage at least one of the strings to make it easier to compare, and in these cases you will see strings converted to a particular case, trimmed, etc before being compared.

If, on the other hand, you just want to do an on-the-fly case-insensitive comparison of two strings then feel free to use equalsIgnoreCase , that’s what its there for after all. I would caution, however, that if you’re seeing a lot of equalsIgnoreCase it could be a code smell.

Performance wise both are same according to this post:

So I would decide based on code readabilty, in some case toLowerCase() would be better if I am passing a value always to a single method to create objects, otherwise equalsIgnoreCase() makes more sense.

It depends on the use case.

If you’re doing a one to one string comparison, equalsIgnoreCase is probably faster, since internally it just uppercases each character as it iterates through the strings (below code is from java.lang.String), which is slightly faster than uppercasing or lowercasing them all before performing the same comparison:

But when you have a situation where you want to do lookups against a data structure full of strings (especially strings that are all in the US Latin/ASCII space) in a case insensitive manner, it will be quicker to trim/lowercase the strings to be checked against and put them in something like a HashSet or HashMap.

This is better than calling equalsIgnoreCase on each element of a List because the slight performance gain of equalsIgnoreCase() is canceled out by the fact that you’re basically doing a modified version of contains() against an array, which is O(n). With a pre-normalized string you can check against the entire list of strings with a single contains() call that runs in O(1).

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).

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

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

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

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

Поэтому, используя 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.

Читать еще:  Java util concurrentmodificationexception

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.

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.

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