Java-洗牌元素并输出特定数量

在Java中，我被告知使用这种结构来洗牌项目列表：

List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
Collections.shuffle(tasks);
for(String task : tasks){
    System.out.println(task); 
}

List tasks=Arrays.asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
for（字符串任务：任务）{
System.out.println（任务）；
}

我的程序的这个解决方案的问题是，我只想随机输出用户选择的一些元素（也就是说，如果用户只想要五个元素而不是全部八个元素，我只想要随机输出五个元素）。我以前从未实际使用过lambda或那种形式的forloop（我对Java完全陌生）。我知道如何使用数组，我试着为数组找到一个洗牌选项，但什么也没想到。我也试过：

int num = console.nextInt();
List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
Collections.shuffle(tasks);
for(int i = 1; i <= num; i++){
    String task = tasks;
    System.out.println(task); 
}

int num=console.nextInt（）；
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
对于（inti=1；i，在无序排列列表后，可以通过
迭代器从头部获取元素

int num = console.nextInt();
List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
Collections.shuffle(tasks);
java.util.Iterator<String> taskItr = tasks.iterator();
for(int i = 1; i <= num && taskItr.hasNext(); i++){
    String task = taskItr.next();
    System.out.println(task); 
}

int num=console.nextInt（）；
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
java.util.Iterator taskItr=tasks.Iterator（）；
对于（inti=1；i，在无序排列列表后，可以通过
迭代器从头部获取元素

int num = console.nextInt();
List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
Collections.shuffle(tasks);
java.util.Iterator<String> taskItr = tasks.iterator();
for(int i = 1; i <= num && taskItr.hasNext(); i++){
    String task = taskItr.next();
    System.out.println(task); 
}

int num=console.nextInt（）；
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
java.util.Iterator taskItr=tasks.Iterator（）；
对于（int i＝1；i＜p＞）是否会有错误地将初始的8个元素（随机）洗牌，然后简单地返回该列表的子集？考虑下面的代码：

public class ListTest {
    public static List<String> getRandomItems(int num) {
        List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
        Collections.shuffle(tasks);

        return tasks.subList(0, num);
    }

    public static void main(String[] args) {
        // take 5 random elements
        List<String> randomList = getRandomItems(5);
        for (String item : randomList) {
            System.out.println("Found an item: " + item);
        }
    }
}

公共类列表测试{
公共静态列表getRandomItems（int num）{
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
返回任务。子列表（0，num）；
}
公共静态void main（字符串[]args）{
//取5个随机元素
List randomList=getRandomItems（5）；
用于（字符串项：随机列表）{
System.out.println（“找到一个项目：+项目”）；
}
}
}

请注意，从原始8个元素中选择哪个子集并不重要，因为它们是随机顺序的。相反，唯一重要的是选择大小正确的子集。
将初始8个元素（随机）混洗会有什么问题吗然后简单地返回那个列表的子集？考虑下面的代码：

public class ListTest {
    public static List<String> getRandomItems(int num) {
        List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
        Collections.shuffle(tasks);

        return tasks.subList(0, num);
    }

    public static void main(String[] args) {
        // take 5 random elements
        List<String> randomList = getRandomItems(5);
        for (String item : randomList) {
            System.out.println("Found an item: " + item);
        }
    }
}

公共类列表测试{
公共静态列表getRandomItems（int num）{
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
返回任务。子列表（0，num）；
}
公共静态void main（字符串[]args）{
//取5个随机元素
List randomList=getRandomItems（5）；
用于（字符串项：随机列表）{
System.out.println（“找到一个项目：+项目”）；
}
}
}

请注意，从原始的8个元素中选择哪个子集并不重要，因为它们将是随机顺序。相反，唯一重要的是选择大小正确的子集。
洗牌后，询问用户需要多少元素…然后使用
列表。sublist
从0到给定数字

例子：
publicstaticvoidmain（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
System.out.println（“您需要多少？”；
int userAnswer=sc.nextInt（）；
List res=任务。子列表（0，userAnswer）；
System.out.println（“这里是”+res）；
}
洗牌后，询问用户需要多少元素…然后使用
列表。子列表
从0到给定数字

例子：
publicstaticvoidmain（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
列表任务=数组。asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
System.out.println（“您需要多少？”；
int userAnswer=sc.nextInt（）；
List res=任务。子列表（0，userAnswer）；
System.out.println（“这里是”+res）；
}
任务
是一个
列表
，它不能分配给
字符串
。您需要从
任务
中获取一个特定的
字符串
来分配给
任务
，或者您可以完全取消
任务
，因为不需要为它声明单独的变量。您的
用于循环应如下所示：

for (int i=0; i<num; i++) {
    System.out.println(tasks.get(i));
}

用于（int i=0；i
任务
是一个
列表
，不能分配给
字符串
。您需要从
任务
中获取一个特定的
字符串
，以分配给
任务
，或者您可以完全取消
任务
，因为不需要为它声明单独的变量或
循环应如下所示：

for (int i=0; i<num; i++) {
    System.out.println(tasks.get(i));
}

for（inti=0；i另一种剥猫皮的方法

int num = console.nextInt();
for(String task : tasks){
    System.out.println(task); 

    if (num--) <= 0) break;
}

int num=console.nextInt（）；
for（字符串任务：任务）{
System.out.println（任务）；
如果（num--）另一种剥猫皮的方法

int num = console.nextInt();
for(String task : tasks){
    System.out.println(task); 

    if (num--) <= 0) break;
}

int num=console.nextInt（）；
for（字符串任务：任务）{
System.out.println（任务）；
如果（num--）您的第二个代码示例甚至无法编译，因为您无法将
列表
分配为
字符串
。您必须使用
String task=tasks.get（i）；

如果要从列表中输出随机元素，只需使用
random
获取范围为0到
list.size（）
的随机数，并在相应位置输出元素：

List<String> tasks = Arrays.asList("1","2","3","4","5","6","7","8");
Collections.shuffle(tasks);
int num = 5;
Random random = new Random();

for(int i = 0; i < num; i++){
    System.out.println(tasks.get(random.nextInt(tasks.size())));
}

List tasks=Arrays.asList（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”）；
集合。洗牌（任务）；
int num=5；
随机=新随机（）；
for（int i=0；i

这里的问题是，您可能会输出