java随机数不重复 - java随机数生成算法

从Java 7开始，您不应再使用Random 。 对于大多数用途，选择的随机数生成器现在是ThreadLocalRandom 。

对于fork连接池和并行流，请使用SplittableRandom 。

约书亚布洛赫。 有效的Java。 第三版。

从Java 8开始

对于fork连接池和并行流，使用通常更快的SplittableRandom ，与Random相比，具有更好的统计独立性和一致性属性。

要在[0, 1_000]:范围内生成随机int [0, 1_000]:

int n = new SplittableRandom().nextInt(0, 1_001);

要生成[0, 1_000]:范围内的随机int[100]值数组[0, 1_000]:

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

要返回随机值流：

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

ThreadLocalRandom等效于多线程环境的类java.util.Random。 在每个线程中本地执行生成随机数。 因此，通过减少冲突，我们可以获得更好的表现。

int rand = ThreadLocalRandom.current().nextInt(x,y);

x，y - 间隔例如（1,10）

使用nextint(n)方法生成min和max之差的随机数，然后将min number添加到结果中：

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

使用：

Random ran = new Random();
int x = ran.nextInt(6) + 5;

整数x现在是可能的结果为5-10的随机数。

另一种选择是使用Apache Commons ：

import org.apache.commons.math.random.RandomData;
import org.apache.commons.math.random.RandomDataImpl;

public void method() {
    RandomData randomData = new RandomDataImpl();
    int number = randomData.nextInt(5, 10);
    // ...
 }

只需使用Random类：

Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);

在Java 1.7或更高版本中 ，执行此操作的标准方法如下：

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

请参阅相关的JavaDoc 。 这种方法的优点是不需要显式初始化java.util.Random实例，如果使用不当，可能会造成混淆和错误。

然而，相反地，没有办法明确地设置种子，因此在有用的情况下（例如测试或保存游戏状态或类似情况）可能难以再现结果。 在这些情况下，可以使用下面显示的Java之前的1.7技术。

在Java 1.7之前 ，执行此操作的标准方法如下：

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

请参阅相关的JavaDoc 。 实际上， java.util.Random类通常比java.lang.Math.random()更可取。

特别是，当标准库中有一个简单的API来完成任务时，不需要重新发明随机整数生成轮。

在java-8他们在Random类中引入了方法ints(int randomNumberOrigin, int randomNumberBound) 。

例如，如果要在[0,10]范围内生成五个随机整数（或单个整数），只需执行以下操作：

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

第一个参数仅表示生成的IntStream的大小（这是生成无限IntStream方法的重载方法）。

如果需要进行多次单独调用，可以从流中创建无限原始迭代器：

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

您也可以为double和long值执行此操作。

希望能帮助到你！ :)

如果您想尝试上述投票最多的答案，您可以使用以下代码：

public class Randomizer
{
    public static int generate(int min,int max)
    {
        return min + (int)(Math.random() * ((max - min) + 1));
    }

    public static void main(String[] args)
    {
        System.out.println(Randomizer.generate(0,10));
    }
}

它干净而简单。

当您需要大量随机数时，我不推荐API中的Random类。 这个时期太短了。 试试Mersenne twister代替。 有一个Java实现 。

您可以编辑第二个代码示例：

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;

我发现这个例子生成随机数 ：

此示例生成特定范围内的随机整数。

import java.util.Random;

/** Generate random integers in a certain range. */
public final class RandomRange {

  public static final void main(String... aArgs){
    log("Generating random integers in the range 1..10.");

    int START = 1;
    int END = 10;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }

    log("Done.");
  }

  private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    // compute a fraction of the range, 0 <= frac < range
    long fraction = (long)(range * aRandom.nextDouble());
    int randomNumber =  (int)(fraction + aStart);    
    log("Generated : " + randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
} 

此类的示例运行：

Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.

最好使用SecureRandom而不仅仅是Random。

public static int generateRandomInteger(int min, int max) {
    SecureRandom rand = new SecureRandom();
    rand.setSeed(new Date().getTime());
    int randomNum = rand.nextInt((max - min) + 1) + min;
    return randomNum;
}

让我们举个例子。

假设我希望生成5-10之间的数字：

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

让我们理解这一点 ......

使用最高值初始化max，使用最低值初始化min。

现在，我们需要确定可以获得多少可能的值。 对于这个例子，它将是：

5,6,7,8,9,10

因此，这将是最大 - 最小+ 1的计数。

即10 - 5 + 1 = 6

随机数将生成0-5之间的数字。

即0,1,2,3,4,5

将min值添加到随机数将产生：

5,6,7,8,9,10

因此，我们获得了所需的范围。

请注意，这种方法比nextInt方法更具偏见且效率更低， https://.com/a/738651/360211 ： nextInt

实现这一目标的一个标准模式是：

Min + (int)(Math.random() * ((Max - Min) + 1))

Java Math库函数Math.random（）生成范围[0,1)的double值。 请注意，此范围不包括1。

为了首先获得特定范围的值，您需要乘以您想要覆盖的值范围的大小。

Math.random() * ( Max - Min )

这将返回[0,Max-Min)范围内的值，其中不包括“Max-Min”。

例如，如果你想要[5,10) ，你需要覆盖五个整数值，以便你使用

Math.random() * 5

这将返回[0,5)范围内的值，其中不包括5。

现在，您需要将此范围更改为您要定位的范围。 您可以通过添加Min值来完成此操作。

Min + (Math.random() * (Max - Min))

您现在将获得[Min,Max)范围内的值。 按照我们的例子，这意味着[5,10) ：

5 + (Math.random() * (10 - 5))

但是，这仍然不包括Max ，你得到的是双倍价值。 为了获得Max值，您需要在范围参数(Max - Min)加1，然后通过强制转换为int来截断小数部分。 这是通过以下方式完成

Min + (int)(Math.random() * ((Max - Min) + 1))

你有它。 [Min,Max]或每个示例[5,10]范围内的随机整数值：

5 + (int)(Math.random() * ((10 - 5) + 1))

这是一个有用的类，可以在包含/包含任意组合的范围内生成随机ints ：

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}

这种方法可能很方便使用：

此方法将在提供的最小值和最大值之间返回一个随机数：

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

并且此方法将从提供的最小值和最大值返回一个随机数（因此生成的数字也可以是最小值或最大值）：

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

 rand.nextInt((max+1) - min) + min;

private static Random random = new Random();    

public static int getRandomInt(int min, int max){
  return random.nextInt(max - min + 1) + min;
}

要么

public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}

public static Random RANDOM = new Random(System.nanoTime());

public static final float random(final float pMin, final float pMax) {
    return pMin + RANDOM.nextFloat() * (pMax - pMin);
}