Question

我在Uni的一位朋友，想要生成一堆13位数字，这样他就可以测试他的排序算法，但是这样做很长一段时间，所以我尝试使用以下用于生成可设置的13位数字的代码。

public class random {

public static void main(String[] args) {

    long intArray[] = new long[20]; // to generate more than 20 random numbers increase this and the 'i < 20' to the same number ie. 75 

    for(int i = 0; i < 20; i++) { // here
        intArray[i] = numbGen();            
    }

    for(int j = 0; j < intArray.length; j++) {
        System.out.println(intArray[j]);
    }

}

public static long numbGen() {

    long numb = (long)(Math.random() * 10000000 * 1000000); // had to use this as int's are to small for a 13 digit number.

    return numb;
}
}

我的问题现在有时它会在20组中产生几个12位数字，我想找到一种方法，如果它不是13位，就不要将数字添加到数组中。我已经尝试过声明，但却因为无法确定Long的长度（个别字符）而感到困惑。

先谢谢。

Answer 1

一个简单的解决方案：

    while(test < 10000) {
        long num = (long) (Math.random() * 100000000 * 1000000);
        if(Long.toString(num).length() == 13) {
            return num;
        }
        test++;
    }

然而，更好的解决方案是：

long number = (long) Math.floor(Math.random() * 9000000000000L) + 1000000000000L;

这只会生成随机的13位数字，您无需检查是否有更多或更少的数字。

请注意，此解决方案可能无法扩展到更高的位数，并且可能无法返回随机数的完美分布。

Answer 2

long min = 1000000000000L; //13 digits inclusive
long max = 10000000000000L; //14 digits exclusive
Random random = new Random()
long number = min+((long)(random.nextDouble()*(max-min)));

Answer 3

基于通用整数的实现将是：

public static long randomDigits(int digits) {
    if (digits <= 0 || digits > 18) {
        throw new IllegalArgumentException("A long can store the random of 18 full digits, you required: " + digits);
    }

    // use SecureRandom instead for truly random values
    final Random r = new Random();
    long randomNumber = r.nextInt(9) + 1;
    for (int i = 1; i < digits; i++) {
        randomNumber = randomNumber * 10L + (long) r.nextInt(10);
    }
    return randomNumber;
}

或使用13个数字的较短版本，不会对RNG征税：

public static long thirteenRandomDigits() {
    final Random r = new Random();
    return 1_000_000_000L * (r.nextInt(9_000) + 1_000)
            + r.nextInt(1_000_000_000);
}

这些解决方案更适合使用Math.random()，因为它们不依赖于大数乘法来生成随机值。双精度只有15-17位精度，非常接近它乘以的13位数。这导致随机数的不均匀分布。基于Math.random()的解决方案也不会超过13位。

Answer 4

您所描述问题的简单解决方案：

public static long numbGen() {
    while (true) {
        long numb = (long)(Math.random() * 100000000 * 1000000); // had to use this as int's are to small for a 13 digit number.
        if (String.valueOf(numb).length() == 13)
            return numb;
    }
}

这不是生成13位数字的最有效或最随机的实现，但它会回答您的特定问题。

Answer 5

首先，Long没有字符。

如果您想查看它是否有13位数字，请将其与999999999999L进行比较。

如果您想确保您的值为13位数，请获取介于0和8999999999999L（含）之间的随机数（使用您已有的技术生成范围内的随机数）并将其添加到1000000000000L。

Answer 6

long randomNumber = 0;
long power = 1;

for(int i = 0; i < 12; i++) { // up to 12 not 13
    Random r = new Random();
    int randomInt = r.nextInt(10);

    randomNumber += (power * randomInt);
    power *= 10;
}

// here, the most stupid way to provide last digit to be not zero
Random r = new Random();
int randomInt = r.nextInt(9);
randomInt++;

randomNumber += (power * randomInt);
power *= 10;

Answer 7

ThreadLocalRandom是一件好事，在Java 1.7中引入

java.util.concurrent.ThreadLocalRandom
    .current()
    .nextLong(1000000000000L, 10000000000000L);

Answer 8

为什么我们不尝试使用毫秒时间的Unix时间戳。因为这将在未来200年内有效，之后我们只需要从数字中删除尾随数字。

Calendar.getInstance().get(Calendar.MILLISECOND);

并且通过使用这种方法，我们不需要任何循环或任何条件，它每次都会给我一个唯一的数字。

用Java制作13位随机数发生器

8 个答案: