java中奇怪的循环行为

我是一名java学习者，我有一个任务要在论坛上学习更多。 挑战是接收一个数字并将其乘以自己的数字，如：

输入

999

输出'9*9*9=729，然后7*2*9=126，再输出1*2*6=12，最后输出1*2=2，直到它只命中一个位数

我得到了这个问题，我要求一个变量将长度为2的数组的乘法相加，它返回给我

 1------------------1
 49-----------------2 
 final result 2450

这就是代码

class Persist {
  public static void persistence(long n) {
     String number = String.valueOf((int)n);
     char[] digits1 = number.toCharArray();
     int value = 1;

     for(int i = 0 ;i <= digits1.length -1;i++) {
        System.out.println(value + "-----------------" + digits1[i]);
        value = value* (int)digits1[i];
     }

     System.out.println((int)value);
 }

 public static void main(String [] args) {
    persistence(12);
 }
}

类持久化{
公共静态void持久性（长n）{
字符串编号=String.valueOf（（int）n）；
char[]digits1=number.toCharArray（）；
int值=1；
对于（int i=0；i您使用的是数字的ASCII值（参见），即1=49和2=50

49*50=2450

您可以使用Character.getNumericValue来获取字符的数值，即

class Persist {
    public static void persistence(long n) {
        String number = String.valueOf((int)n);
        char[] digits1 = number.toCharArray();
        int value = 1;
        for(int i = 0 ;i <= digits1.length -1;i++) {
            System.out.println(value + "-----------------" + digits1[i]);
            value = value* Character.getNumericValue((int)digits1[i]);

        }
        System.out.println((int)value);
    }

    public static void main(String [] args) {
        persistence(12);

    }

类持久化{
公共静态void持久性（长n）{
字符串编号=String.valueOf（（int）n）；
char[]digits1=number.toCharArray（）；
int值=1；
对于（int i=0；i来说，如果您使用调试器查看值，最容易理解。在实际计算过程中，
value=value*（int）digits1[i]
您使用的不是数字的值，而是字符的ASCII值。这是1->49和2->50，因此您正在计算49*50=2450。
将行更改为
value=value*Character.getNumericValue（digits1[i]）；
您就可以得到您想要的内容了。
我将这样做。我对其进行了调整，以便将0值数字转换为1。您可以对此进行注释（这样做是因为0的任何数字都会将答案转换为0）。此版本将不断重复，直到减少到一位数

public class Persist {
    public static void main(String [] args) {
        int answer = persistence(234);
        System.out.println("        length: " + String.valueOf(answer).length());
        while (  String.valueOf(answer).length() > 1)   {   
            answer = persistence(answer);
        } }

    static int persistence(int n) {
        int value = 1;
        String myStr = String.valueOf(n);
        int myStrLen = myStr.length();
        int[] finalIntAr = new int[myStrLen];                                               

        for (int v=0; v< myStrLen;  v++) {
            String subS= myStr.substring(v,v+1);
            System.out.println("the char/int : " + subS);
            Integer bigI = Integer.valueOf(subS);
            if (bigI == 0) { bigI = 1; }   // take this out if you want 0 to perform as 0
            finalIntAr[v] = bigI.intValue();
        }

        for (int i = 0 ;   i < myStrLen;  i++) {
            System.out.println("   -----     first=  " +  value + "  multiplied by : " + finalIntAr[i]);
            value = value * finalIntAr[i];
        }
        System.out.println("\n CURRENT FINAL VALUE *** : " + value);
        return value;
    } }

因为没有人用不带字符串或字符的方式给出答案，我会的。但从技术上讲，这不是对你问题的回答

public static void persistence(long x)
{
    long answer = 1;
    while (x != 0) {
        long onesDigit = x % 10;
        answer *= onesDigit;
        x /= 10;
    }
    System.out.println(answer);
}

可能的重复可以避免所有转换。提示：
1234%10=4
和
1234/10=123
。你写了“输入999输出9*9*9=81”。但是9*9=81和9*9*9=729，对吗？你能纠正你的问题吗？避免“神奇”数字——事实上，是的，
public static void persistence(long x)
{
    long answer = 1;
    while (x != 0) {
        long onesDigit = x % 10;
        answer *= onesDigit;
        x /= 10;
    }
    System.out.println(answer);
}