java - indexOf 区分大小写？

Question

indexOf(String) 方法是否区分大小写？如果是这样，是否有不区分大小写的版本？

score 79 · Accepted Answer

这些indexOf()方法都区分大小写。您可以通过预先将字符串转换为大写/小写来使它们（粗略地，以一种破碎的方式，但适用于很多情况）不区分大小写：

s1 = s1.toLowerCase(Locale.US);
s2 = s2.toLowerCase(Locale.US);
s1.indexOf(s2);

score 44 · Accepted Answer

indexOf(String) 方法是否区分大小写？

是的，它区分大小写：

@Test
public void indexOfIsCaseSensitive() {
    assertTrue("Hello World!".indexOf("Hello") != -1);
    assertTrue("Hello World!".indexOf("hello") == -1);
}

如果是这样，是否有不区分大小写的版本？

不，没有。您可以在调用 indexOf 之前将两个字符串都转换为小写：

@Test
public void caseInsensitiveIndexOf() {
    assertTrue("Hello World!".toLowerCase().indexOf("Hello".toLowerCase()) != -1);
    assertTrue("Hello World!".toLowerCase().indexOf("hello".toLowerCase()) != -1);
}

score 20 · Accepted Answer

Apache Commons Lang 库的 StringUtils 类中有一个忽略大小写的方法

indexOfIgnoreCase(CharSequence str, CharSequence searchStr)

score 17 · Accepted Answer

是的，indexOf区分大小写。

我发现不区分大小写的最佳方法是：

String original;
int idx = original.toLowerCase().indexOf(someStr.toLowerCase());

那将不区分大小写indexOf()。

score 14 · Accepted Answer

这是我的解决方案，它不分配任何堆内存，因此它应该比这里提到的大多数其他实现要快得多。

public static int indexOfIgnoreCase(final String haystack,
                                    final String needle) {
    if (needle.isEmpty() || haystack.isEmpty()) {
        // Fallback to legacy behavior.
        return haystack.indexOf(needle);
    }

    for (int i = 0; i < haystack.length(); ++i) {
        // Early out, if possible.
        if (i + needle.length() > haystack.length()) {
            return -1;
        }

        // Attempt to match substring starting at position i of haystack.
        int j = 0;
        int ii = i;
        while (ii < haystack.length() && j < needle.length()) {
            char c = Character.toLowerCase(haystack.charAt(ii));
            char c2 = Character.toLowerCase(needle.charAt(j));
            if (c != c2) {
                break;
            }
            j++;
            ii++;
        }
        // Walked all the way to the end of the needle, return the start
        // position that this was found.
        if (j == needle.length()) {
            return i;
        }
    }

    return -1;
}

这是验证正确行为的单元测试。

@Test
public void testIndexOfIgnoreCase() {
    assertThat(StringUtils.indexOfIgnoreCase("A", "A"), is(0));
    assertThat(StringUtils.indexOfIgnoreCase("a", "A"), is(0));
    assertThat(StringUtils.indexOfIgnoreCase("A", "a"), is(0));
    assertThat(StringUtils.indexOfIgnoreCase("a", "a"), is(0));

    assertThat(StringUtils.indexOfIgnoreCase("a", "ba"), is(-1));
    assertThat(StringUtils.indexOfIgnoreCase("ba", "a"), is(1));

    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", " Royal Blue"), is(-1));
    assertThat(StringUtils.indexOfIgnoreCase(" Royal Blue", "Royal Blue"), is(1));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "royal"), is(0));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "oyal"), is(1));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "al"), is(3));
    assertThat(StringUtils.indexOfIgnoreCase("", "royal"), is(-1));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", ""), is(0));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "BLUE"), is(6));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "BIGLONGSTRING"), is(-1));
    assertThat(StringUtils.indexOfIgnoreCase("Royal Blue", "Royal Blue LONGSTRING"), is(-1));  
}

score 11 · Accepted Answer

是的，它区分大小写。您可以通过在搜索之前将 String 和 String 参数都转换为大写来做到不区分大小写indexOf。

String str = "Hello world";
String search = "hello";
str.toUpperCase().indexOf(search.toUpperCase());

请注意，toUpperCase 在某些情况下可能不起作用。例如这个：

String str = "Feldbergstraße 23, Mainz";
String find = "mainz";
int idxU = str.toUpperCase().indexOf (find.toUpperCase ());
int idxL = str.toLowerCase().indexOf (find.toLowerCase ());

idxU 将是 20，这是错误的！idxL 将是 19，这是正确的。导致问题的原因是 toUpperCase() 将“ß”字符转换为两个字符“SS”，这会抛出索引。

因此，始终坚持使用 toLowerCase()

score 3 · Accepted Answer

一旦返回索引值，您将如何处理？

如果您使用它来操作您的字符串，那么您可以不使用正则表达式吗？

import static org.junit.Assert.assertEquals;    
import org.junit.Test;

public class StringIndexOfRegexpTest {

    @Test
    public void testNastyIndexOfBasedReplace() {
        final String source = "Hello World";
        final int index = source.toLowerCase().indexOf("hello".toLowerCase());
        final String target = "Hi".concat(source.substring(index
                + "hello".length(), source.length()));
        assertEquals("Hi World", target);
    }

    @Test
    public void testSimpleRegexpBasedReplace() {
        final String source = "Hello World";
        final String target = source.replaceFirst("(?i)hello", "Hi");
        assertEquals("Hi World", target);
    }
}

score 2 · Accepted Answer

@Test
public void testIndexofCaseSensitive() {
    TestCase.assertEquals(-1, "abcDef".indexOf("d") );
}

score 2 · Accepted Answer

是的，我相当肯定它是。使用标准库解决该问题的一种方法是：

int index = str.toUpperCase().indexOf("FOO");

score 2 · Accepted Answer

2

我刚刚看了源码。它比较字符，因此区分大小写。

于 2009-07-14T15:41:51.957 回答

score 2 · Accepted Answer

有同样的问题。我尝试了正则表达式和apache StringUtils.indexOfIgnoreCase-Method，但两者都很慢......所以我自己写了一个简短的方法......：

public static int indexOfIgnoreCase(final String chkstr, final String searchStr, int i) {
    if (chkstr != null && searchStr != null && i > -1) {
          int serchStrLength = searchStr.length();
          char[] searchCharLc = new char[serchStrLength];
          char[] searchCharUc = new char[serchStrLength];
          searchStr.toUpperCase().getChars(0, serchStrLength, searchCharUc, 0);
          searchStr.toLowerCase().getChars(0, serchStrLength, searchCharLc, 0);
          int j = 0;
          for (int checkStrLength = chkstr.length(); i < checkStrLength; i++) {
                char charAt = chkstr.charAt(i);
                if (charAt == searchCharLc[j] || charAt == searchCharUc[j]) {
                     if (++j == serchStrLength) {
                           return i - j + 1;
                     }
                } else { // faster than: else if (j != 0) {
                         i = i - j;
                         j = 0;
                    }
              }
        }
        return -1;
  }

根据我的测试，它的速度要快得多......（至少如果你的 searchString 很短）。如果您有任何改进建议或错误，很高兴让我知道...（因为我在应用程序中使用此代码；-）

score 1 · Accepted Answer

总结一下，3个解决方案：

使用 toLowerCase() 或 toUpperCase
使用 apache 的 StringUtils
使用正则表达式

现在，我想知道哪个是最快的？我猜平均是第一个。

score 1 · Accepted Answer

第一个问题已经回答了很多次了。是的，这些String.indexOf()方法都是区分大小写的。

如果您需要对语言环境敏感indexOf()，您可以使用Collator。根据您设置的强度值，您可以获得不区分大小写的比较，并将重音字母视为与非重音字母相同，等等。以下是如何执行此操作的示例：

private int indexOf(String original, String search) {
    Collator collator = Collator.getInstance();
    collator.setStrength(Collator.PRIMARY);
    for (int i = 0; i <= original.length() - search.length(); i++) {
        if (collator.equals(search, original.substring(i, i + search.length()))) {
            return i;
        }
    }
    return -1;
}

score 1 · Accepted Answer

我想声明 ONE 并且是迄今为止发布的唯一真正有效的解决方案。:-)

必须处理的三类问题。

小写和大写的非传递匹配规则。土耳其语 I 问题在其他回复中经常被提及。根据 String.regionMatches 的 Android 源代码中的评论，格鲁吉亚比较规则在比较不区分大小写的相等时需要额外转换为小写。
大写和小写形式的字母数量不同的情况。在这些情况下，到目前为止发布的几乎所有解决方案都失败了。示例：德语 STRASSE 与 Straße 具有不区分大小写的相等性，但长度不同。
重音字符的结合强度。无论重音是否匹配，区域设置和上下文都会产生影响。在法语中，“é”的大写形式是“E”，尽管有使用大写重音的趋势。在加拿大法语中，“é”的大写形式是“É”，无一例外。这两个国家的用户在搜索时都希望“e”与“é”匹配。重音字符和非重音字符是否匹配是特定于语言环境的。现在考虑：“E”是否等于“É”？是的。确实如此。无论如何，在法语语言环境中。

我目前正在使用android.icu.text.StringSearch正确实现不区分大小写的 indexOf 操作的先前实现。

非 Android 用户可以使用com.ibm.icu.text.StringSearch类通过 ICU4J 包访问相同的功能。

请注意在正确的 icu 包 (android.icu.text或com.ibm.icu.text) 中引用类，因为 Android 和 JRE 在其他命名空间（例如 Collator）中都有同名的类。

    this.collator = (RuleBasedCollator)Collator.getInstance(locale);
    this.collator.setStrength(Collator.PRIMARY);

    ....

    StringSearch search = new StringSearch(
         pattern,
         new StringCharacterIterator(targetText),
         collator);
    int index = search.first();
    if (index != SearchString.DONE)
    {
        // remember that the match length may NOT equal the pattern length.
        length = search.getMatchLength();
        .... 
    }

测试用例（语言环境、模式、目标文本、预期结果）：

    testMatch(Locale.US,"AbCde","aBcDe",true);
    testMatch(Locale.US,"éèê","EEE",true);

    testMatch(Locale.GERMAN,"STRASSE","Straße",true);
    testMatch(Locale.FRENCH,"éèê","EEE",true);
    testMatch(Locale.FRENCH,"EEE","éèê",true);
    testMatch(Locale.FRENCH,"éèê","ÉÈÊ",true);

    testMatch(new Locale("tr-TR"),"TITLE","tıtle",true);  // Turkish dotless I/i
    testMatch(new Locale("tr-TR"),"TİTLE","title",true);  // Turkish dotted I/i
    testMatch(new Locale("tr-TR"),"TITLE","title",false);  // Dotless-I != dotted i.

PS：尽我所能确定，当特定于语言环境的规则根据字典规则区分重音字符和非重音字符时，PRIMARY 绑定强度应该做正确的事情；但我不知道使用哪个语言环境来测试这个前提。捐赠的测试用例将不胜感激。

--

score 0 · Accepted Answer

但是不难写一个：

public class CaseInsensitiveIndexOfTest extends TestCase {
    public void testOne() throws Exception {
        assertEquals(2, caseInsensitiveIndexOf("ABC", "xxabcdef"));
    }

    public static int caseInsensitiveIndexOf(String substring, String string) {
        return string.toLowerCase().indexOf(substring.toLowerCase());
    }
}

score 0 · Accepted Answer

将两个字符串都转换为小写通常没什么大不了的，但如果某些字符串很长，它会很慢。如果你在一个循环中这样做，那将是非常糟糕的。出于这个原因，我会推荐indexOfIgnoreCase.

score 0 · Accepted Answer

 static string Search(string factMessage, string b)
        {

            int index = factMessage.IndexOf(b, StringComparison.CurrentCultureIgnoreCase);
            string line = null;
            int i = index;
            if (i == -1)
            { return "not matched"; }
            else
            {
                while (factMessage[i] != ' ')
                {
                    line = line + factMessage[i];
                    i++;
                }

                return line;
            }

        }

score 0 · Accepted Answer

这是一个与 Apache 的 StringUtils 版本非常相似的版本：

public int indexOfIgnoreCase(String str, String searchStr) {
    return indexOfIgnoreCase(str, searchStr, 0);
}

public int indexOfIgnoreCase(String str, String searchStr, int fromIndex) {
    // https://stackoverflow.com/questions/14018478/string-contains-ignore-case/14018511
    if(str == null || searchStr == null) return -1;
    if (searchStr.length() == 0) return fromIndex;  // empty string found; use same behavior as Apache StringUtils
    final int endLimit = str.length() - searchStr.length() + 1;
    for (int i = fromIndex; i < endLimit; i++) {
        if (str.regionMatches(true, i, searchStr, 0, searchStr.length())) return i;
    }
    return -1;
}

score -2 · Accepted Answer

indexOf 区分大小写。这是因为它使用 equals 方法来比较列表中的元素。包含和删除也是如此。

java - indexOf 区分大小写？

19 回答 19

Related

Reference