由数学基本定理可知：任何一个大于1的非素数整数都可以唯一分解成若干个素数的乘积。编写程序，从控制台读入一组大于1的整数（小于等于20个，且每个整数的大小不会超过int数据类型表示的范围），求这些整数分

### 回答1：
解成素数的乘积，并输出结果。

实现思路：

1. 从控制台读入一组大于1的整数，存储在一个数组中。

2. 对于每个整数，从2开始循环，如果该数可以被整除，则将该因子存储在一个数组中，并将该数除以该因子，继续循环，直到该数无法被整除为止。

3. 输出该数的因子数组，即为该数分解成素数的乘积。

4. 对于每个输入的整数，重复步骤2和3，直到所有整数都被分解成素数的乘积并输出。

代码实现：

import java.util.Scanner;

public class PrimeFactorization {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一组大于1的整数，以空格分隔：");
String input = scanner.nextLine();
String[] nums = input.split(" ");
for (String num : nums) {
int n = Integer.parseInt(num);
System.out.print(n + " = ");
int[] factors = new int[20];
int index = ;
for (int i = 2; i <= n; i++) {
while (n % i == ) {
factors[index++] = i;
n /= i;
}
}
for (int i = ; i < index; i++) {
System.out.print(factors[i]);
if (i != index - 1) {
System.out.print(" × ");
}
}
System.out.println();
}
scanner.close();
}

}

示例输入：

10 24 36

示例输出：

10 = 2 × 5
24 = 2 × 2 × 2 × 3
36 = 2 × 2 × 3 × 3

### 回答2：
这道题目可以使用质因数分解的算法进行求解，质因数分解是将一个整数分解成若干个质数的积，其原理是通过不断试除，找到一个因子后继续试除直到找到最终的质数因子为止。

具体思路如下：

1. 从控制台读入一组大于1的整数，存放在一个数组中。

2. 定义一个函数 primeFactors(int n)，用来求解整数n的质因数分解，它的返回值是一个数组，存放整数n的质因数分解结果。

3. 在 primeFactors(int n) 函数中，从 2 开始不断试除 n，直到不能再整除，将所得到的质因子存入一个数组中。

4. 为了避免重复计算，可以在主函数中记录每个数字的质因数分解结果，若已经计算过，则直接输出结果。

5. 最后，将每个整数的质因数乘积输出即可。

下面是代码实现：

import java.util.*;

public class PrimeFactors {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();   // 读入整数个数
        int[][] arr = new int[n][20];    // 定义数组存放质因数
        int[] count = new int[n];   // 定义数组记录数字的位数
        for (int i = 0; i < n; i++) {
            int num = scanner.nextInt();    // 读入整数
            if (i > 0) {
                for (int j = 0; j < i; j++) {
                    if (Arrays.equals(arr[j], primeFactors(num))) {  // 判断是否已计算过
                        count[i] = count[j];
                        break;
                    }
                }
            }
            if (count[i] == 0) {   // 若未计算过，则进行质因数分解
                int[] temp = primeFactors(num);
                count[i] = temp.length;
                System.arraycopy(temp, 0, arr[i], 0, count[i]);   // 将分解结果存入数组中
            }
        }
        for (int i = 0; i < n; i++) {
            long result = 1;    // 计算质因数乘积
            for (int j = 0; j < count[i]; j++) {
                result *= arr[i][j];
            }
            System.out.println(result); // 输出结果
        }
    }

    // 求整数n的质因数分解结果
    public static int[] primeFactors(int n) {
        ArrayList<Integer> primes = new ArrayList<Integer>();
        for (int i = 2; i <= n / i; i++) {
            while (n % i == 0) {
                primes.add(i);
                n /= i;
            }
        }
        if (n > 1) {
            primes.add(n);
        }
        return primes.stream().mapToInt(Integer::valueOf).toArray();
    }
}

### 回答3：
这道题是分解质因数的基本应用，可以采用循环嵌套的方式进行求解。

首先读入这组整数，可以用Scanner来实现，并存入一个数组中。然后逐个对每个整数进行分解质因数，可以采用如下的代码实现：

public static void primeFactorization(int n){
    for(int i=2;i<=n;i++){
        while(n%i==0){
            n/=i;
            System.out.print(i+" ");
        }
    }
    System.out.println();
}

其中，外层循环从2开始，每次加1，循环条件是小于等于n；

内层循环则是通过判断n是否可以被i整除，如果可以的话就一直除以i，直到n不能被i整除为止，这样就可以将n分解成若干个素数的乘积了。

最后，在程序的主函数中，可以采用循环遍历数组的方式，依次对每个整数进行分解质因数，并输出结果。完整程序如下：

import java.util.Scanner;

public class PrimeFactorization {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int[] num=new int[20];
        int len;
        System.out.print("请输入要分解质因数的整数个数：");
        len=input.nextInt();
        System.out.println("请输入这"+len+"个整数：");
        for(int i=0;i<len;i++){
            num[i]=input.nextInt();
            primeFactorization(num[i]);
        }
    }

    public static void primeFactorization(int n){
        for(int i=2;i<=n;i++){
            while(n%i==0){
                n/=i;
                System.out.print(i+" ");
            }
        }
        System.out.println();
    }
}

这样就可以实现对一组整数的分解质因数了。