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インスタンスを明示的に初期化する必要がないという利点があります。不適切に使用すると、混乱やエラーの原因になる可能性があります。
ただし、逆に言えばシードを明示的に設定する方法がないため、テストやゲームの状態の保存など、シードが役立つ状況で結果を再現するのが難しい場合があります。このような状況では、以下に示す 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というアプローチよりも偏りがあり、効率が悪いことに注意してください
これを達成するための 1 つの標準的なパターンは次のとおりです。
Min + (int)(Math.random() * ((Max - Min) + 1))
Java Math ライブラリ関数 Math.random() は、範囲内のdouble 値を生成します[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)
Java-8ではints(int randomNumberOrigin, int randomNumberBound)、Randomクラスにメソッドが導入されました。
たとえば、[0, 10] の範囲で 5 つのランダムな整数 (または 1 つの整数) を生成する場合は、次のようにします。
Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
最初のパラメーターは、生成されたのサイズのみを示しますIntStream(これは、 unlimited を生成するメソッドのオーバーロードされたメソッドです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値に対しても実行できます。それが役立つことを願っています！:)
2 番目のコード例を次のように編集できます。
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間の乱数を生成するコードは次のようになります。0array.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ます。もう1つのオプションはMath.Random、同じように機能するものです。
index = (int) Math.floor(Math.random() * i.length);
理解を深めるために、フォーラムの投稿Random Intervals (archive.org)を確認してください。
次のステートメントを実行するだけで実行できます。
Randomizer.generate(0,10); //min of zero, max of ten
以下はそのソースコードです
public class Randomizer {
public static int generate(int min,int max) {
return min + (int)(Math.random() * ((max - min) + 1));
}
}
清潔でシンプルです。
うるさいことをお許しください。しかし、大多数が提案する解決策、つまり は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% 以上になることに注意してください。
Apache Commons Mathライブラリによって提供される乱数生成メソッドのいずれかが、法案に適合するかどうか疑問に思います。
例:RandomDataGenerator.nextIntまたはRandomDataGenerator.nextLong
私はこれを使用します：
/**
* @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;
}
必要に応じて、整数にキャストできます。
rand.nextInt((max+1) - 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;
}
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
または、 Apache Commonsの RandomUtils をご覧ください。
サイコロを振る場合、1 から 6 (0 から 6 ではない) の間の乱数になるため、次のようになります。
face = 1 + randomNumbers.nextInt(6);
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 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.
[min, max]これは、閉じた範囲から乱数を生成する方法を示す簡単なサンプルです。min <= max is true
穴クラスのフィールドとして再利用でき、すべてのRandom.classメソッドを 1 か所にまとめることもできます
結果の例:
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;
}
}
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;
}
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;
}
質問によって提供された解決策の何が問題であり、なぜエラーが発生したのかを簡単に述べます。
解決策 1:
randomNum = minimum + (int)(Math.random()*maximum);
問題: randomNum に最大値より大きい数値が割り当てられます。
説明: 最小値が 5 で、最大値が 10 であるとします。0.6Math.random()より大きい値は式を 6 以上に評価し、5 を追加すると 10 (最大値) より大きくなります。問題は、乱数に最大値を掛けて (最大値とほぼ同じ大きさの数値を生成します)、最小値を加算していることです。最小値が 1 でない限り、正しくありません。他の回答で述べたように、切り替える必要があります
randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))
+1 はMath.random()1.0 を返さないためです。
解決策 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
ここでの問題は、最初の項が 0 より小さい場合、「%」が負の数を返す可能性があることrn.nextInt()です。約 50% の確率で負の値を返すため、期待される結果も得られません。
しかし、これはほぼ完璧でした。Javadoc のnextInt(int n)をもう少し調べてみる必要がありました。その方法が利用可能で、
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum = minimum + i;
また、望ましい結果を返します。
問題を解決する次のコード スニペットを使用できます。
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
myRandomNumber を使用します (範囲内の数値が得られます)。
次のコードを使用できます。
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)
あなたが使用することができます
RandomStringUtils.randomNumeric(int count)
メソッドもApache Commonsからのものです。
以下を使用して、生成された乱数を目的の範囲に線形に正規化することを考えています。xを乱数としa、b希望する正規化数の最小範囲と最大範囲を とします。
以下は、線形マッピングによって生成された範囲をテストするための非常に単純なコード スニペットです。
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
次のようなことができます。
import java.awt.*;
import java.io.*;
import java.util.*;
import java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
Math.random() を使用して乱数を生成し、それを 10000 としましょうi。ここで、(x, y) の間に数値が必要な場合は、次のようにします。
i = x + (i % (y - x));
したがって、すべてiの は x と y の間の数値です。
コメントで指摘されているようにバイアスを取り除くには、バイアスに 10000 (または大きな数) を掛けるのではなく、(yx) を掛けます。
私の友人の1人が、今日の大学でこれと同じ質問をしました（彼の要件は、1から-1の間の乱数を生成することでした）。だから私はこれを書きました、そしてそれは私のテストで今のところうまくいきます。理想的には、範囲を指定して乱数を生成する方法はたくさんあります。これを試して：
働き：
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(rand-1);
float highRand = (float) Math.ceil(rand+1);
float genRand = (highRange-lowRange)*((rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
次のように実行します。
System.out.println( getRandomNumberBetween(1,-1));
これにより、重複のない範囲 (最小 - 最大)の乱数リストが生成されます。
generateRandomListNoDuplicate(1000, 8000, 500);
このメソッドを追加します。
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
これがあなたを助けることを願っています。
このコードはそれでうまくいくと思います。これを試してください：
import java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
org.apache.commons.lang.RandomStringUtilsクラスを使用してみてください。はい、隣接して繰り返される数値を与えることがありますが、5 から 15 の間の値を与えます。
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
上記の提案のほとんどは、「オーバーフロー」を考慮していません。たとえば、min = Integer.MIN_VALUE、max = 100 です。これまでの正しいアプローチの 1 つは次のとおりです。
final long mod = max- min + 1L;
final int next = (int) (Math.abs(rand.nextLong() % mod) + min);
a と b の間に n 個の乱数を生成する簡単な方法 (例: a =90、b=100、n =20)
Random r = new Random();
for(int i =0; i<20; i++){
System.out.println(r.ints(90, 100).iterator().nextInt());
}
r.ints()を返し、IntStreamいくつかの便利なメソッドを持っています。そのAPIを見てください。
user42155の要求に応じて、lowerBoundIncluded とで 定義された範囲内の整数乱数を 1 つだけ返す関数を次に示します。upperBoundIncluded
SplittableRandom splittableRandom = new SplittableRandom();
BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
-> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
randomInt.apply( …, … ); // gets the random number
...または乱数の1回限りの生成の場合は短くなります
new SplittableRandom().nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
Java 8 ストリームを使用して、
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
この例では、1-Randombound から数値を生成します。
次のスニペットは、0 から 10000 までのランダムな値を提供します。
import java.util.Random;
public class Main
{
public static void main(String[] args) {
Random rand = new Random();
System.out.printf("%04d%n", rand.nextInt(10000));
}
}