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

Да, содержит с учетом регистра. Вы можете использовать java.util.regex.Pattern с флагом CASE_INSENSITIVE для сопоставления без учета регистра:

Pattern.compile(Pattern.quote(wantedStr), Pattern.CASE_INSENSITIVE).matcher(source).find();

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

Я не уверен, в чем ваш главный вопрос, но да, .contains чувствителен к регистру.

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

Вы хотите вызвать Pattern.quote () на s2:

Pattern.compile(Pattern.quote(s2), Pattern.CASE_INSENSITIVE).matcher(s1).find();

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

String s1 = "abBaCca";
String s2 = "bac";

String s1Lower = s1;

//s1Lower is exact same string, now convert it to lowercase, I left the s1 intact for print purposes if needed

s1Lower = s1Lower.toLowerCase();

String trueStatement = "FALSE!";
if (s1Lower.contains(s2)) {

    //THIS statement will be TRUE
    trueStatement = "TRUE!"
}

return trueStatement;

Этот код вернет строку "ИСТИНА!" как выяснилось, что ваши персонажи содержались.

String x = "abCd";
System.out.println(Pattern.compile("c",Pattern.CASE_INSENSITIVE).matcher(x).find());

Более простой способ сделать это (не беспокоясь о сопоставлении с образцом) - преобразовать оба String в нижний регистр:

String foobar = "fooBar";
String bar = "FOO";
if (foobar.toLowerCase().contains(bar.toLowerCase()) {
    System.out.println("It's a match!");
}

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

org.apache.commons.lang3.StringUtils.containsIgnoreCase("AbBaCca", "bac");

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

Вы можете использовать обычные выражения, и он работает:

boolean found = s1.matches("(?i).*" + s2+ ".*");

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

1. Преобразовать все в нижний регистр

   for (SongInformation song: songs) {
       if (song.artist.toLowerCase().indexOf(pattern.toLowercase() > -1) {
               ...
       }
   }
   

2. Используйте метод String Match ()

   for (SongInformation song: songs) {
       if (song.artist.matches("(?i).*" + pattern + ".*")) {
       ...
       }
   }
   

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

   Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
   Matcher m = p.matcher("");
   for (SongInformation song: songs) {
       m.reset(song.artist);
       if (m.find()) {
       ...
       }
   }
   

Результаты по срокам:

• Нет попыток сопоставления: 20 мсек.

• Для уменьшения совпадения: 182 мсек.

• Соответствие строк: 278 мсек.

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

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

String container = " Case SeNsitive ";
String sub = "sen";
if (rcontains(container, sub)) {
    System.out.println("no case");
}

public static Boolean rcontains(String container, String sub) {

    Boolean b = false;
    for (int a = 0; a < container.length() - sub.length() + 1; a++) {
        //System.out.println(sub + " to " + container.substring(a, a+sub.length()));
        if (sub.equalsIgnoreCase(container.substring(a, a + sub.length()))) {
            b = true;
        }
    }
    return b;
}

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

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

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

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

public static boolean containsIgnoreCase(String haystack, String needle) {
    return indexOfIgnoreCase(haystack, needle) >= 0;
}

public static int indexOfIgnoreCase(String haystack, String needle) {
    StringSearch stringSearch = new StringSearch(needle, haystack);
    stringSearch.getCollator().setStrength(Collator.PRIMARY);
    return stringSearch.first();
}

Более быстрое внедрение: использование String.regionMatches()

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

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

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

public static boolean containsIgnoreCase(String src, String what) {
    final int length = what.length();
    if (length == 0)
        return true; // Empty string is contained

    final char firstLo = Character.toLowerCase(what.charAt(0));
    final char firstUp = Character.toUpperCase(what.charAt(0));

    for (int i = src.length() - length; i >= 0; i--) {
        // Quick check before calling the more expensive regionMatches() method:
        final char ch = src.charAt(i);
        if (ch != firstLo && ch != firstUp)
            continue;

        if (src.regionMatches(true, i, what, 0, length))
            return true;
    }

    return false;
}

Анализ скорости

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

Сравниваю 5 методов.

1. Наш метод containsIgnoreCase ().
2. Преобразуя обе строки в нижний регистр и вызывая String.contains().
3. Преобразуя исходную строку в нижний регистр и вызывая String.contains() с предварительно кэшированной подстрокой в ​​нижнем регистре. Это решение уже не так гибко, потому что тестирует предопределенную подстроку.
4. Используя регулярное выражение (принятый ответ Pattern.compile().matcher().find() ...)
5. Использование регулярного выражения, но с предварительно созданным и кешированным Pattern. Это решение уже не так гибко, потому что тестирует предопределенную подстроку.

Результаты (вызвав метод 10 миллионов раз):

1. Наш метод: 670 мс
2. 2x toLowerCase () и contains (): 2829 мс
3. 1x toLowerCase () и contains () с кэшированной подстрокой: 2446 мс
4. Регулярное выражение: 7180 мс
5. Регулярное выражение с кешированным Pattern: 1845 мс

Результаты в таблице:

                                            RELATIVE SPEED   1/RELATIVE SPEED
 METHOD                          EXEC TIME    TO SLOWEST      TO FASTEST (#1)
------------------------------------------------------------------------------
 1. Using regionMatches()          670 ms       10.7x            1.0x
 2. 2x lowercase+contains         2829 ms        2.5x            4.2x
 3. 1x lowercase+contains cache   2446 ms        2.9x            3.7x
 4. Regexp                        7180 ms        1.0x           10.7x
 5. Regexp+cached pattern         1845 ms        3.9x            2.8x

Наш метод - В 4 раза быстрее по сравнению с нижним регистром и использованием contains(), В 10 раз быстрее по сравнению с использованием регулярных выражений, а также В 3 раза быстрее, даже если Pattern предварительно кэширован (и теряет гибкость проверки произвольной подстроки).

Код теста анализа

Если вам интересно, как проводился анализ, вот полное работающее приложение:

import java.util.regex.Pattern;

public class ContainsAnalysis {

    // Case 1 utilizing String.regionMatches()
    public static boolean containsIgnoreCase(String src, String what) {
        final int length = what.length();
        if (length == 0)
            return true; // Empty string is contained

        final char firstLo = Character.toLowerCase(what.charAt(0));
        final char firstUp = Character.toUpperCase(what.charAt(0));

        for (int i = src.length() - length; i >= 0; i--) {
            // Quick check before calling the more expensive regionMatches()
            // method:
            final char ch = src.charAt(i);
            if (ch != firstLo && ch != firstUp)
                continue;

            if (src.regionMatches(true, i, what, 0, length))
                return true;
        }

        return false;
    }

    // Case 2 with 2x toLowerCase() and contains()
    public static boolean containsConverting(String src, String what) {
        return src.toLowerCase().contains(what.toLowerCase());
    }

    // The cached substring for case 3
    private static final String S = "i am".toLowerCase();

    // Case 3 with pre-cached substring and 1x toLowerCase() and contains()
    public static boolean containsConverting(String src) {
        return src.toLowerCase().contains(S);
    }

    // Case 4 with regexp
    public static boolean containsIgnoreCaseRegexp(String src, String what) {
        return Pattern.compile(Pattern.quote(what), Pattern.CASE_INSENSITIVE)
                    .matcher(src).find();
    }

    // The cached pattern for case 5
    private static final Pattern P = Pattern.compile(
            Pattern.quote("i am"), Pattern.CASE_INSENSITIVE);

    // Case 5 with pre-cached Pattern
    public static boolean containsIgnoreCaseRegexp(String src) {
        return P.matcher(src).find();
    }

    // Main method: perfroms speed analysis on different contains methods
    // (case ignored)
    public static void main(String[] args) throws Exception {
        final String src = "Hi, I am Adam";
        final String what = "i am";

        long start, end;
        final int N = 10_000_000;

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCase(src, what);
        end = System.nanoTime();
        System.out.println("Case 1 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsConverting(src, what);
        end = System.nanoTime();
        System.out.println("Case 2 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsConverting(src);
        end = System.nanoTime();
        System.out.println("Case 3 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCaseRegexp(src, what);
        end = System.nanoTime();
        System.out.println("Case 4 took " + ((end - start) / 1000000) + "ms");

        start = System.nanoTime();
        for (int i = 0; i < N; i++)
            containsIgnoreCaseRegexp(src);
        end = System.nanoTime();
        System.out.println("Case 5 took " + ((end - start) / 1000000) + "ms");
    }

}

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

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

Код:

public static String lowerCaseAscii(String s) {
    if (s == null)
        return null;

    int len = s.length();
    char[] buf = new char[len];
    s.getChars(0, len, buf, 0);
    for (int i=0; i<len; i++) {
        if (buf[i] >= 'A' && buf[i] <= 'Z')
            buf[i] += 0x20;
    }

    return new String(buf);
}

public static boolean containsIgnoreCaseAscii(String str, String searchStr) {
    return StringUtils.contains(lowerCaseAscii(str), lowerCaseAscii(searchStr));
}

Вы можете просто сделать что-то вроде этого:

String s1 = "AbBaCca";
String s2 = "bac";
String toLower = s1.toLowerCase();
return toLower.contains(s2);

import java.text.Normalizer;

import org.apache.commons.lang3.StringUtils;

public class ContainsIgnoreCase {

    public static void main(String[] args) {

        String in = "   Annulée ";
        String key = "annulee";

        // 100% java
        if (Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\p{InCombiningDiacriticalMarks}]", "").toLowerCase().contains(key)) {
            System.out.println("OK");
        } else {
            System.out.println("KO");
        }

        // use commons.lang lib
        if (StringUtils.containsIgnoreCase(Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\p{InCombiningDiacriticalMarks}]", ""), key)) {
            System.out.println("OK");
        } else {
            System.out.println("KO");
        }

    }

}

"AbCd".toLowerCase().contains("abcD".toLowerCase())

Мы можем использовать поток с anyMatch и содержать Java 8

public class Test2 {
    public static void main(String[] args) {

        String a = "Gina Gini Protijayi Soudipta";
        String b = "Gini";

        System.out.println(WordPresentOrNot(a, b));
    }// main

    private static boolean WordPresentOrNot(String a, String b) {
    //contains is case sensitive. That's why change it to upper or lower case. Then check
        // Here we are using stream with anyMatch
        boolean match = Arrays.stream(a.toLowerCase().split(" ")).anyMatch(b.toLowerCase()::contains);
        return match;
    }

}

Существует простой и краткий способ использования флага регулярного выражения (без учета регистра {i}):

 String s1 = "hello abc efg";
 String s2 = "ABC";
 s1.matches(".*(?i)"+s2+".*");

/*
 * .*  denotes every character except line break
 * (?i) denotes case insensitivity flag enabled for s2 (String)
 * */

или вы можете использовать простой подход и просто преобразовать регистр строки в регистр подстроки, а затем использовать метод contains.