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




number generator (25)

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

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

Random 클래스를 사용하면됩니다.

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

또 다른 옵션은 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.


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

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

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

이 메서드는 제공된 최소값과 최대 값 사이 의 임의의 숫자를 반환합니다.

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

이 메서드는 제공된 min 및 max 값 에서 임의의 숫자 반환합니다 (생성 된 숫자도 최소 또는 최대 숫자 일 수 있습니다).

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

    return randomNumber;
}

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


이 접근법은 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))

예를 들어 보겠습니다.

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

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


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)를 확인하십시오 .


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

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

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


용도:

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

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

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

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

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

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

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

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


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

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

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

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


까다로운 것에 대해 저를 용서하십시오. 그러나 대다수가 제안한 해결책, 즉 min + rng.nextInt(max - min + 1)) 과 같은 사실 때문에 위험한 것으로 보입니다.

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

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

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 % 이상이어야합니다.


다음은 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)


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

이것은 잘 작동합니다.


Integer.parseInt(yourString)

다음 사항을 기억하십시오.

Integer.parseInt("1"); // ok

Integer.parseInt("-1"); // ok

Integer.parseInt("+1"); // ok

Integer.parseInt(" 1"); // 예외 (공백)

Integer.parseInt("2147483648"); // 예외 (정수는 최대 값 2,147,483,647로 제한됩니다.)

Integer.parseInt("1.1"); // 예외 ( . 또는 허용되지 않는 것)

Integer.parseInt(""); // 예외 (0이 아닌)

한 가지 예외 유형이 있습니다 : NumberFormatException





java random integer