Java 如何生成4个不重复数字的随机数

我想生成4随机数，它们不能有重复的数字

例如

4567

，（它没有像

4557

那样的重复值）

我希望它们是随机的

---

有没有办法做到这一点？

这将生成没有重复数字的4位随机数

它的工作原理是生成4个唯一的数字，就像在电脑游戏中洗牌一样。然后它简单地通过乘法和加法建立四位数

如果数字小于

1000

，则表示使用了

0

，并且在开始时使用了。因此，只需选择另一个数字进行调整

    Random r = new Random();
    for (int k = 0; k < 10; k++) {
        int val = gen(r);
        System.out.println(val);
    }

    static int[] base = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    public static int gen(Random r) {
        int val = 0;
        int s=10;
        for (int i = 0; i < 4; i++) {
            int n = r.nextInt(s);
            val = val * 10 + base[n];
            int save = base[n];
            base[n] = base[--s];
            base[s] = save;
        }
        return val < 1000 ? val * 10 + base[r.nextInt(s)] : val;
    }

Random r=new Random（）；
对于（int k=0；k<10；k++）{
int val=发电机（r）；
系统输出打印项次（val）；
}
静态int[]base={0,1,2,3,4,5,6,7,8,9}；
公共静态整数生成器（随机r）{
int-val=0；
int s=10；
对于（int i=0；i<4；i++）{
int n=r.nextInt（s）；
val=val*10+base[n]；
int save=base[n]；
基[n]=基[--s]；
基数=保存；
}
返回val<1000？val*10+基[r.nextInt（s）]：val；
}

这里有一个更简单的方法。其原理同上。由于所有的数字都被洗牌，所以它可能没有前一个那么有效

        // generate four digit numbers that have distinct digits.

        List<Integer> digits = Arrays.asList(0,1,2,3,4,5,6,7,8,9);
        Collections.shuffle(digits);

        // now just use the first four of the shuffled list

        if (digits.get(0) == 0) {
            // for a 4 digit number, first digit can't be zero
            // so choose another.
            digits.set(0, digits.get(4));
        }

        // now use simple arithmetic to create the four digit number.
        int n = 0;
        for (int d : digits.subList(0,4)) {
            n = n * 10 + d;
        }

        System.out.println(n);

//生成具有不同数字的四位数字。
列表数字=数组.asList（0,1,2,3,4,5,6,7,8,9）；
集合。洗牌（数字）；
//现在只需使用无序列表的前四个
如果（数字。获取（0）=0）{
//对于4位数字，第一位数字不能为零
//所以选择另一个。
数字.set（0，数字.get（4））；
}
//现在使用简单的算术来创建四位数。
int n=0；
用于（int d：数字。子列表（0,4））{
n=n*10+d；
}
系统输出println（n）；

公共静态void main（字符串[]args）{
列表=新的ArrayList（）；
对于（int j=0；j<10；j++）{
列表.添加（j）；
}
集合。洗牌（列表）；
字符串随机数字=”；
对于（int j=0；j<4；j++）{
randomDigit+=list.get（j.toString（）；
}
系统输出打印项次（随机数字）；
}

---

这是将字符串转换为int。但这将起作用。您可以使用它。

步骤：

创建一个

列表

，该列表将保存生成的 四位数

为1到9之间的单位生成一个随机数，并将其放入列表中

创建一个循环，为循环生成0到9之间的随机数 十的位置直到最后一个位置；每一次，把随机的 在你的名单上填上数字。检查列表中未包含的每个迭代的编号

最终名单的大小现在是4；将这4个人组合成一个

字符串

，并转换为

整数

List<Integer> myNumber = new ArrayList<Integer>();
Random r = new Random();

// Generate a random number between 1 and 9 for units place
myNumber.add(r.nextInt(9) + 1);// adding 1 to avoid 0 in the units place

// Generate a random number between 0 and 9 for 10's and upcoming places
do {
    Integer num = r.nextInt(10);
    // Check the list doesn't contain that number
    if (!myNumber.contains(num)) {
        myNumber.add(num);
    }
}while (myNumber.size() < 4);

StringBuilder numStr = new StringBuilder();
for (int i = 0; i < myNumber.size(); i++)
    numStr.append(myNumber.get(i));

System.out.println(Integer.parseInt(numStr.toString()));

List myNumber=new ArrayList（）；
随机r=新随机（）；
//为单位位置生成1到9之间的随机数
myNumber.add（r.nextInt（9）+1）；//添加1以避免单位位置中的0
//为10个位置和即将到来的位置生成一个介于0和9之间的随机数
做{
整数num=r.nextInt（10）；
//检查列表是否不包含该编号
如果（！myNumber.contains（num））{
myNumber.add（num）；
}
}while（myNumber.size（）<4）；
StringBuilder numStr=新的StringBuilder（）；
对于（int i=0；i

从Java-8开始，使用

stream

和Lambdas的解决方案：

  public static void main(String[] args) {
        Map<String, String> collect = IntStream.rangeClosed(1, 9).boxed()
                .flatMap(x -> IntStream.rangeClosed(0, 9).boxed()
                        .flatMap(y -> IntStream.rangeClosed(0, 9).boxed()
                                .flatMap(z -> IntStream.rangeClosed(0, 9).boxed()
                                        .flatMap(w -> IntStream.rangeClosed(1, 9).boxed().map(s -> s.toString()).filter(e -> noneRepete(x, y, z, w))
                                                .map(k -> x.toString() + y.toString() + z.toString() + w.toString())))))
                .collect(Collectors.toMap(Function.identity(), s -> s, (a, b) -> a));
        collect.keySet().forEach(System.out::println);
    }

    public static boolean noneRepete(Integer a, Integer b, Integer c, Integer d) {
        if (! a.equals(b) && ! a.equals(c) && ! a.equals(d) && a !=0) {
            if (! b.equals(c) && ! b.equals(d)) {
                return ! c.equals(d);
            }
        }
        return false;
    }

publicstaticvoidmain（字符串[]args）{
Map collect=IntStream.rangeClosed（1,9）.boxed（）
.flatMap（x->IntStream.rangeClosed（0,9）.boxed（）
.flatMap（y->IntStream.rangeClosed（0,9）.boxed（）
.flatMap（z->IntStream.rangeClosed（0,9）.boxed（）
.flatMap（w->IntStream.rangeClosed（1,9）.boxed（）.map（s->s.toString（））.filter（e->nonepete（x，y，z，w））
.map（k->x.toString（）+y.toString（）+z.toString（）+w.toString（）））
.collect（Collectors.toMap（Function.identity（），s->s，（a，b）->a））；
collect.keySet（）.forEach（System.out:：println）；
}
公共静态布尔非重复（整数a、整数b、整数c、整数d）{
如果（！a.equals（b）&&！a.equals（c）&&！a.equals（d）&&a！=0）{
如果（！b.equals（c）&&！b.equals（d））{
返回！c等于（d）；
}
}
返回false；
}

说明：

这里我们将整数流从1展平到9（第一个数字不能是0）。 而在下一步中，我们将整型流从0展平到9。 上面的过程又进行了两次，因此它是一个四位数，我们有一个自定义过滤器，它确保所有四位数都是唯一的

---

最后，我们将它们作为键和值进行收集，以确保数字是唯一的，并且地图中的键本身也是唯一的。

如今，我痴迷于流。但是水流很慢。为了显示缓慢，我写了以下主要方法。“generateWithLoop”方法涵盖了@WJS的答案

    public static void main(String[] args) {

        long nanoStart = System.nanoTime();
        generateWithStreams();
        long nanoEnd = System.nanoTime();
        System.out.println("Elapsed time with Streams : " + (nanoEnd - nanoStart) + " nano seconds");

        nanoStart = System.nanoTime();
        generateWithLoop();
        nanoEnd = System.nanoTime();
        System.out.println("Elapsed time with Loop : " + (nanoEnd - nanoStart) + " nano seconds");
    }

控制台输出：

流的运行时间：81367089纳秒

循环运行时间：75093纳秒

使用流：

    public static void generateWithStreams() {

        List<Integer> orderedList = getOrderedList();

        for (int i = 0; i < 4; i++) {
            List<Integer> shuffledList = getShuffledList(orderedList);
            System.out.println(get4DigitNumber(shuffledList));
        }

    }

    public static List<Integer> getOrderedList() {
        return IntStream.range(0, 10).boxed().collect(Collectors.toList());
    }

    public static List<Integer> getShuffledList(List<Integer> list) {
        return list.stream().sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(-1, 2)).collect(Collectors.toList());
    }

    public static Integer get4DigitNumber(List<Integer> shuffledList) {
        final Integer LIMIT = shuffledList.get(0).equals(0) ? 5 : 4;
        return shuffledList.stream().limit(LIMIT).reduce(0, (sum, current) -> sum * 10 + current);
    }

公共静态void generateWithStreams（）{
List orderedList=getOrderedList（）；
对于（int i=0；i<4；i++）{
List shuffledList=getShuffledList（orderedList）；
System.out.println（get4DigitN
    public static void generateWithStreams() {

        List<Integer> orderedList = getOrderedList();

        for (int i = 0; i < 4; i++) {
            List<Integer> shuffledList = getShuffledList(orderedList);
            System.out.println(get4DigitNumber(shuffledList));
        }

    }

    public static List<Integer> getOrderedList() {
        return IntStream.range(0, 10).boxed().collect(Collectors.toList());
    }

    public static List<Integer> getShuffledList(List<Integer> list) {
        return list.stream().sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(-1, 2)).collect(Collectors.toList());
    }

    public static Integer get4DigitNumber(List<Integer> shuffledList) {
        final Integer LIMIT = shuffledList.get(0).equals(0) ? 5 : 4;
        return shuffledList.stream().limit(LIMIT).reduce(0, (sum, current) -> sum * 10 + current);
    }

    public static void generateWithLoop() {
        Random r = new Random();
        for (int k = 0; k < 4; k++) {
            int val = gen(r);
            System.out.println(val);
        }

    }

    static int[] base = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    public static int gen(Random r) {
        int val = 0;
        int s = 10;
        for (int i = 0; i < 4; i++) {
            int n = r.nextInt(s);
            val = val * 10 + base[n];
            int save = base[n];
            base[n] = base[--s];
            base[s] = save;
        }
        return val < 1000 ? val * 10 + base[r.nextInt(s)] : val;
    }