Question

我需要编写将其他字符串上的“String str”写入的方法，并返回str开始的索引。

这听起来像是家庭作业，这是一些家庭作业，但我习惯于学习测试......

我试过了：

public int IndexOf (String str) {

   for (i= 0;i<_st.length();i++)
   {
        if (_st.charAt(i) == str.charAt(i)) {
            i++;
            if (_st.charAt(i) == str.charAt(i)) {
                return i;
            }
        }
   }
   return -1;
 }

但我得不到正确的回报。为什么？我是在正确的方式还是甚至没有关闭？

Answer 1

我很害怕，你并不亲近。

以下是您必须做的事情：

循环播放字符串的字符（ on on ，你应该做indexOf，我会称之为 master ）（你这是对的）

对于每个字符，检查您的其他字符串的字符和此字符是否相同。

如果它们是（同一序列的潜在开始），请检查master中的下一个字符是否与要检查的String匹配（您可能希望循环遍历字符串的元素并逐个检查）。

如果不匹配，请继续使用主字符串中的字符

类似的东西：

Loop master string for every character (using index i, lets say) check whether this is same as first character of the other string if it is //potential match loop through the characters in the child string (lets say using index j) match them with the consecutive characters in the master string (something like master[j+i] == sub[j]) If everything match, 'i' is what you want otherwise, continue with the master, hoping you find a match

其他一些观点：

在java中，方法名称以a开头 约定的小写字母 （意思是，编译器不会抱怨，但你的同事们可以）。所以IndexOf实际应该是 indexOf

拥有实例变量（类级变量）以a开头 _（如_st中所述）不是很好实践。如果你的教授坚持，你可能没有很多选择，但是记住这一点）

Answer 2

不是很亲密，我很害怕。该代码基本上做的是检查两个字符串是否在任何点的相同位置有两个字符，如果是，则返回第二个字符的索引。例如，如果_str是“abcdefg”并且str是“12cd45”，那么你将返回3，因为它们在同一个地方有“cd”，那就是“d”的索引。至少，这就像我能说出它实际上在做什么一样。那是因为你使用相同的索引变量索引到两个字符串。

要重新撰写indexOf，在str内查找_st，您必须扫描_st str中的第一个字符，然后检查是否剩下的字符匹配;如果没有，请从您开始检查的位置前进一个位置并继续扫描。（你可以做一些优化，但这就是它的本质。）例如，如果你在str中的索引4处找到_st的第一个字符而str是六个字符很久，找到了你需要看到的第一个字符，剩下的五个（str的索引是否包含1-5个）与_st的索引是否匹配5-10（最容易检查所有六个） str的字符串从_st的子字符串开始，从4开始，然后是6个charactesr）。如果一切都匹配，则返回找到第一个字符的索引（因此，在该示例中为4）。您可以在_st.length() - str.length()停止扫描，因为如果您在此之前没有找到它，则根本不会找到它。

侧点：不要在每个循环上调用length函数。 JIT 可以能够优化呼叫，但如果您知道_st在此功能的过程中不会改变（如果您不知道，那么您应该要求它，抓住length()到当地，然后参考。当然，既然你知道你可以在length()之前停止，那么你可以使用当地人来记住你可以停下的地方。

Answer 3

你正在使用i两个字符串相等，但是你想要的是第一个始终从0开始的字符串，除非找到该字符是另一个字符串。然后检查下一个字符是否相等，等等。

希望这有帮助

Answer 4

你的代码循环遍历被搜索的字符串，如果位置i的字符匹配，它会检查下一个位置。如果字符串在下一个位置匹配，则假定字符串str包含在_st中。

您可能想要做的是：

跟踪_st中是否包含整个str。您可以检查您要搜索的字符串的长度是否等于到目前为止匹配的字符数。
如果您执行上述操作，那么您可以通过从当前i值中减去匹配数来获得起始索引。

一个问题：

为什么不使用内置的String.IndexOf（）函数？这项任务是否意味着您可以自己实现此功能？

Answer 5

也许Oracle Java API源代码确实有帮助：

   /**
     * Returns the index within this string of the first occurrence of the
     * specified substring. The integer returned is the smallest value
     * <i>k</i> such that:
     * <blockquote><pre>
     * this.startsWith(str, <i>k</i>)
     * </pre></blockquote>
     * is <code>true</code>.
     *
     * @param   str   any string.
     * @return  if the string argument occurs as a substring within this
     *          object, then the index of the first character of the first
     *          such substring is returned; if it does not occur as a
     *          substring, <code>-1</code> is returned.
     */
    public int indexOf(String str) {
    return indexOf(str, 0);
    }

    /**
     * Returns the index within this string of the first occurrence of the
     * specified substring, starting at the specified index.  The integer
     * returned is the smallest value <tt>k</tt> for which:
     * <blockquote><pre>
     *     k &gt;= Math.min(fromIndex, this.length()) && this.startsWith(str, k)
     * </pre></blockquote>
     * If no such value of <i>k</i> exists, then -1 is returned.
     *
     * @param   str         the substring for which to search.
     * @param   fromIndex   the index from which to start the search.
     * @return  the index within this string of the first occurrence of the
     *          specified substring, starting at the specified index.
     */
    public int indexOf(String str, int fromIndex) {
        return indexOf(value, offset, count,
                       str.value, str.offset, str.count, fromIndex);
    }

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

indexOf（String str） - 将字符串等于其他字符串

5 个答案: