3

这是我所拥有的方法lastIndexOf，ch是要匹配的字符，并且str是源字符串。

public static int lastIndexOf(char ch, String str) {
    // check for null string or empty string
    if (str.length() == 0 || str == null) {
        return -1;
    }

    int indexInRest = lastIndexOf(ch, str.substring(1));
    char first = str.charAt(0);

    // recursive call to find the last matching character
    if (first == ch) {
        return 1 + indexInRest; // this might not work properly
    } else
        return indexInRest;
}

如果在我班级的主要方法中我调用：

    System.out.println(lastIndexOf('r', "recurse"));
    System.out.println(lastIndexOf('p', "recurse"));

我有：

1
-1

期望的结果是：

4
-1

建议，请。

4

6 回答 6

3

这必须是功课，因为 API 中存在 String.lastIndexOf() ，因此编写此方法没有意义，并且使用递归执行此操作会很慢并且会占用大量内存。

这里提示一下。现在，您的算法正在从前面切掉字符（ substring(1) ）并比较它们。lastIndexOf() 应该首先删除字符串后面的字符以寻找匹配项，然后在找到匹配项时退出。

于 2012-09-27T15:08:24.707 回答
3

如何采用功能方法..

public static int lastIndexOf(char ch, String str) {
    if (str.charAt(str.length() - 1) == ch) { return str.length() -1; }
    if (str.length() <= 1) { return -1; }
    return lastIndexOf(ch, str.substring(0, str.length() - 1));
}
于 2012-09-27T15:09:33.647 回答
0

为什么不String.lastIndexOf这样使用：

str.lastIndexOf(ch)
于 2012-09-27T15:06:53.617 回答
0

使用String#lastIndexOf(int ch)实施作为一般准则，

public int lastIndexOf(int ch) {
    return lastIndexOf(ch, value.length - 1);
}

public int lastIndexOf(int ch, int fromIndex) {
    if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
        // handle most cases here (ch is a BMP code point or a
        // negative value (invalid code point))
        final char[] value = this.value;
        int i = Math.min(fromIndex, value.length - 1);
        for (; i >= 0; i--) {
            if (value[i] == ch) {
                return i;
            }
        }
        return -1;
    } else {
        return lastIndexOfSupplementary(ch, fromIndex);
    }
}

private int lastIndexOfSupplementary(int ch, int fromIndex) {
    if (Character.isValidCodePoint(ch)) {
        final char[] value = this.value;
        char hi = Character.highSurrogate(ch);
        char lo = Character.lowSurrogate(ch);
        int i = Math.min(fromIndex, value.length - 2);
        for (; i >= 0; i--) {
            if (value[i] == hi && value[i + 1] == lo) {
                return i;
            }
        }
    }
    return -1;
}

还有这个，

lastIndexOf(ch, value.length - 1);

value是作为字符数组的目标字符串。

于 2012-09-27T15:07:40.497 回答
0

首先，您应该更改为：

if (str == null || str.length() == 0) {

因为如果str是NPE 可以提高null

在您的代码中添加一个deep参数，如下所示：

public static int lastIndexOf(char ch, String str, int deep) {

并在每次递归调用时增加它的值 

int indexInRest = lastIndexOf(ch, str.substring(1), deep++);

然后，在返回语句中，将 deep 添加到返回值：

return 1 + indexInRest + deep; // this might not work properly

第一次调用函数deep = 0，或者更好的是，使两个参数lastIndexOf的方法调用 3 参数版本lastIndexOf的deep参数设置为 0

于 2012-09-27T15:08:22.163 回答
0

您还可以使用Matcher以预测作业要求的字符串分析的演变：

public int getlastMatch(String searchPattern,String textString) {
       int index = -1;
       Pattern pattern = Pattern.compile(searchPattern);
       Matcher matcher = pattern.matcher(textString);

       while(matcher.find()) {
               index = matcher.start();
       }
       return index;
   }

textString你关心的角色可能在哪里。

从而返回字符串中最后一次出现的字符串部分。

于 2012-09-27T15:09:07.717 回答