Java 使用递归反转字符串

谁能解释一下为什么“returnstr”行从不执行

public static String reverseString(String str){
    String reverse="";
    if(str.length() == 1){
        return str; //at one point this condition will be true, but value never returns
    } else {
        reverse += str.charAt(str.length()-1) + reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

public static void main(String a[]) {
    System.out.println(reverseString("Test"));
}

---

行执行，你怎么能说它不执行。我添加了syso语句，它确实会打印，实际上您正在递归中调用

子字符串

，一旦长度变为1，它就会执行

public static String reverseString(String str) {
        String reverse = "";
        if (str.length() == 1) {
            System.out.println("hi");
            return str; // at one point this condition will be true, but value never returns
        } else {
            reverse += str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1));
            return reverse;
        }
    }

    public static void main(String a[]) {
        System.out.println(reverseString("Test"));
    }

输出

hi
tseT

---

行执行，你怎么能说它不执行。我添加了syso语句，它确实会打印，实际上您正在递归中调用

子字符串

，一旦长度变为1，它就会执行

public static String reverseString(String str) {
        String reverse = "";
        if (str.length() == 1) {
            System.out.println("hi");
            return str; // at one point this condition will be true, but value never returns
        } else {
            reverse += str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1));
            return reverse;
        }
    }

    public static void main(String a[]) {
        System.out.println(reverseString("Test"));
    }

输出

hi
tseT

---

行执行，你怎么能说它不执行。我添加了syso语句，它确实会打印，实际上您正在递归中调用

子字符串

，一旦长度变为1，它就会执行

public static String reverseString(String str) {
        String reverse = "";
        if (str.length() == 1) {
            System.out.println("hi");
            return str; // at one point this condition will be true, but value never returns
        } else {
            reverse += str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1));
            return reverse;
        }
    }

    public static void main(String a[]) {
        System.out.println(reverseString("Test"));
    }

输出

hi
tseT

---

行执行，你怎么能说它不执行。我添加了syso语句，它确实会打印，实际上您正在递归中调用

子字符串

，一旦长度变为1，它就会执行

public static String reverseString(String str) {
        String reverse = "";
        if (str.length() == 1) {
            System.out.println("hi");
            return str; // at one point this condition will be true, but value never returns
        } else {
            reverse += str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1));
            return reverse;
        }
    }

    public static void main(String a[]) {
        System.out.println(reverseString("Test"));
    }

输出

hi
tseT

只要在递归函数中添加一个print，就可以跟踪正在发生的事情

输出：

Current: T      // return str
Current: eT     // return reverse
Current: seT    // return reverse
tseT            // final return reverse

从输出中，您可以确定str是否返回。

只要在递归函数中添加一个print，就可以跟踪正在发生的事情

输出：

Current: T      // return str
Current: eT     // return reverse
Current: seT    // return reverse
tseT            // final return reverse

从输出中，您可以确定str是否返回。

只要在递归函数中添加一个print，就可以跟踪正在发生的事情

输出：

Current: T      // return str
Current: eT     // return reverse
Current: seT    // return reverse
tseT            // final return reverse

从输出中，您可以确定str是否返回。

只要在递归函数中添加一个print，就可以跟踪正在发生的事情

输出：

Current: T      // return str
Current: eT     // return reverse
Current: seT    // return reverse
tseT            // final return reverse

从输出中，您可以确定str是否被返回。
我的实现：

    public static String reverse(String str) {
        if(str.length() > 1) {
            return str.substring(str.length()-1)+reverse(str.substring(0, str.length()-1));
        } else {
            return str;
        }
    }

    public static void main(String[] args) {
        System.out.println(reverse("Test"));
    }

输出：

tseT

我的实施：

    public static String reverse(String str) {
        if(str.length() > 1) {
            return str.substring(str.length()-1)+reverse(str.substring(0, str.length()-1));
        } else {
            return str;
        }
    }

    public static void main(String[] args) {
        System.out.println(reverse("Test"));
    }

输出：

tseT

我的实施：

    public static String reverse(String str) {
        if(str.length() > 1) {
            return str.substring(str.length()-1)+reverse(str.substring(0, str.length()-1));
        } else {
            return str;
        }
    }

    public static void main(String[] args) {
        System.out.println(reverse("Test"));
    }

输出：

tseT

我的实施：

    public static String reverse(String str) {
        if(str.length() > 1) {
            return str.substring(str.length()-1)+reverse(str.substring(0, str.length()-1));
        } else {
            return str;
        }
    }

    public static void main(String[] args) {
        System.out.println(reverse("Test"));
    }

输出：

tseT

你可以很容易地使用这个方法

你可以很容易地使用这个方法

你可以很容易地使用这个方法

你可以很容易地使用这个方法

---

实际上它点击并执行，看看这个

public static String reverseString(String str){
    String reverse="";
    if(str.length() == 1 ){
        System.out.println("HIT: " + str);  // CHECKING HIT
        return str; //at one point this condition will be true, but value never returns
    } else {
        reverse += str.charAt(str.length()-1) + reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

public static void main(String a[]) {
    System.out.println(reverseString("Abcd"));
}

如果运行此代码，您将看到如下输出：

HIT: A
dcbA

要理解这段代码是如何工作的，您必须理解反向方法如何调用自身并完成其过程

检查下面的图像

如您所见，在第三步中，由于递归函数的输入字符串长度等于1，因此执行了该部分代码

---

希望所有这些都能有所帮助。

实际上，它会命中并执行，请查看此

public static String reverseString(String str){
    String reverse="";
    if(str.length() == 1 ){
        System.out.println("HIT: " + str);  // CHECKING HIT
        return str; //at one point this condition will be true, but value never returns
    } else {
        reverse += str.charAt(str.length()-1) + reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

public static void main(String a[]) {
    System.out.println(reverseString("Abcd"));
}

如果运行此代码，您将看到如下输出：

HIT: A
dcbA

要理解这段代码是如何工作的，您必须理解反向方法如何调用自身并完成其过程

检查下面的图像

如您所见，在第三步中，由于递归函数的输入字符串长度等于1，因此执行了该部分代码

---

希望所有这些都能有所帮助。

实际上，它会命中并执行，请查看此

public static String reverseString(String str){
    String reverse="";
    if(str.length() == 1 ){
        System.out.println("HIT: " + str);  // CHECKING HIT
        return str; //at one point this condition will be true, but value never returns
    } else {
        reverse += str.charAt(str.length()-1) + reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

public static void main(String a[]) {
    System.out.println(reverseString("Abcd"));
}

如果运行此代码，您将看到如下输出：

HIT: A
dcbA

要理解这段代码是如何工作的，您必须理解反向方法如何调用自身并完成其过程

检查下面的图像

如您所见，在第三步中，由于递归函数的输入字符串长度等于1，因此执行了该部分代码

---

希望所有这些都能有所帮助。

实际上，它会命中并执行，请查看此

public static String reverseString(String str){
    String reverse="";
    if(str.length() == 1 ){
        System.out.println("HIT: " + str);  // CHECKING HIT
        return str; //at one point this condition will be true, but value never returns
    } else {
        reverse += str.charAt(str.length()-1) + reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

public static void main(String a[]) {
    System.out.println(reverseString("Abcd"));
}

如果运行此代码，您将看到如下输出：

HIT: A
dcbA

要理解这段代码是如何工作的，您必须理解反向方法如何调用自身并完成其过程

检查下面的图像

如您所见，在第三步中，由于递归函数的输入字符串长度等于1，因此执行了该部分代码

---

---

希望所有这些都有帮助。

返回str仅在字符串长度为1，测试长度为4时才会执行。您是否尝试在调试器中运行您的小示例？代码绝对正确。。。return reverse执行…如果您使用的是像eclipse这样的IDE，调试并查看它在递归调用期间获得
str=“T”
值时进入
If（str.length（）==1）
。
return str仅在字符串长度为1，测试长度为4时才会执行。您是否尝试在调试器中运行您的小示例？代码绝对正确。。。return reverse执行…如果您使用的是像eclipse这样的IDE，调试并查看它在递归调用期间获得
str=“T”
值时进入
If（str.length（）==1）
。
return str仅在字符串长度为1，测试长度为4时才会执行。您是否尝试在调试器中运行您的小示例？代码绝对正确。。。return reverse执行…如果您使用的是像eclipse这样的IDE，调试并查看它在递归调用期间获得
str=“T”
值时进入
If（str.length（）==1）
。
return str仅在字符串长度为1，测试长度为4时才会执行。您是否尝试在调试器中运行您的小示例？代码绝对正确。。。return reverse执行…如果您使用的是像eclipse这样的IDE，调试并查看它在递归调用期间获得
str=“T”
值时是否进入
If（str.length（）==1）
。请在回答中解释代码。即使这样做有效（我想是的），解释也比复制和粘贴更能帮助OP纠正他的解决方案。（这也不能回答关于“为什么这个函数不能正确结束？”）的实际问题@Vesper是Java中的一个内置类。从上面的链接查看API文档。如果您感兴趣，也可以从rt.ja查看源代码