递归在Java中以意外的方式运行

我是一名学生，我一直致力于以下挑战：在更大的字符串（草堆）中找到子字符串（针），而不使用

substring

方法，也不使用递归。递归不是我的强项，但我已经解决了以下问题：

public class Contains
{
    public static void main(String[] args)
    {
        System.out.println(contains("Java programming", "ogr", false));
    }

    public static boolean contains(String haystack, String needle, boolean doesContain)
    {
        if(haystack.length() < needle.length())
        {
            return false;
        }
        else
        {
            for(int i = 0; i < needle.length(); i++)
            {
                if(haystack.charAt(i) != needle.charAt(i))
                    if((i + 1) == needle.length())
                        {
                            doesContain = false;
                            break;
                        }
                    else
                        break;
                else
                    if((i + 1) == needle.length())
                    {
                        doesContain = true;
                        break;
                    }
                    else
                        continue;
            }
            char[] haystackChar = haystack.toCharArray();
            char[] newCharArray = new char[(haystackChar.length - 1)];

            for(int j = 1; j < haystackChar.length; j++)
            {
                newCharArray[j - 1] = haystackChar[j];
            }

            String newStr = new String(newCharArray);

            if(doesContain == false)
                contains(newStr, needle, doesContain);
        }
        return doesContain;
    }
}

公共类包含
{
公共静态void main（字符串[]args）
{
println（包含（“Java编程”、“ogr”、false））；
}
公共静态布尔包含（字符串干草堆、字符串针、布尔doesContain）
{
if（haystack.length（）

我意识到这可能不是最好或最优雅的解决方案，但我主要只是想让它发挥作用。我一直在Eclipse调试器中运行它，直到调用

if（doesContain==false）

方法调用

contain

期间调用

doesContain

在for循环的迭代期间将

doesContain

设置为true之前，一切都按预期运行。调试器正在将

doesContain

的值显示为（正确）true，并显示它跳过if语句并退出else块。但是，紧接着，它跳回else块，只调用对

contain

的递归调用，而不是返回

doesContain

。然后，它继续递归工作，随后失败并返回false，因为它现在正在搜索字符串的其余部分，而“指针”不在其中

---

我知道StackOverflow本身并不是一个“家庭作业帮助”的位置，但我编程的目的不是学校，我很困惑为什么它会这样。有人知道它为什么这样做吗？我在这里遗漏了什么吗？

要以您想要的方式在

大草堆中找到
针
，您不需要使用递归

只需从函数中删除以下代码行，即可正常工作：

        char[] haystackChar = haystack.toCharArray();
        char[] newCharArray = new char[(haystackChar.length - 1)];

        for(int j = 1; j < haystackChar.length; j++)
        {
            newCharArray[j - 1] = haystackChar[j];
        }

        String newStr = new String(newCharArray);

        if(doesContain == false)
            contains(newStr, needle, doesContain);

char[]haystackChar=haystack.tocharray（）；
char[]newCharArray=new char[（haystackChar.length-1）]；
对于（int j=1；j
我想你有点把自己和递归函数搞混了。传递给递归函数的变量之一是
doesContain
，但函数应该返回字符串是否包含它！排队

        if(doesContain == false)
            contains(newStr, needle, doesContain);

如果子字符串包含指针，则对
contains
的调用将返回。您需要获取该值，并将其返回到调用堆栈中

希望这有点道理。如果没有，我会给你代码，让你自己去弄清楚：

public static boolean contains(String haystack, String needle)
{
    if(haystack.length() < needle.length())
    {
        return false;
    }
    else
    {
        boolean doesContain=false;
        for(int i = 0; i < needle.length(); i++)
        {
            if(haystack.charAt(i) != needle.charAt(i))
                if((i + 1) == needle.length())
                    {
                        doesContain = false;
                        break;
                    }
                else
                    break;
            else
                if((i + 1) == needle.length())
                {
                    doesContain = true;
                    break;
                }
                else
                    continue;
        }
        char[] haystackChar = haystack.toCharArray();
        char[] newCharArray = new char[(haystackChar.length - 1)];

        for(int j = 1; j < haystackChar.length; j++)
        {
            newCharArray[j - 1] = haystackChar[j];
        }

        String newStr = new String(newCharArray);

        if(doesContain == false)
            return contains(newStr, needle);
        else
            return true;
    }
}

公共静态布尔包含（字符串草堆、字符串针）
{
if（haystack.length（）
我查看了您的代码，并亲自在eclipse中运行了它。您将要研究的一个理论是在递归中堆栈是如何工作的。您的程序正在找到true，然后离开堆栈，但到那时它已经重复出现了好几次。它返回true，但随后还返回了之前存储的所有false变量

如果你还有任何问题，请告诉我

编辑
如果你真的对高级递归感兴趣，我强烈推荐这段视频：

嘿，我不需要走那么远就能成功。您可以将doesContain作为参数删除，并将其设置为静态实例变量，这对我很有用

public class Contains
{

    private static boolean doesContain = false;

    public static void main(String[] args)
    {
        System.out.println(contains("Java programming", "ogr"));
    }

    public static boolean contains(String haystack, String needle)
    {
        if(haystack.length() < needle.length())
        {
            return false;
        }
        else
        {
            for(int i = 0; i < needle.length(); i++)
            {
                if(haystack.charAt(i) != needle.charAt(i))
                    if((i + 1) == needle.length())
                        {
                            doesContain = false;
                            break;
                        }
                    else
                        break;
                else
                    if((i + 1) == needle.length())
                    {
                        doesContain = true;
                        break;
                    }
                    else
                        continue;
            }
            char[] haystackChar = haystack.toCharArray();
            char[] newCharArray = new char[(haystackChar.length - 1)];

            for(int j = 1; j < haystackChar.length; j++)
            {
                newCharArray[j - 1] = haystackChar[j];
            }

            String newStr = new String(newCharArray);

            if(doesContain == false)
                contains(newStr, needle);
        }
        return doesContain;
   }
}

公共类包含
{
私家侦探