请教各位高手！

Question

if (a== 0) {
  if (data == tempRowCount) {
     /*
      *当程序执行到这里时，下面两种情况为什么不一样？？？？求高手指点一下。
      **/
     //1、第一种情况跳出整个if else块
     result = result.substring(1, result.length());
     return result;
     //2、第二种情况会执行到codeXXXX()处
     return result.substring(1, result.length());
  }else{
       
  }
}else{
     codeXXXX();
}

Answer 1

a!=0 时才会执行}else{
  codeXXXX(); 
}a== 0且data！=tempRowCount时 什么都不执行走的分支是 }else{
    
  } 

Answer 2

没看懂，if-else不是一层一层走的么？if不满足就走else啊，，，

Answer 3

程序写的很乱套，见笑了哈public class ReversedTest {
private static int[] dataResult;
private static int rowCount = 0;
private static int test = 1234567890; /**
 * 将一整数逆序后放入一数组中（要求递归实现） Ex : 1234 变为 {4,3,2,1}
 */
public static void main(String[] args) {
Integer dataInt = new Integer(test);
int length = dataInt.toString().length();
dataResult = new int[length];
int[] result = reversed(test);
for (int i = 0; i < result.length; i++) {
System.out.print(result[i]);
}
} private static int[] reversed(int data) {
Integer dataInt = new Integer(data);
int length = dataInt.toString().length();
int multiplier = (int) Math.pow(10, length - 1); int divisor = data % multiplier;
if (data == multiplier) {
divisor = data;
} Integer temp = new Integer(divisor);
if (temp.toString().length() == 1) {
dataResult[rowCount] = divisor;
rowCount++;
String testData = new Integer(test).toString();
int subLength = 0;
int tempDataInt = 0;
if (testData.length() != rowCount) {
subLength = testData.length() - rowCount;
tempDataInt = Integer
.parseInt(testData.substring(0, subLength));
reversed(tempDataInt);
} else {
return dataResult;
}
} else {
reversed(divisor);
}
return dataResult;
}
}

Answer 4

您可以试一下public class ReversedTest {
private static int[] dataResult;
private static int rowCount = 0;
private static int test = 1234567890; /**
 * 将一整数逆序后放入一数组中（要求递归实现） Ex : 1234 变为 {4,3,2,1}
 */
public static void main(String[] args) {
Integer dataInt = new Integer(test);
int length = dataInt.toString().length();
dataResult = new int[length];
int[] result = reversed(test);
for (int i = 0; i < result.length; i++) {
System.out.print(result[i]);
}
} private static int[] reversed(int data) {
Integer dataInt = new Integer(data);
int length = dataInt.toString().length();
int multiplier = (int) Math.pow(10, length - 1); int divisor = data % multiplier;
if (data == multiplier) {
divisor = data;
} Integer temp = new Integer(divisor);
if (temp.toString().length() == 1) {
dataResult[rowCount] = divisor;
rowCount++;
String testData = new Integer(test).toString();
int subLength = 0;
int tempDataInt = 0;
if (testData.length() != rowCount) {
subLength = testData.length() - rowCount;
tempDataInt = Integer
.parseInt(testData.substring(0, subLength));
reversed(tempDataInt);
} else {
return dataResult;
}
} else {
reversed(divisor);
}
return dataResult;
}
}

Answer 5

if (a== 0) {
  if (data == tempRowCount) {
  /*
  *当程序执行到这里时，下面两种情况为什么不一样？？？？求高手指点一下。
  **/
  //1、第一种情况跳出整个if else块
  result = result.substring(1, result.length());
  return result;
  //2、第二种情况会执行到codeXXXX()处
  //这个地方不可能跳到codeXXXX()处,因为在if-else只能执行一种，很明显现在已经在第一个条件里了。不可能再执行它的else.
  return result.substring(1, result.length());
  }else{
   
  }
}else{
  codeXXXX();
}

Answer 6

楼主的逻辑是不是把
1234567890
把其他位都截掉，当最后只剩下一个的时候0，放入数组中。
接着substring 得到 123456789
重复以上操作就等到逆序了
但是好像没有楼主说的那种跳跃吧。我没看出来，确切的说真没有。

Answer 7

抱歉啊各位，弄错了，这个是，大家可以试试debug一下试试，我不会泡大家的public class QualityFactorTest {
static String result = "";
static int rowCount = 2; /**
 * 分解成质因数(如435234=251*17*17*3*2，据说是华为笔试题)
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(getQualityFactor(12));
} private static String getQualityFactor(int data) {
int temp = data % rowCount;
if (temp == 0) {
result = "*" + rowCount + result;
int tempRowCount = rowCount;
rowCount = 2;
if (data == tempRowCount) {
// result = result.substring(1, result.length());
return result.substring(1, result.length());
} else {
getQualityFactor(data / tempRowCount);
}
} else {
rowCount++;
getQualityFactor(data);
}
return result;
}
}

Answer 8

结构还是比较清晰的public class QualityFactorTest {
    static String result = "";
    static int rowCount = 2;    /**
     * 分解成质因数(如435234=251*17*17*3*2，据说是华为笔试题)
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(getQualityFactor(121));
    }    private static String getQualityFactor(int data){//12进来
        int temp = data % rowCount;//temp=6
        if (temp == 0) {//true
            result = "*"+rowCount + result;//result ="*2"
            int tempRowCount = rowCount;//2
//            rowCount = 2;//这句话多余了
            if (data == tempRowCount){//如果除数=被除数?说明没有其他因子，只有他本身了，直接返回
                return result.substring(1,result.length());//把前面的*号去掉
            } else {
                getQualityFactor(data/tempRowCount);
            }
        }
        else {
            rowCount++;//如果temp != 0说明rowCount不是因子，+1处理，如果是因子，就是前面的if语句了，就在除这个因子，看可不可以再继续分解。
            getQualityFactor(data);
        }
        return result.substring(1,result.length());//把多余的*截掉
    }
}

Answer 9

前辈，您debug了吗？这两种结果是一样的吗？

Answer 10

debug了，是跳了，因为这是递归调用，然后一层一层回跳，导致有这种误导。刚开始我想也不会跳吧，就相当于一个返回值一级一级返回来，然后回到主函数操作。
还有楼主说的那两种情况不同，
  //1、第一种情况跳出整个if else块
  result = result.substring(1, result.length());
  return result;
  //2、第二种情况会执行到codeXXXX()处
  return result.substring(1, result.length());
测试结果是一样，没有你说的跳出if else
其实也跳了，但是不是在同一层，返回的是上一层。我是这么理解的。不然为什么跳了没执行？是不？

Answer 11

package com;public class QualityFactorTest {
    static String result = "";
    static int rowCount = 2;    /**
     * 分解成质因数(如435234=251*17*17*3*2，据说是华为笔试题)
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(getQualityFactor(12));
    }
    
    //该递归方法会被不必要的调用n多次
    private static String getQualityFactor(int data) {
     //data为12时候 第一次进入该方法 会进入getQualityFactor(data / tempRowCount);
     //递归第二次进入该方法的时候data为6 也是进入getQualityFactor(data / tempRowCount);
     //递归第三次进入该方法的时候data为3进入外围的else块，在此进入 getQualityFactor(data);
     //递归第四次进入该方法的时候data为3  rowCount也为3 方法会进入 内层的if语句 开始返回数据
        int temp = data % rowCount;
        if (temp == 0) {
            result = "*" + rowCount + result;
            int tempRowCount = rowCount;
            rowCount = 2;
            if (data == tempRowCount) {
//                result = result.substring(1, result.length());
             //这个return并没有修改result数据 所以这个时候result还是  *3*2*2
             //而且result是类的成员变量，你只要去修改就可以，不需要这样在用return返回了
                return result.substring(1, result.length());
            } else {
                getQualityFactor(data / tempRowCount);
            }
        } else {
            rowCount++;
            getQualityFactor(data);
        }
        return result;
    }
}

Answer 12

告诉你我一向不喜欢一层一层IF ELSE
虽然这样可以满足要求，但对后面的维护是个头大的问题。
你估计得看着一个流程图才大概能明白这段代码的意思吧？
在这种逻辑复杂的情况下代码非常关键！
我还是非常推荐，单IF结构。
令愿多写点条件，多个单IF能搞定。
这样对可阅读性要好的多。

Answer 13

package com;public class QualityFactorTest {
    static String result = "";
    static int rowCount = 2;
    
    public static void main(String[] args) {
     getQualityFactor(12);
        System.out.println(result);
        System.out.println(getQualityFactor1(12));
        System.out.println(getQualityFactor2(12));
    }
    //递归调用实现
    private static void getQualityFactor(int data) {
     if(data == 1) {//说明因式分解结束
     result = result.substring(1);
     rowCount = 2;
     }
     for(; rowCount <= data; rowCount++) {
     if(data % rowCount == 0) {
     result = "*" + rowCount + result;
     getQualityFactor(data / rowCount);
     break;
     //return;
     }
     }
    }
    //递归调用实现
    private static String getQualityFactor1(int data) {
     for(; rowCount <= data; rowCount++) {
     if(data % rowCount == 0) {
     if(data == rowCount) {//说明因式分解结束
     String result1 = String.valueOf(rowCount);
     rowCount = 2;
     return result1;
     }
     String result1 = "*" + rowCount;
     return  getQualityFactor1(data / rowCount) + result1;
     }
     }
     return "";
    }
    //循环实现
    private static String getQualityFactor2(int data) {
     String result1 = "";
     while(true) {
     for(; rowCount <= data; rowCount++) {
     if(data % rowCount == 0) {
     result1 = "*" + rowCount + result1;
     data = data / rowCount;
     break;
     }
     }
     if(data == 1) {
     break;
     }
     }
     return result1.substring(1);
    }
}
给你个我的实现方式