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

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

String s1 = "Hello";
String s2 = "hello";

if (s1.equals(s2)) {
    System.out.println("hai");
} else {
    System.out.println("welcome");
}

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

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

Используйте String.equalsIgnoreCase().

Используйте справочник по Java API, чтобы найти такие ответы:

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

https://docs.oracle.com/javase/1.5.0/docs/api/

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

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

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

import com.ibm.icu.text.Normalizer2;

// ...

public static boolean equalsIgnoreCase(CharSequence s, CharSequence t) {
    Normalizer2 normalizer = Normalizer2.getNFKCCasefoldInstance();
    return normalizer.normalize(s).equals(normalizer.normalize(t));
}

    String brook = "flu\u0308ßchen";
    String BROOK = "FLÜSSCHEN";

    assert equalsIgnoreCase(brook, BROOK);

Наивное сравнение с String.equalsIgnoreCase, или String.equalsна прописные или нижний регистр строк не получится даже этот простой тест.

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

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

int compareValue = str1.compareToIgnoreCase(str2);

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

import java.lang.String; //contains equalsIgnoreCase()
/*
*
*/
String s1 = "Hello";
String s2 = "hello";

if (s1.equalsIgnoreCase(s2)) {
System.out.println("hai");
} else {
System.out.println("welcome");
}

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

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

String.CASE_INSENSITIVE_ORDER

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

String s = "some text here";
s.equalsIgnoreCase("Some text here");

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

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

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

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

private static class HashWrap {
    private final String value;
    private final int hash;

    public String get() {
        return value;
    }

    private HashWrap(String value) {
        this.value = value;
        String lc = value.toLowerCase();
        this.hash = lc.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o instanceof HashWrap) {
            HashWrap that = (HashWrap) o;
            return value.equalsIgnoreCase(that.value);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        return this.hash;
    }
}

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

HashMap<HashWrap, Object> map = new HashMap<HashWrap, Object>();

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

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

то есть:

public boolean areStringsSame(String str1, String str2)
{
    if (str1 == null && str2 == null)
        return true;
    if (str1 == null || str2 == null)
        return false;

    return str1.equalsIgnoreCase(str2);
}

Используйте s1.equalsIgnoreCase(s2): https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String) .

Вы можете использовать equalsIgnoreCase

Подробнее о строке можно найти в Учебниках по классам String и String.

Чтобы быть нулевым, вы можете использовать

org.apache.commons.lang.StringUtils.equalsIgnoreCase(String, String)

или

org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)

public boolean newEquals(String str1, String str2)
{
    int len = str1.length();
int len1 = str2.length();
if(len==len1)
{
    for(int i=0,j=0;i<str1.length();i++,j++)
    {
        if(str1.charAt(i)!=str2.charAt(j))
        return false;
    }`enter code here`
}
return true;
}