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

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

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

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

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

Ответы

Ответ 1

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

Ответ 3

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

int compareValue = str1.compareToIgnoreCase(str2);

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

Ответ 4

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.

Ответ 5

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

Ответ 6

В стандартном 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>();

Ответ 7

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

Объект null 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);
}

Ответ 11

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

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

или

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

Ответ 12

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;
}