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`.
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がある場合は、ランダムな整数生成ホイールを作り直す必要はありません。
このアプローチはnextIntアプローチよりも偏りがあり効率が悪いことに注意してください。 https://stackoverflow.com/a/738651/360211
これを達成するための1つの標準的なパターンは次のとおりです。
Min + (int)(Math.random() * ((Max - Min) + 1))
Java Mathライブラリ関数Math.random（）は、[0,1)の範囲のdouble値を生成します。この範囲に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は含まれておらず、あなたはdouble値を得ています。 Max値を含めるには、範囲パラメータ(Max - Min)に1を追加してから、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 と共に Random クラスに ints(int randomNumberOrigin, int randomNumberBound) というメソッドを導入しました。
たとえば、[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のサイズのみを示します（これは無制限の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 の実装についてはこちらを参照してください。
マルチスレッド環境では、ThreadLocalRandomはJava.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);
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）を調べてください。
頑固であることを私に許してください、しかし大多数によって提案された解決策、すなわちmin + rng.nextInt(max - min + 1))は、以下の事実のために危険に思えます：
rng.nextInt(n)はInteger.MAX_VALUEに到達できません。minが負の場合、(max - 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
例を挙げましょう。
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);
これを理解しましょう ...
Maxを最大値で、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
それ故、我々は所望の範囲を得る。
Rand.nextInt((max+1) - min) + min;
nextint（n） メソッドを使用して最小値と最大値の差に乱数を生成してから、結果に最小値を追加します。
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
Java 7以降、
Randomを使用しないでください。ほとんどの用途では、乱数ジェネレータの選択は[ThreadLocalRandomになりました。
フォーク結合プールおよび並列ストリームの場合は、SplittableRandomを使用します。
ジョシュアブロッホ。効果的なJava第3版。
Java 8以降
フォークジョインプールとパラレルストリームには、通常は高速で、統計的な独立性と統一性がSplittableRandomより優れているRandomを使用します。
[0, 1_000]:の範囲でランダムなintを生成する
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);
サイコロを振る場合、それは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;
}
}
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
または Apache Commons からRandomUtilsを見てください。
「2つの数字の間に」乱数を生成するには、次のコードを使用します。
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
これは1（両端を含む）と11（排他的）の間の乱数を与えるので、1を加えることによってupperBound値を初期化します。 10。
このメソッドは使いやすいかもしれません：
このメソッドは乱数 から までの最小値と最大値を返します。
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;
}
}
そしてこのメソッドは乱数 from 与えられた最小値と最大値を返します（そのため、生成された数は最小値または最大値にもなります）。
public static int getRandomNumberFrom(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt((max + 1) - min) + min;
return randomNumber;
}
Random クラスを使うだけです。
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
私はこの例を見つけました 乱数を生成します ：
この例では、特定の範囲の乱数を生成します。
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.
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 twister を試してください。 Javaの実装 があります。
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);
}
もう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);
// ...
}
閉じた[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;
}
}
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + 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));
}
}
それはただきれいでシンプルです。
単なる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;
これはうまくいっています。
私はこれを使う：
/**
* @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;
}
必要に応じて整数にキャストすることができます。
import Java.util.Random;
public class RandomUtil {
// Declare as class variable so that it is not re-seeded every call
private static Random random = new Random();
/**
* Returns a psuedo-random number between min and max (both inclusive)
* @param min Minimim value
* @param max Maximim value. Must be greater than min.
* @return Integer between min and max (both inclusive)
* @see Java.util.Random#nextInt(int)
*/
public static int nextInt(int min, int max) {
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
return random.nextInt((max - min) + 1) + min;
}
}
あなたはこのようなことをすることができます：
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));
}
}
あなたはあなたの問題を解決するであろうこのコードスニペットを使うことができます：
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
MyRandomNumberを使用します（これにより範囲内の数値が得られます）。
Java 8のIntStreamとCollections.shuffleを使った別のアプローチ
import Java.util.stream.IntStream;
import Java.util.ArrayList;
import Java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
Scalaと同等のもの
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
質問によって提供された解決策の何が問題なのか、またその理由は何ですか。
解決策1：
randomNum = minimum + (int)(Math.random()*maximum);
問題：randomNumに最大値より大きい数値が割り当てられます。
説明：最小値が5で、最大値が10であるとします。0.6を超えるMath.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 random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
あなたが使用することができます
RandomStringUtils.randomNumeric(int count)
apache commonsからのメソッドもあります。
import Java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
また使用することができます
import Java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
ただし、このクラスはマルチスレッド環境ではうまく機能しません。
に次の変更を加えると、1 と試みることになります -
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
作業コードについては this を確認してください。
以下を使って、生成された乱数を望ましい範囲に線形正規化することを考えています。 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);
}
Math.random（）を使って乱数を生成し、それに大きな数を掛けます。10000としましょう。そこで、0から10,000の間の数を得て、この数をiと呼びます。さて、（x、y）の間の数字が必要なら、次のようにしてください。
i = x + (i % (y - x));
したがって、すべてのiはxとyの間の数です。
コメントで指摘されているように、バイアスを10000（または大きな数）で乗算するのではなく、バイアスを削除するには、バイアスを（y-x）で乗算します。
私はこのコードがうまくいくと思います。これを試してください。
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);
}
}
すでにCommons Lang API 2.xまたは最新バージョンを使用している場合は、乱数生成用のクラスが1つありますRandomUtils。
public static int nextInt(int n)
Math.random（）シーケンスから、0（両端を含む）と指定された値（両端を含まない）の間の一様分布の整数値を返します。
パラメーター： n - 指定された排他的最大値
int random = RandomUtils.nextInt(1000000);
注意： RandomUtils には乱数生成のための多くのメソッドがあります
以下のコードは100,000から900,000の間の乱数を生成します。このコードは6桁の値を生成します。このコードを使って6桁の _ otp _ を生成しています。
このランダムな方法を使用するにはimport Java.util.Randomを使用してください。
import Java.util.Random;
// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
Randomクラスを使用して乱数を生成してから、.nextInt（maxNumber）を使用して乱数を生成することができます。 maxNumberは、乱数を生成するときに最大にしたい数値です。ただし、Randomクラスでは0からmaxNumber-1までの数値が得られます。
Random r = new Random();
int i = r.nextInt();
これを行うもう1つの方法は、より効率的で新しいRandomオブジェクトを宣言する必要がないため、学校の多くのクラスで使用するMath.Random（）クラスを使用することです。 Math.Random（）を使用して乱数を取得するには、次のように入力します。
Math.random() * (max - min) + min;
乱数リスト with range（Min - Max） with 複製なし .
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);
}
}
これがお役に立てば幸いです。
私は与えられた範囲の中でユニークな整数を得るためのメソッドを作成しました。
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
0〜9の範囲で、0が最小で9が最大であるとします。下記の関数は0から9までの間の何でも印刷します。それはすべての範囲で同じです。
public static void main(String[] args) {
int b = randomNumberRange(0, 9);
int d = randomNumberRange (100, 200);
System.out.println("value of b is " + b);
System.out.println("value of d is " + d);
}
public static int randomNumberRange(int min, int max) {
int n = (max + 1 - min) + min;
return (int) (Math.random() * n);
}
私の友人の一人が今日同じ大学で同じ質問をしていました（彼の必要条件は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));
以下は、RandomとforEachを使った別の例です。
int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
https://sourceforge.net/projects/stochunit/ にライブラリがあります。
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
Edge包含/除外があります。
Aとbの間にn個の乱数を生成する簡単な方法[a]。例えば、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 _ を見てください。
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..max]の範囲からの乱数
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
一般的な用途にはRandomにJava.utilを使用してください。
あなたはそれらの結果を得るためにあなたの最小と最大の範囲を定義することができます。
Random Rand=new Random();
Rand.nextInt((max+1) - min) + min;
上記の提案のほとんどは 'オーバーフロー'を考慮していません、例えば：min = Integer.MIN_VALUE、max =100。私がこれまでに持っている正しいアプローチの1つは：
final long mod = max- min + 1L;
final int next = (int) (Math.abs(Rand.nextLong() % mod) + min);
これはこれを行う簡単な方法です。
import Java.util.Random;
class Example{
public static void main(String args[]){
/*-To test-
for(int i = 1 ;i<20 ; i++){
System.out.print(randomnumber()+",");
}
*/
int randomnumber = randomnumber();
}
public static int randomnumber(){
Random Rand = new Random();
int randomNum = Rand.nextInt(6) + 5;
return randomNum;
}
}
そこに5が乱数の出発点です。 6は5を含む範囲です。
ここで定義された範囲の整数の乱数を1つだけ返す関数ですlowerBoundIncludedandupperBoundIncluded、要求どおり = user42155
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 );
public static void main(String[] args) {
Random ran = new Random();
int min, max;
Scanner sc = new Scanner(System.in);
System.out.println("Enter min range:");
min = sc.nextInt();
System.out.println("Enter max range:");
max = sc.nextInt();
int num = ran.nextInt(min);
int num1 = ran.nextInt(max);
System.out.println("Random Number between given range is " + num1);
}
math.random()を使用して、ifステートメントに要件を設定してください。最も簡単で、最も簡単で、最も速いアプローチ
Java 8ストリームの使用
- InitialCapacityを渡す - 数字の数
- RandomBoundを渡す - xからrandomBoundに
- ソートされたかどうかについてtrue/falseを渡す
- 新しいRandom（）オブジェクトを渡す
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から数を生成します。
以下は、特定の範囲内でランダムな整数を生成する方法を示すサンプルクラスです。最大値として必要な任意の値を変数 'max'に割り当て、最小値として必要な任意の値を変数 'min'に割り当てます。
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max = 10;
int min = 5;
int x;
x = r.nextInt(max) + min;
System.out.println(x);
}
}
次のコードが使用される可能性があります。
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)