Java 生成特定的随机字符串数组

我知道，这个标题似乎有点奇怪，让我解释一下

我想生成随机字符串数组，它必须由特定的给定元素组成

假设这些元素是：面包、牛奶、谷物和咖啡

Java代码应该随机选择其中一个并将其放入数组中

我取得了一些进展，并成功生成了10个具有以下代码的数组，例如：

    String[] elements = new String[] {"Bread","Milk","Cereal","Coffee"};

    for (int i=0; i < 10; i++) {

        int random_number = ThreadLocalRandom.current().nextInt(2, 5);

        String[] list = new String[random_number];

        System.out.print("[");

        for (int j=0; j < random_number; j++) {

            int pos = ThreadLocalRandom.current().nextInt(0, 4);
            list[j] = elements[pos];
            System.out.print(list[j]+ ", ");
        }

        System.out.println("]");
        }

有两个问题

第一个不是很重要，但是最好不要在每个数组的最后一个元素后面有

，

第二个问题是：我不希望每个数组中都有重复的元素

面包、牛奶、谷物、咖啡在每个阵列中不得显示超过一次

例如，

[咖啡，咖啡，咖啡，面包]

是错误的

换句话说，一个可能的正确输出是：

[Bread, Milk]
[Bread, Milk, Cereal, Coffee]
[Bread, Cereal, Coffee]
[Bread, Cereal]
[Bread, Coffee]
[Milk, Coffee]
[Milk, Cereal]
[Milk, Cereal, Coffee]
[Cereal, Coffee]

如果两个或两个以上的数组相同就可以了

---

提前感谢。

创建一个包含4个元素的列表。洗牌。选择一个介于0和4之间的随机整数。获取从0开始并以此随机索引结束的子列表。打印列表。重复任意次数。

创建一个包含4个元素的列表。洗牌。选择一个介于0和4之间的随机整数。获取从0开始并以此随机索引结束的子列表。打印列表。重复任意次数。

您可以像这样使用

Set

和

Random

：

String[] elements = new String[] {"Bread","Milk","Cereal","Coffee"};
Random r = new Random();
for(int i=0;i<10;i++)
    Set<String> set = new HashSet<>();
    for (int j=0; j < 4; j++) {
       set.add(elements[r.nextInt(4)]);
    }
    System.out.println(set);
}

String[]elements=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
随机r=新随机（）；
对于（int i=0；i您可以使用
Set
和
Random
这样：

String[] elements = new String[] {"Bread","Milk","Cereal","Coffee"};
Random r = new Random();
for(int i=0;i<10;i++)
    Set<String> set = new HashSet<>();
    for (int j=0; j < 4; j++) {
       set.add(elements[r.nextInt(4)]);
    }
    System.out.println(set);
}

String[]elements=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
随机r=新随机（）；
对于（int i=0；i首先，数组中不会有一个，来自
System.out.print（list[j]+“，”）；
，它与数组无关

为了避免重复，将
字符串
数组
字符串[]列表=新字符串[随机数]；

替换为

集

，

集集=新哈希集（）；

首先，数组中不会有来自

系统的.out.print（list[j]+“，”）；

，它与数组无关

---

为了避免重复，将

字符串

数组字符串[]列表=新字符串[随机数]；替换为

集合

，

集合=新哈希集（）；

如果您不太在意效率，这将是一种方法

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class RandomArrays {
    public static void main(String[] args) {
        String[] elements = new String[]{"Bread", "Milk", "Cereal", "Coffee"};
        for (int i = 0; i < 15; i++) {
            final String[] array = generateRandomArrayFromElements(elements);
            System.out.println(Arrays.toString(array));
        }
    }

    private static String[] generateRandomArrayFromElements(String[] elements) {
        final List<String> list = Arrays.asList(elements);
        Collections.shuffle(list);
        return list.toArray(new String[list.size()]);
    }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公共类随机数组{
公共静态void main（字符串[]args）{
字符串[]元素=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
对于（int i=0；i<15；i++）{
最终字符串[]数组=GeneratorDomainArrayFromElements（元素）；
System.out.println（array.toString（array））；
}
}
私有静态字符串[]GeneratorDomainArrayFromElements（字符串[]元素）{
最终列表=数组.asList（元素）；
集合。洗牌（列表）；
return list.toArray（新字符串[list.size（）]）；
}
}

或者，如果您需要可变数量的元素，可以执行以下操作：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

public class RandomArrays {
    public static void main(String[] args) {
        String[] elements = new String[]{"Bread", "Milk", "Cereal", "Coffee"};
        for (int i = 0; i < 15; i++) {
            final String[] array = generateRandomArrayFromElements(elements);
            System.out.println(Arrays.toString(array));
        }
    }

    private static String[] generateRandomArrayFromElements(String[] elements) {
        int size = ThreadLocalRandom.current().nextInt(0, elements.length) + 1;
        String[] array = new String[size];
        ArrayList<Integer> usedIndices = new ArrayList<>(size);
        for (int i = 0; i < array.length; i++) {
            int randomIndex = getUniqueRandomIndex(usedIndices, size);
            usedIndices.add(randomIndex);
            array[i] = elements[randomIndex];
        }
        return array;
    }

    private static int getUniqueRandomIndex(ArrayList<Integer> usedIndices, int max) {
        int randomIndex = ThreadLocalRandom.current().nextInt(0, max);
        final boolean contains = usedIndices.contains(randomIndex);
        if (contains)
            randomIndex = getUniqueRandomIndex(usedIndices, max);
        return randomIndex;
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.concurrent.ThreadLocalRandom；
公共类随机数组{
公共静态void main（字符串[]args）{
字符串[]元素=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
对于（int i=0；i<15；i++）{
最终字符串[]数组=GeneratorDomainArrayFromElements（元素）；
System.out.println（array.toString（array））；
}
}
私有静态字符串[]GeneratorDomainArrayFromElements（字符串[]元素）{
int size=ThreadLocalRandom.current（）.nextInt（0，elements.length）+1；
字符串[]数组=新字符串[大小]；
ArrayList usedIndices=新的ArrayList（大小）；
for（int i=0；i

如果您不太在意效率，这将是一种方法

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class RandomArrays {
    public static void main(String[] args) {
        String[] elements = new String[]{"Bread", "Milk", "Cereal", "Coffee"};
        for (int i = 0; i < 15; i++) {
            final String[] array = generateRandomArrayFromElements(elements);
            System.out.println(Arrays.toString(array));
        }
    }

    private static String[] generateRandomArrayFromElements(String[] elements) {
        final List<String> list = Arrays.asList(elements);
        Collections.shuffle(list);
        return list.toArray(new String[list.size()]);
    }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公共类随机数组{
公共静态void main（字符串[]args）{
字符串[]元素=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
对于（int i=0；i<15；i++）{
最终字符串[]数组=GeneratorDomainArrayFromElements（元素）；
System.out.println（array.toString（array））；
}
}
私有静态字符串[]GeneratorDomainArrayFromElements（字符串[]元素）{
最终列表=数组.asList（元素）；
集合。洗牌（列表）；
return list.toArray（新字符串[list.size（）]）；
}
}

或者，如果您需要可变数量的元素，可以执行以下操作：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

public class RandomArrays {
    public static void main(String[] args) {
        String[] elements = new String[]{"Bread", "Milk", "Cereal", "Coffee"};
        for (int i = 0; i < 15; i++) {
            final String[] array = generateRandomArrayFromElements(elements);
            System.out.println(Arrays.toString(array));
        }
    }

    private static String[] generateRandomArrayFromElements(String[] elements) {
        int size = ThreadLocalRandom.current().nextInt(0, elements.length) + 1;
        String[] array = new String[size];
        ArrayList<Integer> usedIndices = new ArrayList<>(size);
        for (int i = 0; i < array.length; i++) {
            int randomIndex = getUniqueRandomIndex(usedIndices, size);
            usedIndices.add(randomIndex);
            array[i] = elements[randomIndex];
        }
        return array;
    }

    private static int getUniqueRandomIndex(ArrayList<Integer> usedIndices, int max) {
        int randomIndex = ThreadLocalRandom.current().nextInt(0, max);
        final boolean contains = usedIndices.contains(randomIndex);
        if (contains)
            randomIndex = getUniqueRandomIndex(usedIndices, max);
        return randomIndex;
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.concurrent.ThreadLocalRandom；
公共类随机数组{
公共静态void main（字符串[]args）{
字符串[]元素=新字符串[]{“面包”、“牛奶”、“谷物”、“咖啡”}；
对于（int i=0；i<15；i++）{
最终字符串[]数组=GeneratorDomainArrayFromElements（元素）；
System.out.println（array.toString（array））；
}
}
私有静态字符串[]GeneratorDomainArrayFromElements（字符串[]元素）{
int size=ThreadLocalRandom.current（）.nextInt（0，元素）。