발생 - Java에서 특정 범위 내의 임의의 정수를 생성하는 방법은 무엇입니까?




java 임의 의 수 (20)

특정 범위에서 임의의 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`.

https://code.i-harness.com


Java 7 Random 더 이상 Random 사용하지 않아야합니다. 대부분의 용도에서 선택되는 난수 생성기는 이제 ThreadLocalRandom 입니다.

분기 결합 풀 및 병렬 스트림의 경우 SplittableRandom 사용하십시오.

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

Java 8부터

포크 결합 풀 및 병렬 스트림의 경우 일반적으로 더 빠른 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);

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

난수가 많이 필요한 경우 API의 Random 클래스는 권장하지 않습니다. 너무 작은 기간이 있습니다. 대신에 Mersenne 트위스터 를 사용해보십시오. Java 구현이 있습니다.


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

구멍 클래스의 필드로 다시 사용할 수 있으며 모든 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;
    }
}

다중 스레드 환경의 경우 java.util.Random 클래스에 해당하는 ThreadLocalRandom. 난수 생성은 각 스레드에서 로컬로 수행됩니다. 따라서 우리는 갈등을 줄임으로써 더 나은 성과를 얻었습니다.

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

x, y - 간격 (예 : 1,10)


두 번째 코드 예제를 다음과 같이 편집 할 수 있습니다.

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

무작위가 아닌 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;
}

예를 들어 보겠습니다.

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

이걸 이해합시다 ...

가장 큰 값으로 min을 초기화하고 가장 작은 값으로 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

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


용도:

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

위의 투표에서 가장 많은 답을 얻으려면 다음 코드를 사용하십시오.

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

그것은 단지 깨끗하고 단순합니다.


이 예제는 난수 생성 :

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

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.

이 접근법은 nextInt 접근보다 편향되고 덜 효율적이라는 점에 유의 https://.com/a/738651/360211

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

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

Java 수학 라이브러리 함수 Math.random ()은 [0,1) 범위의 double 값을 생성합니다. 이 범위에는 1이 포함되지 않습니다.

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

Math.random() * ( Max - Min )

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

예를 들어, [5,10) 을 원한다면 5 개의 정수 값을 커버해야합니다.

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

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

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

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



nextint(n) 메서드를 사용하여 min과 max의 차이에 대한 난수를 생성 한 다음 결과에 min number를 추가합니다.

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

JavaMath.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.length25 를 돌려 i.length 때문에, nextInt( i.length )0-24 의 범위의 번호를 돌려줍니다. 다른 옵션은 같은 방식으로 작동하는 Math.Random 과 함께 사용됩니다.

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

더 나은 이해를 위해서 포럼 게시물 Random Intervals (archive.org)를 확인하십시오 .


java-8 에서는 Random 클래스에 ints(int randomNumberOrigin, int randomNumberBound) 메소드를 도입했습니다.

예를 들어 [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 값에 대해서도 수행 할 수 있습니다.

희망이 도움이됩니다! :)


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






integer