Question

以下是方法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

建议，请。

Answer 1

这必须是功课，因为编写这个方法是没有意义的，因为API中存在String.lastIndexOf（），并且使用递归来做这个会变慢并且使用大量内存。

这里有一个提示。现在你的算法正在砍掉前面的字符（substring（1））并比较它们。 lastIndexOf（）应该首先删除字符串后面的字符，然后在找到匹配项时退出。

Answer 2

如何采用功能性方法..

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

Answer 3

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

str.lastIndexOf(ch)

Answer 4

使用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是目标String作为字符数组。

Answer 5

首先，您应该更改为：

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

因为如果str为null

，NPE可能会提高

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

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

每次递归调用增加其值

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

然后，在返回句子中，添加深度到您返回的值：

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

第一次使用deep = 0调用该函数，或者更好的是，使用lastIndexOf参数集调用lastIndexOf的3参数版本{参数}到0

Answer 6

您还可以使用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可能是您关注的角色。

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

java recursion查找字符串中字符的最后一个索引

6 个答案: