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

질문자 :user42155

특정 범위에서 임의의 int

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

시도 1:

 randomNum = minimum + (int)(Math.random() * maximum);

버그: randomNum maximum 보다 클 수 있습니다.

시도 2:

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

버그: randomNum minimum 보다 작을 수 있습니다.

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 인스턴스를 명시적으로 초기화할 필요가 없다는 장점이 있습니다. 이는 부적절하게 사용되는 경우 혼란과 오류의 원인이 될 수 있습니다.

그러나 반대로 시드를 명시적으로 설정하는 방법이 없으므로 게임 상태를 테스트하거나 저장하는 등 유용한 상황에서 결과를 재현하기 어려울 수 있습니다. 이러한 상황에서는 아래와 같은 pre-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가 있는 경우 임의의 정수 생성 휠을 재발명할 필요가 없습니다.

Greg Case

nextInt 접근 방식( https://stackoverflow.com/a/738651/360211) 보다 편향되고 덜 효율적입니다.

이를 수행하기 위한 한 가지 표준 패턴은 다음과 같습니다.

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

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

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

 Math.random() * ( Max - Min )

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

예를 들어 [5,10) 을 원하면 5개의 정수 값을 덮어야 하므로 다음을 사용합니다.

 Math.random() * 5

이것은 5가 포함되지 않은 [0,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))

TJ_Fischer

사용하다:

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

정수 x 5-10 의 가능한 결과를 갖는 난수입니다.

jackson

사용하다:

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

krosenvold

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 값에 대해서도 수행할 수 있습니다. 도움이 되기를 바랍니다! :)

Alexis C.

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

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

Bill the Lizard

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

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

---

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

hexabunny

ThreadLocalRandom 은 다중 스레드 환경의 경우 java.util.Random 클래스와 동일합니다. 난수 생성은 각 스레드에서 로컬로 수행됩니다. 따라서 충돌을 줄임으로써 더 나은 성능을 얻을 수 있습니다.

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

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

andrew

Java 의 Math.Random 클래스는 0부터 시작합니다. 따라서 다음과 같이 작성하면:

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

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

Matt R

다음 명령문을 수행하면 됩니다.

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

그냥 깨끗하고 심플합니다.

Abel Callejo

까다롭다는 점을 용서해 주십시오. 그러나 대다수가 제안한 해결책, 즉 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% 이상입니다.

Joel Sjöstrand

Apache Commons Math 라이브러리에서 제공하는 임의의 숫자 생성 방법이 청구서에 맞는지 궁금합니다.

예: RandomDataGenerator.nextInt 또는 RandomDataGenerator.nextLong

Chinnery

나는 이것을 사용한다:

 /** * @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; }

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

Simon

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

Michael Myers

예를 들어 보겠습니다.

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

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

Sunil Chawla

Random 사용하지 않아야 합니다. 대부분의 경우 난수 생성기는 이제 ThreadLocalRandom 입니다.

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

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

자바 8부터

포크 조인 풀 및 병렬 스트림의 경우 Random 에 비해 더 빠르고 통계적 독립성 및 균일성 속성이 더 나은 SplittableRandom 을 사용합니다.

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

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

[0, 1_000]: 범위의 값으로 구성된 임의의 int[100]

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

임의 값의 스트림을 반환하려면:

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

Oleksandr Pyrohov

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

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

gifpif

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

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

Prof Mo

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

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

이것은 1(포함)과 11(배타) 사이의 난수를 제공하므로 1을 추가하여 upperBound 값을 초기화합니다. 예를 들어, 1에서 10 사이의 난수를 생성하려면 upperBound 값을 11 대신 11로 초기화합니다. 10.

Lawakush Kurmi

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

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

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

Luke Taylor

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

 face = 1 + randomNumbers.nextInt(6);

sam

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

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

user2427

다음은 포함/배타 범위의 조합으로 범위에서 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; } }

Garrett Hall

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

user5150135

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

gerardw

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

AZ_

이 예를 찾았습니다. 난수 생성:

---

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

 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.

Hospes

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

Yakiv Mospan

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

이것은 잘 작동합니다.

ganesh

Random보다는 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; }

grep

출처 : 여기를 클릭하세요

출처 : http:www.stackoverflow.com/questions/363681/how-do-i-generate-random-integers-within-a-specific-range-in-java