Чувствительный к регистру indexOf?

Да, регистр учитывается. Вы можете выполнить indexOf без учета регистра, преобразовав строку и параметр String в верхний регистр перед поиском.

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 ()

Но написать одно несложно:

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

indexOf чувствителен к регистру. Это потому, что он использует метод equals для сравнения элементов в списке. То же самое касается "содержит" и "удалить".

Да, я совершенно уверен, что это так. Один из способов решения этой проблемы с использованием стандартной библиотеки:

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

Я только что посмотрел исходник. Он сравнивает символы, поэтому он чувствителен к регистру.

Учитывает ли регистр метод 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);
}

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

Что вы делаете с возвращенным значением индекса?

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

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

Да, indexOf чувствителен к регистру.

Я нашел лучший способ сделать регистр нечувствительным:

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

Это сделает регистронезависимый indexOf () .