1

我正在尝试在String.endsWith()不使用内置方法的情况下实现方法String.endsWith()。

这是我的代码：

public static boolean endsWithSuffix(String str, String suffix) {
    char[] chStr = str.toCharArray();
    char[] chSuf = suffix.toCharArray();

    if(!str.contains(suffix) {
        return false;
    }
    return true;
}

endsWith()在不使用内置方法的情况下实现该方法的最佳方法是什么？

我一直在尝试使用字符数组，但还没有运气。字符串会更容易吗？

4

8 回答 8

2

一种方法是这样的：

  • 检查是否suffix <= str。
  • 使用. 获取where的最后一个n字符。strn = suffix.length()substring()
  • 将该部分字符串与suffixwithequals()或进行比较equalsIgnoreCase()。
于 2013-04-16T00:44:53.230 回答
2 
    return str.length() >= suffix.length() && str.substring(str.length() - suffix.length()) == suffix;

你可以使用 .equals 但你必须添加无效检查然后

于 2013-04-16T00:46:54.413 回答
2 
public static boolean endsWith(String test, String suffix) {

    int start = test.length() - suffix.length();
    if (start >= 0) {
        return test.indexOf(suffix, start) >= 0;
    }
    return false;
}

public static void main(String... args) {

    System.out.println(endsWith("aaabbbccc", "aaa"));
    System.out.println(endsWith("aaabbbccc", "bbb"));
    System.out.println(endsWith("aaabbbccc", "ccc"));
    System.out.println(endsWith("Hello Java", "Java"));
}

输出

false
false
true
true
于 2013-04-16T00:47:35.887 回答
2 
    public static boolean endsWith(String str, String suffix){  
        return (str.lastIndexOf(suffix) == str.length() - suffix.length()); 
    }  

    public static void main(String[] args) {
        System.out.println(endsWith("this is a test", "test")); //True
        System.out.println(endsWith("This is another test", "test2"));  //False
    }
于 2013-04-16T00:47:54.520 回答
1

这是我要做的：

  1. 反转输入字符串
  2. 反转后缀字符串
  3. 检查1String.startsWith的输出。2的输出。
于 2013-04-16T00:44:25.497 回答
1

您可以尝试字符串的 Substring 方法

public static boolean endsWithSuffix(String str, String suffix) 
{
int a,b;
a=str.length();
b=suffix.length();
if (str.subString(b-a,a).equals(suffix))
   return true;
else 
   return false;

}

于 2013-04-16T00:49:42.533 回答
1

试试下面的。

public static boolean endsWithSuffix(String str, String suffix)     
    int offset = str.length - suffix.length();
    if (offset >= 0) {
        String temp = str.substring(offset, str.length() - 1);
        if (suffix.equals(temp)) {
            return true;
        }
    }
    return false;
}
于 2013-04-16T00:53:52.157 回答
1

由于您试图重新发明轮子以弄清楚轮子是如何工作的（这不是一件坏事！），使用 substring + 似乎有点作弊equals，不是吗？为什么不直接实施检查，而不是将其传递给equals?

基本思想是比较每个字符串的最后一个字符，然后是倒数第二个字符，然后是倒数第三个字符，等等。如果你得到一个不相等的比较，你可以返回 false。否则，您可以返回 true。换句话说，您将两个字符串逐个字符配对；而不是询问这些对是否都相等，而是询问它们中的任何一个是否不相等。

给定一个 int i，您可以通过. 例如，最后一个数字是，倒数第二个是，等等。所以：stringLength - 1 - istringLength - 1stringLength - 2

  1. 检查后缀是否长于str. 如果是的话，你可以return false
  2. 让我们i代表我们想看的右边有多少个字符
  3. 创建一个循环，从后缀的右侧开始查看所有i -ith 字符：for(int i = 0; i < suffix.length(); ++i)
  4. 在每次迭代中，从两个字符串的右侧获取第i个字符，如上所述
  5. 如果它们不相等，return false. 如果它们相等，则继续下一次迭代
  6. 如果你已经用尽了所有的字符suffix（即，如果循环结束），则返回 true。

把它们放在一起：

public static boolean endsWithSuffix(String str, String suffix) {
    int strLen = str.length();
    int suffixLen = suffix.length();

    if (suffixLen > strLen)
        return false;
    for (int i = 0; i < suffixLen; ++i) {
        char strChar = str.charAt(strLen - 1 - i);
        char suffixChar = suffix.charAt(suffixLen - 1 - i);
        if (strChar != suffixChar)
            return false
    }
    return true
}

的初始检查suffixLen > strLen不仅仅是一种优化——它是正确性所必需的。否则，如果后缀比 str 长，那么循环将走得足够远，以至于您会要求str.charAt(-1)甚至更低，这将引发异常！还有其他方法可以解决这个问题，但我会让你找到它们。:)

于 2013-04-16T02:05:15.340 回答