Меню

Java сравнить без учета регистра



Изучаем Java: сравнение строк

Класс String Java содержит ряд методов для сравнения строк. Ниже приведены некоторые методы класса string java:

  • Оператор == ;
  • Метод equals() ;
  • equalsIgnoreCase ;
  • Метод compareTo() .

Java string методы — использование оператора ==

Оператор == проверяет ссылки, а не значения. Это означает, что он проверяет, являются ли сравниваемые элементы одним и тем же объектом. Если две переменные String указывают на один и тот же объект в памяти, сравнение возвращает true . В противном случае — false :

Здесь литералы интернируются компилятором и таким образом ссылаются на один и тот же объект:

Приведенные выше переменные String указывают на разные объекты:

Приведенные выше переменные String также указывают на разные объекты.

Оператор ‘==’ не сравнивает строки в java, а только ссылки, на которые они строки.

Метод String equals()

В Java сравнение строк equals проверяет исходное содержимое строки. Он возвращает true , если параметр — это объект String , который представляет собой ту же строку символов, что и объект:

Если нужно проверить, имеют ли две строки одинаковое значение, можно использовать Objects.equals() .

String equalsIgnoreCase

Метод equalsIgnoreCase() осуществляет Java сравнение строк лексикографически, игнорируя различия регистра. Значение true возвращается только тогда, когда аргумент является объектом String , который представляет ту же последовательность символов, что и объект. Если нужно проверить строки на равенство без учета регистра, лучше использовать метод equalsIgnoreCase класса String .

Метод String compareTo()

Метод compareTo() используется, когда нужно определить порядок строк лексикографически. Он сравнивает значения char аналогично методу equals() . Если две строки точно совпадают, метод compareTo() вернет значение 0 ( результат = 0 ). При сравнении двух строк Java он возвращает положительное ( результат > 0 ) целое число, если первый объект String следует за второй строкой. Метод compareTo() возвращает отрицательный результат ( результат ), если первый объект String предшествует второй строке:

Источник

Как сравнить регистр игнорирования символов в примитивных типах

Я пишу эти строки кода:

Я хочу сравнить Character с двумя String с, игнорируя этот случай. Простое использование IgnoreCase не работает. Добавление значения ’65’ ASCII тоже не работает. Как мне это сделать?

6 ответов

Мне нужно сравнить два string s (а не только ASCII) в случае игнорирования D. Очевидным решением является: s1.toUpper() == s2.toUpper() Но я хочу избежать дублирования строк или написать один сам в пользу возможно самого быстрого нативного onde (если таковой имеется).

Как сравнить только дату без времени в DateTime типах, в C#.One дата будет обнуляться. Как я могу это сделать??

Класс Character Java API имеет различные функции, которые вы можете использовать.

Вы можете преобразовать свой символ в нижний регистр с обеих сторон:

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

На самом деле вы не можете сделать эту работу совершенно правильно с toLowerCase , ни в строке, ни в символе. Проблема в том, что существуют различные глифы в верхнем или нижнем регистре, и в зависимости от того, прописные вы или строчные, ваши глифы могут сохраняться или не сохраняться. Даже непонятно, что вы имеете в виду, когда говорите, что два варианта строчного глифа сравниваются без учета регистра: являются ли они или не являются одним и тем же? (Обратите внимание, что существуют также глифы со смешанным регистром: \u01c5, \u01c8, \u01cb, \u01f2 или dž, lj, nj, dz, но любой метод, предложенный здесь, будет работать с ними до тех пор, пока они будут считаться такими же, как их полностью верхние или полностью нижние варианты.)

Существует дополнительная проблема с использованием Char : существует около 80 кодовых точек, не представимых с помощью одного Char , которые являются вариантами верхнего/нижнего регистра (по 40 из каждого), по крайней мере, как это обнаруживается верхним/нижним корпусом кодовой точки Java. Поэтому вам нужно получить кодовые точки и изменить регистр на них.

Но кодовые точки не помогают с вариантами глифов.

Во всяком случае, вот полный список глифов, которые являются проблематичными из-за вариантов, показывая, как они справляются с 6 вариантами методов:

  1. Персонаж toLowerCase
  2. Персонаж toUpperCase
  3. Строка toLowerCase
  4. Строка toUpperCase
  5. Строка equalsIgnoreCase
  6. Символ toLowerCase(toUpperCase) (или наоборот)

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

Еще больше усложняет это то, что нет никакого способа получить правильность Turkish I (т. е. пунктирные версии отличаются от неразмеченных версий), если вы не знаете, что находитесь в Turkish; ни один из этих методов не дает правильного поведения и не может дать, если вы не знаете locale (т. е. не-Turkish: i и I — это один и тот же игнорирующий случай; Turkish, нет).

Читайте также:  Добрый человек все возможные степени сравнения

В целом, использование toUpperCase дает вам самое близкое приближение, так как у вас есть только пять вариантов верхнего регистра (или четыре, не считая Turkish).

Вы также можете попытаться специально перехватить эти пять неприятных случаев и вызвать toUpperCase(toLowerCase(c)) только по ним. Если вы тщательно выберете своих охранников (просто toUpperCase , если c 0x212B , а затем проработаете другие альтернативы), вы можете получить только штраф за скорость

20% для символов в низком диапазоне (по сравнению с

4x, если вы преобразуете отдельные символы в строки и equalsIgnoreCase их) и только около 2x штрафа, если у вас много в опасной зоне. У вас все еще есть проблема locale с пунктиром I , но в остальном вы в приличной форме. Конечно, если вы можете использовать equalsIgnoreCase на большей строке, вам лучше это сделать.

Вот пример кода Scala, который выполняет эту работу:

Вы можете изменить регистр строки перед ее использованием, например

Источник

java сравнение строк без учета регистра

Класс String содержит ряд методов для Java сравнения строк. Ниже приведены некоторые из наиболее часто используемых:

  • Оператор == ;
  • Метод equals() ;
  • equalsIgnoreCase ;
  • Метод compareTo() .

Использование оператора ==

Оператор == проверяет ссылки, а не значения. Это означает, что он проверяет, являются ли сравниваемые элементы одним и тем же объектом. Если две переменные String указывают на один и тот же объект в памяти, сравнение возвращает true . В противном случае — false :

Здесь литералы интернируются компилятором и таким образом ссылаются на один и тот же объект:

Приведенные выше переменные String указывают на разные объекты:

Приведенные выше переменные String также указывают на разные объекты.

Оператор ‘==’ не сравнивает две строки Java , а только ссылки, на которые они строки.

Метод String equals()

В Java сравнение строк equals проверяет исходное содержимое строки. Он возвращает true , если параметр — это объект String , который представляет собой ту же строку символов, что и объект:

Если нужно проверить, имеют ли две строки одинаковое значение, можно использовать Objects.equals() .

String equalsIgnoreCase

Метод equalsIgnoreCase() осуществляет Java сравнение строк лексикографически, игнорируя различия регистра. Значение true возвращается только тогда, когда аргумент является объектом String , который представляет ту же последовательность символов, что и объект. Если нужно проверить строки на равенство без учета регистра, лучше использовать метод equalsIgnoreCase класса String .

Метод String compareTo()

Метод compareTo() используется, когда нужно определить порядок строк лексикографически. Он сравнивает значения char аналогично методу equals() . Если две строки точно совпадают, метод compareTo() вернет значение 0 ( результат = 0 ). При сравнении двух строк Java он возвращает положительное ( результат > 0 ) целое число, если первый объект String следует за второй строкой. Метод compareTo() возвращает отрицательный результат ( результат ), если первый объект String предшествует второй строке:

Данная публикация представляет собой перевод статьи « String Comparison in Java » , подготовленной дружной командой проекта Интернет-технологии.ру

Содержание

Описание

Метод equalsIgnoreCase() — сравнивает данную строку с другой строкой, игнорируя регистр. Две строки считаются равными, если они имеют одинаковую длину и соответствующие символы у двух строк равны, игнорируя регистр букв.

Синтаксис

Параметры

Подробная информация о параметрах:

  • anotherString — строка для сравнения с заданной строкой.

Для соединения строк можно использовать операцию сложения («+»):

При этом если в операции сложения строк используется нестроковый объект, например, число, то этот объект преобразуется к строке:

Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.

Другой способ объединения строк представляет метод concat() :

Метод concat() принимает строку, с которой надо объединить вызывающую строку, и возвращает соединенную строку.

Еще один метод объединения — метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово «HelloJava», но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join() :

Метод join является статическим. Первым параметром идет разделитель, которым будут разделяться подстроки в общей строке, а все последующие параметры передают через запятую произвольный набор объединяемых подстрок — в данном случае две строки, хотя их может быть и больше

Извлечение символов и подстрок

Для извлечения символов по индексу в классе String определен метод char charAt(int index) . Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:

Как и в массивах индексация начинается с нуля.

Если надо извлечь сразу группу символов или подстроку, то можно использовать метод getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) . Он принимает следующие параметры:

Читайте также:  Geforce мобильные видеокарты сравнение

srcBegin : индекс в строке, с которого начинается извлечение символов

srcEnd : индекс в строке, до которого идет извлечение символов

dst : массив символов, в который будут извлекаться символы

dstBegin : индекс в массиве dst, с которого надо добавлять извлеченные из строки символы

Сравнение строк

Для сравнения строк используются методы equals() (с учетом регистра) и equalsIgnoreCase() (без учета регистра). Оба метода в качестве параметра принимают строку, с которой надо сравнить:

В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals() .

Еще один специальный метод regionMatches() сравнивает отдельные подстроки в рамках двух строк. Он имеет следующие формы:

Метод принимает следующие параметры:

ignoreCase : надо ли игнорировать регистр символов при сравнении. Если значение true , регистр игнорируется

toffset : начальный индекс в вызывающей строке, с которого начнется сравнение

other : строка, с которой сравнивается вызывающая

oofset : начальный индекс в сравниваемой строке, с которого начнется сравнение

len : количество сравниваемых символов в обеих строках

В данном случае метод сравнивает 3 символа с 6-го индекса первой строки («wor») и 3 символа со 2-го индекса второй строки («wor»). Так как эти подстроки одинаковы, то возвращается true .

И еще одна пара методов int compareTo(String str) и int compareToIgnoreCase(String str) также позволяют сравнить две строки, но при этом они также позволяют узнать больше ли одна строка, чем другая или нет. Если возвращаемое значение больше 0, то первая строка больше второй, если меньше нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0.

Для определения больше или меньше одна строка, чем другая, используется лексикографический порядок. То есть, например, строка «A» меньше, чем строка «B», так как символ ‘A’ в алфавите стоит перед символом ‘B’. Если первые символы строк равны, то в расчет берутся следующие символы. Например:

Поиск в строке

Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() — индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:

Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:

Замена в строке

Метод replace() позволяет заменить в строке одну последовательность символов на другую:

Обрезка строки

Метод trim() позволяет удалить начальные и конечные пробелы:

Метод substring() возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса:

Изменение регистра

Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() — в верхний:

Split

Метод split() позволяет разбить строку на подстроки по определенному разделителю. Разделитель — какой-нибудь символ или набор символов передается в качестве параметра в метод. Например, разобьем текст на отдельные слова:

В данном случае строка будет разделяться по пробелу. Консольный вывод:

Источник

Как проверить, содержит ли строка другую строку без учета регистра в Java?

скажем, у меня есть две строки

Я хочу выполнить проверку, возвращая это s2 внутри s1 . Я могу сделать это с:

я почти уверен, что contains() чувствителен к регистру, однако я не могу точно определить это из чтения документации. Если это так, то я полагаю, что мой лучший метод будет чем-то вроде:

все это в сторону, есть другой (возможно лучший) способ сделать это, не заботясь о чувствительность к регистру?

17 ответов

да, contains чувствителен к регистру. Вы можете использовать Java.утиль.регулярное выражение.Шаблон с флагом CASE_INSENSITIVE для сопоставления без учета регистра:

EDIT: если s2 содержит специальные символы regex (которых много), важно сначала процитировать его. Я исправил свой ответ, так как это первый, который люди увидят, но проголосуйте за Мэтта Куэйла, так как он указал на это.

одна проблема с ответ Дэйва л. — это когда s2 содержит разметку регулярных выражений, такую как \d , etc.

вы хотите вызвать шаблон.цитата() на с2:

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

Более Быстрая Реализация: Использование String.regionMatches()

использование regexp может быть относительно медленным. Он (медлительность) не имеет значения, если вы просто хотите проверить в одном случае. Но если у вас есть массив или коллекция из тысяч или сотен тысяч строк, все может идти довольно медленно.

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

Читайте также:  Глюкометр one touch сравнение

решение основывается на строку.regionMatches() метод, который, кажется, неизвестно. Он проверяет, если 2 String регионы совпадают, но важно то, что он также имеет перегрузку с удобным

Да, это достижимо:

этот код вернет строку » TRUE!- так же, как и то, что в нем содержались ваши персонажи.

более простым способом сделать это (не беспокоясь о сопоставлении шаблонов) будет преобразование обоих String s в нижнем регистре:

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

вот некоторые Unicode-дружественные, которые вы можете сделать, если вы вытащите ICU4j. Я думаю, что «игнорировать случай» сомнительно для имен методов, потому что, хотя первичные сравнения силы игнорируют случай, он описывается как специфика, зависящая от локали. Но, надеюсь, это зависит от локали так, как пользователь ожидал бы.

Я сделал тест, найдя нечувствительное к регистру совпадение строки. У меня есть вектор из 150 000 объектов со строкой как одно поле и хотел найти подмножество, которое соответствует строке. Я попробовал три метода:—4—>

конвертировать все в нижний регистр

используйте метод String matches ()

использовать регулярные выражения

результаты сроки являются:

нет попытки совпадения: 20 мс

понизить матч: 182 МС

совпадений: МС 278

регулярное выражение: 65 мс

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

Я не уверен, что ваш основной вопрос здесь, Но да .содержит чувствителен к регистру.

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

этот метод принимает строку, которая является «sub», и проверяет, равна ли она подстрокам строки контейнера, которые равны по длине»sub». Если вы посмотрите на for цикл, вы увидите, что он повторяется в подстроках (это длина «sub») над строкой контейнера.

каждая итерация проверяет, является ли подстрока строки контейнера equalsIgnoreCase суб.

Если вам нужно искать строку ASCII в другой строке ASCII, например URL-адресом, вы найдете мое решение будет лучше. Я протестировал метод icza и мой для скорости, и вот результаты:

  • дело 1 заняло 2788 МС-regionMatches
  • случай 2 занял 1520 МС-мой

Источник

Как сделать сравнение строк без учета регистра?

Я создал программу на Java для сравнения двух строк:

Отображается «добро пожаловать». Я понимаю, что это с учетом регистра. Но моя проблема в том, что я хочу сравнить две строки без учета регистра. То есть Я ожидаю, что результат будет hai .

11 ответов

  • Лучше всего использовать s1.equalsIgnoreCase(s2) : (см. javadoc )
  • Вы также можете преобразовать их в верхний /нижний регистр и использовать s1.equals(s2)

Используйте ссылку на API Java, чтобы найти ответы, подобные этим.

Вы должны использовать метод compareToIgnoreCase метода String объект.

if (compareValue == 0) это означает, что str1 равно str2

String.equalsIgnoreCase — наиболее практичный выбор для наивного сравнения строк без учета регистра.

Однако полезно знать, что этот метод не выполняет ни полного свертывания, ни декомпозиции, и поэтому не может выполнить сопоставление без учета регистра, как указано в стандарте Unicode. На самом деле API JDK не делают обеспечить доступ к информации о символах свертывания регистра, так что это задание лучше всего делегировать проверенной сторонней библиотеке.

Эта библиотека ICU , и вот как можно реализовать утилита для сравнения строк без учета регистра:

Наивное сравнение с String.equalsIgnoreCase или String.equals в верхнем или нижнем регистре не пройдёт даже этот простой тест.

(Обратите внимание, что предопределенный вариант сворачивания регистра getNFKCCasefoldInstance не зависит от локали, для турецких локалей немного больше работы с использованием UCharacter.foldCase может понадобиться.)

Теперь он выведет: hai

В Java API по умолчанию у вас есть:

Таким образом, вам не нужно переписывать компаратор, если вы должны использовать строки с отсортированными структурами данных.

Это то, что вы хотите для чистых проверок на равенство в вашем собственном коде.

Просто для получения дополнительной информации обо всем, что касается равенства строк в Java. Функция hashCode () класса java.lang.String «чувствительна к регистру»:

Итак, если вы хотите использовать Hashtable /HashMap со строками в качестве ключей и чтобы ключи, такие как «SomeKey», «SOMEKEY» и «somekey», рассматривались как равные, вам придется заключить строку в другой класс ( Вы не можете расширять String, так как это последний класс). Например:

, а затем используйте его как таковой:

Обратите внимание, что вы, возможно, захотите выполнить нулевые проверки на них также до выполнения ваших .equals или .equalsIgnoreCase.

Нулевой объект String не может вызвать метод equals.

Источник