定义一个长度随机的ArrayList类型的数组，并在其中填充若干个1～50之间的随机整数，然后从中过滤出所有的质数，并保存到到另一个ArrayList类型的数组中

### 回答1：
好的，这是一个关于编程的问题，我可以帮助您解决。以下是代码：

import java.util.ArrayList;
import java.util.Random;

public class Main {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
Random random = new Random();
int n = random.nextInt(20) + 1;
for(int i = 0; i< n; i++){
list1.add(random.nextInt(50)+1);
}
System.out.println("原始数组为：" + list1);

ArrayList<Integer> list2 = new ArrayList<Integer>();
for(int i = 0; i < list1.size(); i++){
int num = list1.get(i);
boolean isPrime = true;
for(int j = 2; j < num; j++){
if(num % j == 0){
isPrime = false;
break;
}
}
if(isPrime){
list2.add(num);
}
}
System.out.println("质数数组为：" + list2);
}
}

这段代码可以生成一个长度随机的ArrayList类型的数组，然后从中过滤出所有的质数，并保存到到另一个ArrayList类型的数组中。在这个过程中，我们使用了嵌套的for循环来判断每个数字是否是质数，具体判断方法是如果这个数字除了1和自己本身，没有其他因子，那么就是质数，然后将质数加入到另外一个数组中。

希望这个代码可以帮助您解决问题。

### 回答2：
要实现这个需求，首先需要定义一个长度随机的ArrayList类型的数组，并填充随机数。接下来，遍历数组中的每个元素，判断是否为质数，并将质数保存到另一个ArrayList类型的数组中。

具体步骤如下：
1. 导入所需的包，包括ArrayList和Random。
2. 使用Random类生成一个随机长度，存储在randomLength中。
3. 创建一个ArrayList类型的数组numbers，用于存储生成的随机数。
4. 使用循环，往数组numbers中添加randomLength个随机整数，范围为1到50。
5. 创建一个ArrayList类型的数组primeNumbers，用于存储质数。
6. 使用循环，遍历数组numbers中的每个元素。
7. 对当前元素进行质数判断：
a. 如果当前元素小于2，跳过本次循环。
b. 如果当前元素是2，将其添加到数组primeNumbers中。
c. 如果当前元素大于2，使用循环判断是否存在除1和本身以外的因子：
i. 如果存在除1和本身以外的因子，跳过本次循环。
ii. 如果不存在除1和本身以外的因子，将当前元素添加到数组primeNumbers中。
8. 输出数组primeNumbers，即为过滤出的所有质数。

下面是实现的示例代码：

import java.util.ArrayList;
import java.util.Random;

public class PrimeNumberFilter {

    public static void main(String[] args) {
        Random random = new Random();
        int randomLength = random.nextInt(20); // 生成随机长度

        ArrayList<Integer> numbers = new ArrayList<>(); // 存储随机数
        for (int i = 0; i < randomLength; i++) {
            int randomNumber = random.nextInt(50) + 1; // 生成1到50的随机整数
            numbers.add(randomNumber); // 添加到数组
        }

        ArrayList<Integer> primeNumbers = new ArrayList<>(); // 存储质数
        for (int number : numbers) {
            if (number < 2) {
                continue;
            }
            if (number == 2) {
                primeNumbers.add(number);
            } else {
                boolean isPrime = true;
                for (int j = 2; j < number; j++) {
                    if (number % j == 0) {
                        isPrime = false;
                        break;
                    }
                }
                if (isPrime) {
                    primeNumbers.add(number);
                }
            }
        }

        System.out.println("过滤出的质数为：" + primeNumbers);
    }
}

这样，就可以生成长度随机的ArrayList类型的数组，并过滤出其中的质数，保存到另一个ArrayList类型的数组中。最后输出质数数组即可。

### 回答3：
首先，我们可以使用Random类生成一个随机数对象，用于生成1到50之间的随机整数。然后，我们定义一个ArrayList类型的数组，将其长度设为随机数。

接下来，我们可以使用一个循环来填充ArrayList数组。在每次循环中，我们生成一个1到50之间的随机整数，并将其添加到ArrayList数组中。

然后，我们定义另一个ArrayList类型的数组，用于保存质数。我们可以使用一个循环遍历原始ArrayList数组中的每个元素。对于每个元素，我们可以编写一个函数来检查它是否是质数。如果是质数，我们将其添加到保存质数的ArrayList数组中。

最后，我们可以输出保存质数的ArrayList数组中的所有元素。

以下是完整的代码示例：

import java.util.ArrayList;
import java.util.Random;

public class PrimeNumberFilter {
    public static void main(String[] args) {
        Random random = new Random();
        int length = random.nextInt(50) + 1;
        ArrayList<Integer> originalList = new ArrayList<>();
        ArrayList<Integer> primeList = new ArrayList<>();

        for (int i = 0; i < length; i++) {
            int randomNumber = random.nextInt(50) + 1;
            originalList.add(randomNumber);
        }

        for (int number : originalList) {
            if (isPrime(number)) {
                primeList.add(number);
            }
        }

        System.out.println("原始数组：" + originalList);
        System.out.println("质数数组：" + primeList);
    }

    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}

以上代码会首先随机生成一个长度1到50的ArrayList类型的数组，然后将1到50之间的随机整数添加到该数组中。接下来，会通过isPrime函数过滤出其中的质数，并保存到另一个ArrayList类型的数组中。最后，输出原始数组和质数数组的内容。