Java 编写一个递归方法，返回'；A'；在字符串中传递它

所以我在过去的一个小时里一直在处理这个问题。我一直收到意外的类型错误。这似乎是由于charAt和s.length之间的冲突。有什么办法可以解决这个问题吗

class lab7
{
    public static void main(String[] args)
    {
        String s = ("BCA");
    }

    public static String recursion(String s)
    {
        if (s.length()>=0)
        {
            if(s.charAt(s.length()) = A)
            {
                count++;
            }
            s.substring(0, s.length()-1);
        }
        return count;
    }
}

---

这段代码有几个问题，包括一些重要的逻辑错误。但是，您可能会遇到以下具体错误：

if(s.charAt(s.length()) = A)

首先，请注意您使用的是=而不是==，它执行赋值而不是比较。还要注意的是，A应该是单引号中的字符文字。现在，Java认为A是一个未定义的变量的名称。最后，请注意字符串的索引为零，因此在位置s.length（）处查找字符将导致边界错误

---

我希望这能帮助你开始！作为提示，尽管您的函数名为“递归”，但它实际使用递归吗？

此代码存在一些问题，包括一些重要的逻辑错误。但是，您可能会遇到以下具体错误：

if(s.charAt(s.length()) = A)

首先，请注意您使用的是=而不是==，它执行赋值而不是比较。还要注意的是，A应该是单引号中的字符文字。现在，Java认为A是一个未定义的变量的名称。最后，请注意字符串的索引为零，因此在位置s.length（）处查找字符将导致边界错误

---

我希望这能帮助你开始！作为提示，尽管您的函数名为“递归”，但它实际使用递归吗？

此代码存在一些问题，包括一些重要的逻辑错误。但是，您可能会遇到以下具体错误：

if(s.charAt(s.length()) = A)

首先，请注意您使用的是=而不是==，它执行赋值而不是比较。还要注意的是，A应该是单引号中的字符文字。现在，Java认为A是一个未定义的变量的名称。最后，请注意字符串的索引为零，因此在位置s.length（）处查找字符将导致边界错误

---

我希望这能帮助你开始！作为提示，尽管您的函数名为“递归”，但它实际使用递归吗？

此代码存在一些问题，包括一些重要的逻辑错误。但是，您可能会遇到以下具体错误：

if(s.charAt(s.length()) = A)

首先，请注意您使用的是=而不是==，它执行赋值而不是比较。还要注意的是，A应该是单引号中的字符文字。现在，Java认为A是一个未定义的变量的名称。最后，请注意字符串的索引为零，因此在位置s.length（）处查找字符将导致边界错误

我希望这能帮助你开始！作为提示，尽管函数名为“递归”，但它实际使用递归吗？

下面的代码使用字符串类。对于性能关键型应用程序，您可能需要相应地使用StringBuffer/StringBuilder类

class StringCounter
{
    public static void main (String[] args) 
    {
        int count = returnCount("ABCDABCDABCD", 0);
        System.out.println(count);
    }
    public static int returnCount(String s, int count)
    {
        // You may want to do some validations here.
        if(s.length()==0)
        {
            return count;
        }
        if(s.charAt(0)=='A')
        {
            return returnCount(s.substring(1), count+1);            
        }
        else
        {
            return returnCount(s.substring(1), count);
        }
    }
}

代码只是将字符串参数一次分割一个字符，并检查所需的字符。此外，每次调用时，它都会更新count和String参数

有什么办法可以解决这个问题吗

class lab7
{
    public static void main(String[] args)
    {
        String s = ("BCA");
    }

    public static String recursion(String s)
    {
        if (s.length()>=0)
        {
            if(s.charAt(s.length()) = A)
            {
                count++;
            }
            s.substring(0, s.length()-1);
        }
        return count;
    }
}

您的函数不是递归的。递归函数使用操纵/更新的参数调用自己

作为递归函数中的一条经验法则，请始终考虑操作函数参数

始终具有终止递归调用的基本情况

下面的代码使用字符串类。对于性能关键型应用程序，您可能需要相应地使用StringBuffer/StringBuilder类

class StringCounter
{
    public static void main (String[] args) 
    {
        int count = returnCount("ABCDABCDABCD", 0);
        System.out.println(count);
    }
    public static int returnCount(String s, int count)
    {
        // You may want to do some validations here.
        if(s.length()==0)
        {
            return count;
        }
        if(s.charAt(0)=='A')
        {
            return returnCount(s.substring(1), count+1);            
        }
        else
        {
            return returnCount(s.substring(1), count);
        }
    }
}

代码只是将字符串参数一次分割一个字符，并检查所需的字符。此外，每次调用时，它都会更新count和String参数

有什么办法可以解决这个问题吗

class lab7
{
    public static void main(String[] args)
    {
        String s = ("BCA");
    }

    public static String recursion(String s)
    {
        if (s.length()>=0)
        {
            if(s.charAt(s.length()) = A)
            {
                count++;
            }
            s.substring(0, s.length()-1);
        }
        return count;
    }
}

您的函数不是递归的。递归函数使用操纵/更新的参数调用自己

作为递归函数中的一条经验法则，请始终考虑操作函数参数

始终具有终止递归调用的基本情况

下面的代码使用字符串类。对于性能关键型应用程序，您可能需要相应地使用StringBuffer/StringBuilder类

class StringCounter
{
    public static void main (String[] args) 
    {
        int count = returnCount("ABCDABCDABCD", 0);
        System.out.println(count);
    }
    public static int returnCount(String s, int count)
    {
        // You may want to do some validations here.
        if(s.length()==0)
        {
            return count;
        }
        if(s.charAt(0)=='A')
        {
            return returnCount(s.substring(1), count+1);            
        }
        else
        {
            return returnCount(s.substring(1), count);
        }
    }
}

代码只是将字符串参数一次分割一个字符，并检查所需的字符。此外，每次调用时，它都会更新count和String参数

有什么办法可以解决这个问题吗

class lab7
{
    public static void main(String[] args)
    {
        String s = ("BCA");
    }

    public static String recursion(String s)
    {
        if (s.length()>=0)
        {
            if(s.charAt(s.length()) = A)
            {
                count++;
            }
            s.substring(0, s.length()-1);
        }
        return count;
    }
}

您的函数不是递归的。递归函数使用操纵/更新的参数调用自己

作为递归函数中的一条经验法则，请始终考虑操作函数参数

始终具有终止递归调用的基本情况

下面的代码使用字符串类。对于性能关键型应用程序，您可能需要相应地使用StringBuffer/StringBuilder类

class StringCounter
{
    public static void main (String[] args) 
    {
        int count = returnCount("ABCDABCDABCD", 0);
        System.out.println(count);
    }
    public static int returnCount(String s, int count)
    {
        // You may want to do some validations here.
        if(s.length()==0)
        {
            return count;
        }
        if(s.charAt(0)=='A')
        {
            return returnCount(s.substring(1), count+1);            
        }
        else
        {
            return returnCount(s.substring(1), count);
        }
    }
}

代码只是将字符串参数一次分割一个字符，并检查所需的字符。此外，每次调用时，它都会更新count和String参数

有什么办法可以解决这个问题吗

class lab7
{
    public static void main(String[] args)
    {
        String s = ("BCA");
    }

    public static String recursion(String s)
    {
        if (s.length()>=0)
        {
            if(s.charAt(s.length()) = A)
            {
                count++;
            }
            s.substring(0, s.length()-1);
        }
        return count;
    }
}

您的函数不是递归的。递归函数使用操纵/更新的参数调用自己

作为递归函数中的一条经验法则，请始终考虑操作函数参数

始终具有终止递归调用的基本情况

考虑一下这个片段：

static int countA(String str) {
    if (str == null || str.length() == 0) {  /* nothing or "" contains 0 A's */
        return 0;
    }
    return (str.charAt(0) == 'A' ? 1 : 0 )   /* 0 or 1 A's in first character */
                + countA(str.substring(1));  /* plus no. of A's in the rest */
}

您可以这样调用函数：

int a = countA("ABAABA");  /* a is 4 */

我现在意识到这个问题与学校有关，但至少这个片段可以作为理解递归的练习。

考虑一下这个片段：

static int countA(String str) {
    if (str == null || str.length() == 0) {  /* nothing or "" contains 0 A's */
        return 0;
    }
    return (str.charAt(0) == 'A' ? 1 : 0 )   /* 0 or 1 A's in first character */
                + countA(str.substring(1));  /* plus no. of A's in the rest */
}

您可以这样调用函数：

int a = countA("ABAABA");  /* a is 4 */

我现在意识到这个问题与学校有关，但至少这个片段在联合国是一个练习