如何在不使用Java中内置方法.endsWith（）的情况下实现String.endsWith（）

Question

我正在尝试不使用内置方法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()方法的最佳方法是什么？

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

Answer 1

一种方式是这样的：

• 检查suffix <= str 。
• 使用substring()获得str的最后n字符，其中n = suffix.length() substring() 。
• 将字符串的该部分与带有equals()或equalsIgnoreCase() suffix进行比较。

Answer 2

    return str.length() >= suffix.length() && str.substring(str.length() - suffix.length()) == suffix;

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

Answer 3

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

Answer 4

    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
    }

Answer 5

这是我要做的：

1. 反转输入字符串
2. 反转后缀String
3. 检查输出1.是否为String.startsWith 2。

Answer 6

您可以尝试字符串的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;

}

Answer 7

尝试以下方法。

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

Answer 8

由于您正在尝试重新发明轮子以弄清楚轮子的工作原理（这不是一件坏事！），所以使用substring + equals似乎有点作弊，不是吗？ 为什么不直接执行检查，而不是将检查传递给equals ？

基本思想是比较每个字符串的最后一个字符，然后比较倒数第二个，然后比较倒数第三个，依此类推。如果比较不相等，则可以返回false。 否则，您可以返回true。 换句话说，您将两个字符串逐个字符配对； 而不是问这些对是否全部相等，而是要问它们是否不相等。

---

给定一个int i ，您可以通过stringLength - 1 - i获得“从右数第i个索引”。 例如，最后一位是stringLength - 1 ，倒数第二位是stringLength - 2 ， stringLength - 2 。因此：

1. 检查后缀是否长于str 。 如果是，则可以return false
2. 让i代表我们要看的右边的几个字符
3. 创建一个循环，该循环将在后缀内从右侧查看所有第i个字符： for(int i = 0; i < suffix.length(); ++i)
4. 在每次迭代中，从两个字符串的右侧获取第i -ith个字符，如上所述
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)甚至更低，这将引发异常！ 还有其他方法可以解决此问题，但是我将由您自己找到它们。 :)