1. import java.io.*;
   
2. public class Text4 {
   
3.         public static void chuLi(int n)
   
4.         {
   
5.                 for(int i=2;i<=n;i++)
   
6.                 {
   
7.                         if(n==i)
   
8.                         {  
   
9.                                 System.out.print(i);
   
10.                                 return;
    
11.                         }       
    
12.                         if(n>i&&(n%i==0))
    
13.                         {
    
14.                                 n=n/i;
    
15.                                 System.out.print(i+"*");
    
16.                                 chuLi(n);
    
17.                                 break;//这句很重要
    
18.                         }       
    
19.                 }
    
20.         }
    
21.         public static void main(String[] args) throws IOException
    
22.         {
    
23.                 int shu=0;
    
24.                 BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    
25.                 System.out.print("请输入正整数：");
    
26.                 shu=(new Integer(stdin.readLine()));
    
27.                 chuLi(shu);
    
28.         }
    
29. }
    

复制代码

将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

穷举法，从2开始除已输入的数，如果2不是除数，开始自增，直到增到输入数总能找到比自己小的除数，或者是自己。看图吧，希望你能看懂啊楼主，你最好自己跟踪一下n

通过内外两层循环来进行判断
for(int i=2;i<=n;i++)外层循环因子i从最小的质数2开始，
内层循环对被分解因数n 进行多次分解因式（通过取模实现），
从而保证了分解出来的因数都为质因数。

我的图有点错误，吧chuli()分别改为chuli(45) chuli(15) chuli(5) 就好啦

1. import java.io.*;
   
2. public class Text4 {
   
3.         public static void main(String[] args) throws IOException
   
4.         {
   
5.                 //定义一个int型变量，用来存放得到的键盘的值。
   
6.                 int shu=0;
   
7.                 //定义输入流，接收从键盘得到的数据。
   
8.                 //System.in是标准输入流，对应键盘输入。
   
9.                 //BufferedReader是字符缓冲输入流，用它的原因是因为它有readLine方法。
   
10.                 BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
    
11.                 //提示用户输入正整数。
    
12.                 System.out.print("请输入正整数：");
    
13.                 //用Integer的构造方法，把得到的字符串转换为int型数据。
    
14.                 shu=(new Integer(stdin.readLine()));
    
15.                 //调用chuli方法。
    
16.                 chuLi(shu);
    
17.         }
    
18.        
    
19.         /*        递归实现正整数分解质因数
    
20.                 明确质数概念，只能被1或它本身整除。
    
21.                 基本思路：
    
22.                 1.从2开始，以后递加，判断n能否被其整除,结束条件是其已经等于n.
    
23.                 2.如果能被整除，得到该数,而n值就变为整除得到的商；
    
24.                 3.然后判断这个n有没有质因数，方法就是上面讲的，再得到商，再判断。。。
    
25.                 4.结束条件：得到的商n，是质因数。
    
26.         */
    
27.         public static void chuLi(int n)
    
28.         {
    
29.                 //for循环从2开始，因为n肯定能被1整除，而且被1整除也不算判定条件
    
30.                 for(int i=2;i<=n;i++)
    
31.                 {
    
32.                         //如果i的值还小于n，且能够整除，得到i值。     
    
33.                         if(n>i&&(n%i==0))
    
34.                         {
    
35.                                 //此时n变为他们整除的商。       
    
36.                                 n=n/i;
    
37.                                 //得到i，这里的处理是打印。
    
38.                                 System.out.print(i+"*");
    
39.                                 //将得到的新的n，再次判断是否有质因数。
    
40.                                 chuLi(n);
    
41.                                 //这句是最后n为质数了，chuli方法返回后，会继续向下执行，
    
42.                                 //执行break，跳出循环，递归方法结束，否则，会继续执行if(n == i)
    
43.                                 //而此时i很可能不等于n，那么for循环还要继续执行
    
44.                                 //继续执行的后果，见图分析。
    
45.                                 break;//这句很重要
    
46.                         }      
    
47.                        
    
48.                         //直到n==i，递归结束。
    
49.                         if(n==i)
    
50.                         {  //把最后一个质数打印出。
    
51.                                 System.out.print(i);
    
52.                                 //返回
    
53.                                 return;
    
54.                         }   
    
55.                 }
    
56.         }
    
57. }
    

复制代码

这是有break和没有break的执行顺序