Question

我正在阅读String.class的源代码在方法indexOf()中，我看到了一些我无法理解的东西以下是来自indexOf()源代码的方法String.class代码段。

/**
 * Code shared by String and StringBuffer to do searches. The
 * source is the character array being searched, and the target
 * is the string being searched for.
 *
 * @param   source       the characters being searched.
 * @param   sourceOffset offset of the source string.
 * @param   sourceCount  count of the source string.
 * @param   target       the characters being searched for.
 * @param   targetOffset offset of the target string.
 * @param   targetCount  count of the target string.
 * @param   fromIndex    the index to begin searching from.
 */
static int indexOf(char[] source, int sourceOffset, int sourceCount,
        char[] target, int targetOffset, int targetCount,
        int fromIndex) {
    if (fromIndex >= sourceCount) {
        return (targetCount == 0 ? sourceCount : -1);
    }
    if (fromIndex < 0) {
        fromIndex = 0;
    }
    if (targetCount == 0) {
        return fromIndex;
    }

    char first = target[targetOffset];
    int max = sourceOffset + (sourceCount - targetCount);

    for (int i = sourceOffset + fromIndex; i <= max; i++) {
        /* Look for first character. */
        if (source[i] != first) {
            while (++i <= max && source[i] != first);
        }

        /* Found first character, now look at the rest of v2 */
        if (i <= max) {
            int j = i + 1;
            int end = j + targetCount - 1;
            for (int k = targetOffset + 1; j < end && source[j]
                    == target[k]; j++, k++);

            if (j == end) {
                /* Found whole string. */
                return i - sourceOffset;
            }
        }
    }
    return -1;
}

我无法理解这里的代码。

if (fromIndex >= sourceCount) {
    return (targetCount == 0 ? sourceCount : -1);
}

如果source String为"abcdedefg"，sourceOffset为2，则sourceCount为3，我想搜索＆＃34; d＆＃34;由此，为什么我不能从索引4中搜索？ / **
* Ps：如果sourceCount表示整个字符串的长度，为什么不使用source.length
*而不是？
* /

Answer 1

此方法接受两个字符数组 - source数组是正在搜索的数组，target数组是搜索的数组。

但是，offset和count变量将搜索范围限制为source的子数组和target的子数组。

基本上，您正在从source[sourceOffSet]到source[sourceOffset+sourceCount-1]的子数组中搜索由String到{{1}的子数组中的字符组成的target[targetOffSet] }}

这是一个例子。搜索的相关数组是子数组：

target[targetOffset+targetCount-1]

但是，通过提供source array : |--------------------| sub array : |-------| source source offset offset + source count - 1 target array : |--------------------| sub array : |-------| target target offset offset + target count - 1进一步限制了搜索。您可以从fromIndex子阵列的fromIndex＆＃39;索引开始搜索。

由于source子阵列的长度为source，如果sourceCount，则无法找到fromIndex >= sourceCount子阵列，因此除非{{1}子数组为空（即target），返回target。

让我们考虑你的例子：

targetCount == 0

这些参数意味着您要在源子字符串-1中搜索从索引source : "abcdedefg" sourceOffset : 2 sourceCount : 3 target : "d" targetOffset : 0 targetCount : 1 fromIndex : 4开始的目标子字符串"cde"。但是，"d"中没有索引4，因此会返回4。

关于你的

Ps：如果sourceCount表示整个字符串的长度，为什么不使用source.length

正如我所解释的那样"cde"并不意味着整个-1数组的长度，只是被搜索的子数组的长度。

请注意，当您致电sourceCount时，系统会使用以下参数调用您询问的source方法：

someString.indexOf(str,fromIndex)

在这种情况下，static等于public int indexOf(String str, int fromIndex) { return indexOf(value, 0, value.length, str.value, 0, str.value.length, fromIndex); }（即从sourceCount开始搜索整个source.length数组。

Answer 2

    if (fromIndex >= sourceCount) {
        return (targetCount == 0 ? sourceCount : -1);
    }

这表示搜索索引（fromIndex）在结尾之后是字符串长度（sourceCount），然后返回-1（未找到），除非搜索到的字符串是{{ 1}} - 这是“永远找到的”。非常具体。

为什么代码以这种方式写入String.class中的方法indexOf（）？

2 个答案: