Java의 특정 범위 내에서 임의의 정수를 어떻게 생성합니까?

int특정 범위에서 임의의 값을 생성하려면 어떻게합니까 ?

다음을 시도했지만 작동하지 않습니다.

시도 1 :

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

시도 2 :

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.

에서 나중에 자바 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가있는 경우 임의 정수 생성 휠을 재발 명할 필요가 없습니다.

이 방법은 https://stackoverflow.com/a/738651/360211nextInt 방법 보다 편향되어 비효율적입니다.

이를 달성하기위한 하나의 표준 패턴은 다음과 같습니다.

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

자바 수학 라이브러리 함수 인 Math.random ()는 범위의 두 값을 생성한다 [0,1). 이 범위에는 1이 포함되지 않습니다.

특정 범위의 값을 먼저 얻으려면 적용 할 값 범위의 크기를 곱해야합니다.

Math.random() * ( Max - Min )

[0,Max-Min)'Max-Min'이 포함되지 않은 범위의 값을 반환합니다 .

예를 들어 원하는 경우 [5,10)5 개의 정수 값을 포함해야합니다.

Math.random() * 5

[0,5)5 범위 에 포함되지 않은 범위의 값을 반환합니다 .

이제이 범위를 타겟팅하는 범위로 이동해야합니다. 최소값을 추가하면됩니다.

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

이제 범위 내의 값을 얻게됩니다 [Min,Max). 우리의 예에 따르면, 그것은 다음을 의미합니다 [5,10).

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

그러나 이것은 여전히 ​​포함 Max되어 있지 않으며 두 배의 가치를 얻고 있습니다. Max포함 된 값 을 얻으 려면 range 매개 변수에 1을 추가 (Max - Min)한 다음 int로 캐스팅하여 소수 부분을 잘라야합니다. 이것은 다음을 통해 달성됩니다.

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

그리고 거기 있습니다. 범위 [Min,Max]또는 예 에 따른 임의의 정수 값 [5,10]:

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

사용하다:

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

정수 x는 이제 가능한 결과가있는 난수입니다 5-10.

사용하다:

minimum + rn.nextInt(maxValue - minvalue + 1)

와 자바 -8그들은 수업 ints(int randomNumberOrigin, int randomNumberBound)에서 그 방법을 소개했습니다 Random.

예를 들어 [0, 10] 범위에서 5 개의 임의 정수 (또는 단일 정수)를 생성하려면 다음을 수행하십시오.

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값으로 도 할 수 있습니다 . 도움이 되길 바랍니다! :)

두 번째 코드 예제를 편집하여 다음을 수행 할 수 있습니다.

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

첫 번째 솔루션을 약간만 수정하면 충분합니다.

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

구현에 대한 자세한 내용은 여기를 참조하십시오 Random

ThreadLocalRandomjava.util.Random다중 스레드 환경 의 클래스와 동일 합니다. 난수 생성은 각 스레드에서 로컬로 수행됩니다. 따라서 충돌을 줄임으로써 성능이 향상됩니다.

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

x, y- 간격 예를 들어, (1,10)

Java 의 Math.Random클래스 는 0 기반입니다. 따라서 다음과 같이 작성하면

Random rand = new Random();
int x = rand.nextInt(10);

x0-9포함 사이에 있습니다 .

따라서 다음과 같은 25항목 배열이 주어지면 (배열의 0기준) 사이에 난수를 생성하는 코드 는 다음과 같습니다 array.length.

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

이후 i.length리턴 25상기는 nextInt( i.length )의 범위 사이의 수를 반환한다 0-24. 다른 옵션은 Math.Random동일한 방식으로 작동합니다.

index = (int) Math.floor(Math.random() * i.length);

더 잘 이해하려면 포럼 게시물 Random Intervals (archive.org)를 확인하십시오 .

까다로워서 용서해주십시오. 그러나 대다수가 제안한 해결책은 다음 min + rng.nextInt(max - min + 1))과 같은 사실 때문에 위험 해 보입니다.

• rng.nextInt(n)에 도달 할 수 없습니다 Integer.MAX_VALUE.
• (max - min)min음수 일 때 오버플로가 발생할 수 있습니다 .

완벽한 솔루션은 min <= max[ Integer.MIN_VALUE, Integer.MAX_VALUE] 내에서 올바른 결과를 반환합니다 . 다음 순진한 구현을 고려하십시오.

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

비효율적이지만 while루프 에서 성공할 확률 은 항상 50 % 이상입니다.

간단히 진술을 수행하면됩니다.

Randomizer.generate(0,10); //min of zero, max of ten

아래는 소스 코드입니다

Randomizer.java

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

깨끗하고 간단합니다.

Apache Commons Math 라이브러리에서 제공하는 난수 생성 방법 중 어느 것이나 법안에 맞는지 궁금합니다 .

예를 들어 : RandomDataGenerator.nextInt또는RandomDataGenerator.nextLong

예를 들어 보자.

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);

우리가 이것을 이해하자 ...

최대 값으로 최대 값을 초기화하고 최소값으로 최소값을 초기화하십시오.

이제 얻을 수있는 값의 수를 결정해야합니다. 이 예에서는 다음과 같습니다.

5, 6, 7, 8, 9, 10

따라서이 수는 최대-최소 + 1입니다.

즉 10-5 + 1 = 6

난수는 0-5 사이의 숫자를 생성합니다 .

즉, 0, 1, 2, 3, 4, 5

임의의 숫자에 최소값을 추가하면 다음 이 생성됩니다.

5, 6, 7, 8, 9, 10

따라서 원하는 범위를 얻습니다.

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

nextint (n) 메소드 를 사용하여 min과 max의 차이에 대한 난수를 생성 한 다음 결과에 최소 숫자를 추가하십시오.

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

나는 이것을 사용한다 :

 /**
   * @param min - The minimum.
   * @param max - The maximum.
   * @return A random double between these numbers (inclusive the minimum and maximum).
   */
 public static double getRandom(double min, double max) {
   return (Math.random() * (max + 1 - min)) + min;
 }

원하는 경우 정수로 캐스트 할 수 있습니다.

Java 7부터는 더 이상 사용하지 않아야합니다 Random. 대부분의 경우 임의의 숫자 생성기가 선택됩니다 ThreadLocalRandom.

포크 조인 풀 및 병렬 스트림의 경우을 사용하십시오 SplittableRandom.

조슈아 블로흐. 효과적인 자바. 세번째 판.

Java 8에서 시작

포크 조인 풀 및 병렬 스트림의 경우 SplittableRandom일반적으로 사용 하는 것이 더 빠르며 통계적 독립성 및 균일 성 특성이보다 빠릅니다 Random.

int범위에서 랜덤을 생성하려면[0, 1_000]:

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

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);

Random 클래스를 사용하십시오 .

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

이 방법은 사용하기 편리 할 수 ​​있습니다.

이 메소드는 제공된 최소값과 최대 값 사이 의 난수를 리턴 합니다.

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;
}

주사위를 굴릴 경우 1에서 6 사이의 난수 (0에서 6이 아님)가됩니다.

face = 1 + randomNumbers.nextInt(6);

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

또는 Apache Commons의 RandomUtils를 살펴보십시오 .

다음 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;
    }
}

"두 숫자 사이에"난수를 생성하려면 다음 코드를 사용하십시오.

Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;

이것은 1 (포함)과 11 (제외) 사이의 난수를 제공하므로 1을 추가하여 upperBound 값을 초기화하십시오. 예를 들어, 1 ~ 10 사이의 난수를 생성하려면 대신에 10.

Java 8에서 간결하게 달성 할 수 있습니다.

Random random = new Random();

int max = 10;
int min = 5;
int totalNumber = 10;

IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);

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);
}

또 다른 옵션은 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);
    // ...
 }

이 예제에서 난수 생성을 발견했습니다 .

이 예제는 특정 범위에서 임의의 정수를 생성합니다.

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 을 사용하는 것이 좋습니다.

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;
}

닫힌 [min, max]범위 에서 난수를 생성하는 방법을 보여주는 간단한 샘플은 다음과 같습니다.min <= max is true

홀 클래스에서 필드로 재사용 할 수 있으며 모든 Random.class방법을 한 곳에 배치 할 수도 있습니다

결과 예 :

RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert

출처 :

import junit.framework.Assert;
import java.util.Random;

public class RandomUtils extends Random {

    /**
     * @param min generated value. Can't be > then max
     * @param max generated value
     * @return values in closed range [min, max].
     */
    public int nextInt(int min, int max) {
        Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
        if (min == max) {
            return max;
        }

        return nextInt(max - min + 1) + min;
    }
}

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

이것은 잘 작동합니다.