Random (Java Platform SE 8)

java.lang.Object
- java.util.Random

すべての実装されたインタフェース:

Serializable

直系の既知のサブクラス:

SecureRandom, ThreadLocalRandom
```
public class Random
extends Object
implements Serializable
```
このクラスのインスタンスは、一連の擬似乱数を生成するために使用されます。クラスでは48ビットのシードを使い、このシードは線形合同法で変更されます。詳細はDonald Knuth著『The Art of Computer Programming, Volume 2』のセクション3.2.1を参照してください。
2つのRandomインスタンスが同じシードで生成されている場合、それぞれに対して同じシーケンスでメソッド呼出しを行うと、同じシーケンスで数値が生成され返されます。この特性を保証するために、Randomクラスには固有のアルゴリズムが指定されています。 Javaコードの絶対的な移植性の保持のために、Javaの実装はここに示されているRandomクラスのアルゴリズムをすべて使用する必要があります。ただし、Randomクラスのサブクラスは、すべてのメソッドの一般規約に準拠したものであればほかのアルゴリズムも使用できます。
Randomクラスによって実装されるアルゴリズムでは、各呼出しで擬似乱数的に生成された最大32ビットを提供できるprotectedユーティリティ・メソッドが使用されます。
多くのアプリケーションの場合、Math.random()メソッドを使うほうが簡単です。
java.util.Randomのインスタンスはスレッド・セーフです。ただし、複数のスレッドで同じjava.util.Randomインスタンスを並行して使用すると、競合が発生してパフォーマンスが低下する可能性があります。マルチ・スレッド設計では、代わりにThreadLocalRandomを使用することを検討してください。
java.util.Randomのインスタンスには安全な暗号化が施されていません。セキュリティ保護を必要とするアプリケーションで使用するために安全な暗号化の施された擬似乱数ジェネレータを取得するには、代わりにSecureRandomを使用することを検討してください。

導入されたバージョン:

1.0

関連項目:

直列化された形式

コンストラクタのサマリー

コンストラクタ
コンストラクタ	説明
`Random()`	新規乱数ジェネレータを作成します。
`Random(long seed)`	単一の`long`型のシードを使って、新しい乱数ジェネレータを作成します。

メソッドのサマリー

すべてのメソッドインスタンス・メソッド具象メソッド
修飾子と型	メソッド	説明
`DoubleStream`	`doubles()`	0(含む)から1(含まない)までの擬似乱数`double`値を含む、事実上無制限のストリームを返します。
`DoubleStream`	`doubles(double randomNumberOrigin, double randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`double`値を含む、事実上無制限のストリームを返します。
`DoubleStream`	`doubles(long streamSize)`	0(含む)から1(含まない)までの擬似乱数`double`値を、指定された`streamSize`数だけ生成するストリームを返します。
`DoubleStream`	`doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`double`値を、指定された`streamSize`数だけ生成するストリームを返します。
`IntStream`	`ints()`	擬似乱数`int`値を含む、事実上無制限のストリームを返します。
`IntStream`	`ints(int randomNumberOrigin, int randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`int`値を含む、事実上無制限のストリームを返します。
`IntStream`	`ints(long streamSize)`	擬似乱数`int`値を、指定された`streamSize`数だけ生成するストリームを返します。
`IntStream`	`ints(long streamSize, int randomNumberOrigin, int randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`int`値を、指定された`streamSize`数だけ生成するストリームを返します。
`LongStream`	`longs()`	擬似乱数`long`値を含む、事実上無制限のストリームを返します。
`LongStream`	`longs(long streamSize)`	擬似乱数`long`値を、指定された`streamSize`数だけ生成するストリームを返します。
`LongStream`	`longs(long randomNumberOrigin, long randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`long`値を含む、事実上無制限のストリームを返します。
`LongStream`	`longs(long streamSize, long randomNumberOrigin, long randomNumberBound)`	指定された起点(含む)と境界(含まない)に準拠した擬似乱数`long`を、指定された`streamSize`数だけ生成するストリームを返します。
`protected int`	`next(int bits)`	次の擬似乱数を生成します。
`boolean`	`nextBoolean()`	この乱数ジェネレータのシーケンスを使って、一様分布の`boolean`型の次の擬似乱数値を返します。
`void`	`nextBytes(byte[] bytes)`	ランダム・バイトを生成し、ユーザー指定のバイト配列に配置します。
`double`	`nextDouble()`	この乱数ジェネレータのシーケンスを使って、`0.0`から`1.0`の範囲で一様分布の`double`型の次の擬似乱数値を返します。
`float`	`nextFloat()`	この乱数ジェネレータのシーケンスを使って、`0.0`から`1.0`の範囲で一様分布の`float`型の次の擬似乱数値を返します。
`double`	`nextGaussian()`	この乱数ジェネレータのシーケンスを使って、平均`0.0`、標準偏差`1.0`のガウス(「正規」)分布の`double`型の擬似乱数値を返します。
`int`	`nextInt()`	この乱数ジェネレータのシーケンスを使って、一様分布の`int`型の次の擬似乱数値を返します。
`int`	`nextInt(int bound)`	この乱数ジェネレータのシーケンスを使って、0から指定された値の範囲(0は含むが、その指定された値は含まない)で一様分布の`int`型の擬似乱数値を返します。
`long`	`nextLong()`	この乱数ジェネレータのシーケンスを使って、一様分布の`long`型の次の擬似乱数値を返します。
`void`	`setSeed(long seed)`	単一の`long`型のシードを使って、この乱数ジェネレータのシードを設定します。

クラス java.lang.Objectから継承されたメソッド
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- コンストラクタの詳細
  - Random
```
public Random()
```
    新規乱数ジェネレータを作成します。このコンストラクタは、乱数ジェネレータのシードを、このコンストラクタの他の呼び出しと区別可能な値に設定します。
  - Random
```
public Random(long seed)
```
    単一のlong型のシードを使って、新しい乱数ジェネレータを作成します。シードは、擬似乱数ジェネレータの内部状態の初期値で、next(int)メソッドによって保守されます。
    呼び出しnew Random(seed)は次と等価です。
```
 
 Random rnd = new Random();
 rnd.setSeed(seed);
```
    パラメータ:
    
    seed - 初期シード
    
    関連項目:
    
    setSeed(long)
- メソッドの詳細
  - setSeed
```
public void setSeed(long seed)
```
    単一のlong型のシードを使って、この乱数ジェネレータのシードを設定します。 setSeedの一般規約では、シードとして引数seedを使って作成されたばかりの状態と同じになるように、この乱数ジェネレータ・オブジェクトの状態を変更します。 RandomクラスによるsetSeedメソッドの実装では、シードを次のように原始的に更新します。
```
 (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)
```
    また、nextGaussian()によって使用されるhaveNextNextGaussianフラグをクリアします。
    RandomクラスによるsetSeedの実装は、指定されたシードの48ビットだけを使用しています。ただし一般には、オーバーライドするメソッドは、long引数の64ビットすべてをシード値として使用できます。
    パラメータ:
    
    seed - 初期シード
  - next
```
protected int next(int bits)
```
    次の擬似乱数を生成します。このメソッドは、ほかのすべてのメソッドによって使われるので、サブクラスによってオーバーライドされます。
    nextの一般規約では、int型の値を返し、引数bitsが1 - 32 (1と32を含む)の範囲の場合は、戻り値の多くの下位ビットが(ほぼ)独立に選択されたビット値になり、それぞれの値は(ほぼ)均等に0または1になります。 Randomクラスによるnextメソッドの実装では、シードを
```
 (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)
```
    に原始的に更新し、次の値を返します。
```
 (int)(seed >>> (48 - bits)).
```
    これは、D. H. Lehmerによって定義された、線形合同擬似乱数ジェネレータです。 Knuth著『The Art of Computer Programming, Volume 3: Seminumerical Algorithms』のセクション3.2.1。
    パラメータ:
    
    bits - ランダム・ビット
    
    戻り値:
    
    この乱数ジェネレータのシーケンスに基づく次の擬似乱数値
    
    導入されたバージョン:
    
    1.1
  - nextBytes
```
public void nextBytes(byte[] bytes)
```
    ランダム・バイトを生成し、ユーザー指定のバイト配列に配置します。作成されるランダム・バイトの数は、バイト配列の長さと等しくなります。
    RandomクラスによるnextBytesメソッドの実装は、次と同等です。
```
 
 public void nextBytes(byte[] bytes) {
   for (int i = 0; i < bytes.length; )
     for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
          n-- > 0; rnd >>= 8)
       bytes[i++] = (byte)rnd;
 }
```
    パラメータ:
    
    bytes - 乱数バイトを格納するバイト配列
    
    例外:
    
    NullPointerException - バイト配列がnullである場合
    
    導入されたバージョン:
    
    1.1
  - nextInt
```
public int nextInt()
```
    この乱数ジェネレータのシーケンスを使って、一様分布のint型の次の擬似乱数値を返します。 nextIntの一般規約では、1つのint型の値が擬似乱数として生成されて返されます。 2³²個のすべての可能なint値が(ほぼ)均等な確率で生成されます。
    RandomクラスによるnextIntメソッドの実装は、次と同等です。
```
 
 public int nextInt() {
   return next(32);
 }
```
    戻り値:
    
    この乱数ジェネレータのシーケンスを使って生成された、一様分布のint型の次の擬似乱数値
  - nextInt
```
public int nextInt(int bound)
```
    この乱数ジェネレータのシーケンスを使って、0から指定された値の範囲(0は含むが、その指定された値は含まない)で一様分布のint型の擬似乱数値を返します。 nextIntの一般規約では、指定された範囲内の1つのint型の値が擬似乱数として生成されて返されます。 bound個のすべての可能なint値が(ほぼ)均等な確率で生成されます。 nextInt(int bound)メソッドは、Randomクラスによって次のように実装されます。
```
 
 public int nextInt(int bound) {
   if (bound <= 0)
     throw new IllegalArgumentException("bound must be positive");

   if ((bound & -bound) == bound)  // i.e., bound is a power of 2
     return (int)((bound * (long)next(31)) >> 31);

   int bits, val;
   do {
       bits = next(31);
       val = bits % bound;
   } while (bits - val + (bound-1) < 0);
   return val;
 }
```
    上記の説明で「ほぼ」という言葉を使用しているのは、nextメソッドが単にほとんど無関係に選択されたビットの中立的なソースだからです。ランダムに選択されたビットの完全なソースであるとすれば、示されたアルゴリズムは指定された範囲から完全な一貫性でint型の値を選択することになります。
    このアルゴリズムは多少扱いづらい面があります。このアルゴリズムは一様でない分布になる値を拒絶します(2^31がnで割れないことによる)。値が拒絶される確率はnによって異なります。最悪のケースはn=2^30+1で、この場合、拒絶の確率は1/2になり、ループが強制終了するまでの予想される反復回数は2回です。
    このアルゴリズムは、nが2の累乗であるケースを特別に処理します。このアルゴリズムは、基になる擬似乱数ジェネレータから適切な数の上位ビットを返します。特別な処理がない場合は、適切な数の下位ビットが返されます。このクラスで実装されているような線形合同擬似乱数ジェネレータは、下位ビットの値のシーケンスで周期が短いことが知られています。そのため、この特別なケースでは、nが2の小さな累乗である場合、このメソッドの連続した呼出しによって返される値のシーケンスの長さが大幅に長くなります。
    パラメータ:
    
    bound - 上限(含まない)。正の値でなければならない
    
    戻り値:
    
    この乱数ジェネレータのシーケンスを使った、0(含む)からbound(含まない)の範囲で一様分布の、int型の次の擬似乱数値
    
    例外:
    
    IllegalArgumentException - boundが正でない場合
    
    導入されたバージョン:
    
    1.2
  - nextLong
```
public long nextLong()
```
    この乱数ジェネレータのシーケンスを使って、一様分布のlong型の次の擬似乱数値を返します。 nextLongの一般規約では、1つのlong型の値が擬似乱数として生成されて返されます。
    RandomクラスによるnextLongメソッドの実装は、次と同等です。
```
 
 public long nextLong() {
   return ((long)next(32) << 32) + next(32);
 }
```
    Randomクラスは48ビットのみを含むシードを使用するため、このアルゴリズムは可能なすべてのlong値の一部しか返しません。
    戻り値:
    
    この乱数ジェネレータのシーケンスを使って生成された、一様分布のlong型の次の擬似乱数値
  - nextBoolean
```
public boolean nextBoolean()
```
    この乱数ジェネレータのシーケンスを使って、一様分布のboolean型の次の擬似乱数値を返します。 nextBooleanの一般規約では、1つのboolean型の値が擬似乱数として生成されて返されます。値trueとfalseが(ほぼ)均等な確率で生成されます。
    RandomクラスによるnextBooleanメソッドの実装は、次と同等です。
```
 
 public boolean nextBoolean() {
   return next(1) != 0;
 }
```
    戻り値:
    
    この乱数ジェネレータのシーケンスを使って生成された、一様分布のboolean型の次の擬似乱数値
    
    導入されたバージョン:
    
    1.2
  - nextFloat
```
public float nextFloat()
```
    この乱数ジェネレータのシーケンスを使って、0.0から1.0の範囲で一様分布のfloat型の次の擬似乱数値を返します。
    nextFloatの一般規約では、0.0fから1.0fの範囲(0.0fは含むが、1.0fは含まない)から(ほぼ)均等な確率で選択された1つのfloat値が擬似乱数として生成されて返されます。形式m x 2^-24(mは2²⁴未満の正の整数)の、2²⁴個のすべての可能なfloat値が(ほぼ)均等な確率で生成されます。
    RandomクラスによるnextFloatメソッドの実装は、次と同等です。
```
 
 public float nextFloat() {
   return next(24) / ((float)(1 << 24));
 }
```
    上記の説明で「ほぼ」という言葉を使用しているのは、nextメソッドが単にほとんど無関係に選択されたビットの中立的なソースだからです。ランダムに選択されたビットの完全なソースであるとすれば、示されたアルゴリズムは指定された範囲から完全な一貫性でfloat型の値を選択することになります。
    [以前のバージョンのJavaでは、結果は次のように誤って計算されました。
```
 
   return next(30) / ((float)(1 << 30));
```
    これでもある程度等しく思われますが、実際には、浮動小数点数の丸めでのバイアスのために多少のばらつきが生じるので、有効数字の下位ビットが、1よりも0になることが多くなりがちでした。]
    戻り値:
    
    この乱数ジェネレータのシーケンスを使って生成された、0.0から1.0の範囲の一様分布のfloat型の次の擬似乱数値
  - nextDouble
```
public double nextDouble()
```
    この乱数ジェネレータのシーケンスを使って、0.0から1.0の範囲で一様分布のdouble型の次の擬似乱数値を返します。
    nextDoubleの一般規約では、0.0dから1.0dの範囲(0.0fは含むが、1.0fは含まない)から(ほぼ)均等な確率で選択された1つのdouble値が擬似乱数として生成されて返されます。
    RandomクラスによるnextDoubleメソッドの実装は、次と同等です。
```
 
 public double nextDouble() {
   return (((long)next(26) << 27) + next(27))
     / (double)(1L << 53);
 }
```
    上記の説明で「ほぼ」という言葉を使用しているのは、独立して選択されたビットのソースとしてnextメソッドが偏りがないのは、近似的にのみ成立するからです。ランダムに選択されたビットの完全なソースであるとすれば、示されたアルゴリズムは指定された範囲から完全な一貫性でdouble型の値を選択することになります。
    [以前のバージョンのJavaでは、結果は次のように誤って計算されました。
```
 
   return (((long)next(27) << 27) + next(27))
     / (double)(1L << 54);
```
    これは同等のように見えますが(良くはないにしても)、実際には浮動小数点数の丸めでのバイアスのために大きなばらつきが生じていました。有効数字の下位ビットが0になる(1ではなく)可能性が3倍ありました。この程度のばらつきは実際には問題になりませんが、完全性を求めて修正を試みています。]
    戻り値:
    
    この乱数ジェネレータのシーケンスを使って生成された、0.0から1.0の範囲の一様分布のdouble型の次の擬似乱数値
    
    関連項目:
    
    Math.random()
  - nextGaussian
```
public double nextGaussian()
```
    この乱数ジェネレータのシーケンスを使って、平均0.0、標準偏差1.0のガウス(「正規」)分布のdouble型の擬似乱数値を返します。
    nextGaussianの一般規約では、平均0.0、標準偏差1.0のほぼ通常の正規分布から選択された1つのdouble値が、擬似乱数として生成されて返されます。
    RandomクラスによるnextGaussianメソッドの実装は、次のスレッド・セーフなバージョンと同等です。
```
 
 private double nextNextGaussian;
 private boolean haveNextNextGaussian = false;

 public double nextGaussian() {
   if (haveNextNextGaussian) {
     haveNextNextGaussian = false;
     return nextNextGaussian;
   } else {
     double v1, v2, s;
     do {
       v1 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       v2 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       s = v1 * v1 + v2 * v2;
     } while (s >= 1 || s == 0);
     double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
     nextNextGaussian = v2 * multiplier;
     haveNextNextGaussian = true;
     return v1 * multiplier;
   }
 }
```
    polar methodを使用します - これは、G. E. P. Box、M. E. Muller、およびG. Marsaglia、Donald E. Knuth著『The Art of Computer Programming』第3巻『Seminumerical Algorithms』のセクション3.4.1のC、アルゴリズムPで説明されています。 StrictMath.logとStrictMath.sqrtの1回ずつの呼び出しだけで2つの別々の値を生成することに注意してください。
    戻り値:
    
    この乱数ジェネレータのシーケンスを使った、平均0.0、標準偏差1.0のガウス(「正規」)分布のdouble型の次の擬似乱数値
  - ints
```
public IntStream ints(long streamSize)
```
    擬似乱数int値を、指定されたstreamSize数だけ生成するストリームを返します。
    メソッドnextInt()呼び出しの結果と同様に、擬似乱数int値が生成されます。
    
    パラメータ:
    
    streamSize - 生成する値の数
    
    戻り値:
    
    擬似乱数int値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合
    
    導入されたバージョン:
    
    1.8
  - ints
```
public IntStream ints()
```
    擬似乱数int値を含む、事実上無制限のストリームを返します。
    メソッドnextInt()呼び出しの結果と同様に、擬似乱数int値が生成されます。
    
    実装上のノート:
    
    このメソッドは、ints(Long.MAX_VALUE)と同等であるように実装されます。
    
    戻り値:
    
    擬似乱数int値のストリーム
    
    導入されたバージョン:
    
    1.8
  - ints
```
public IntStream ints(long streamSize,
                      int randomNumberOrigin,
                      int randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数int値を、指定されたstreamSize数だけ生成するストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数int値が生成されます。
```
 
 int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // range not representable as int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
```
    パラメータ:
    
    streamSize - 生成する値の数
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と境界(含まない)が指定された、擬似乱数int値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合、またはrandomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8
  - ints
```
public IntStream ints(int randomNumberOrigin,
                      int randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数int値を含む、事実上無制限のストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数int値が生成されます。
```
 
 int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // range not representable as int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
```
    実装上のノート:
    
    このメソッドは、ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)と同等であるように実装されます。
    
    パラメータ:
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と境界(含まない)が指定された、擬似乱数int値のストリーム
    
    例外:
    
    IllegalArgumentException - randomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8
  - longs
```
public LongStream longs(long streamSize)
```
    擬似乱数long値を、指定されたstreamSize数だけ生成するストリームを返します。
    メソッドnextLong()呼び出しの結果と同様に、擬似乱数long値が生成されます。
    
    パラメータ:
    
    streamSize - 生成する値の数
    
    戻り値:
    
    擬似乱数long値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合
    
    導入されたバージョン:
    
    1.8
  - longs
```
public LongStream longs()
```
    擬似乱数long値を含む、事実上無制限のストリームを返します。
    メソッドnextLong()呼び出しの結果と同様に、擬似乱数long値が生成されます。
    
    実装上のノート:
    
    このメソッドは、longs(Long.MAX_VALUE)と同等であるように実装されます。
    
    戻り値:
    
    擬似乱数long値のストリーム
    
    導入されたバージョン:
    
    1.8
  - longs
```
public LongStream longs(long streamSize,
                        long randomNumberOrigin,
                        long randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数longを、指定されたstreamSize数だけ生成するストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数long値が生成されます。
```
 
 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // power of two
     r = (r & m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) < 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
```
    パラメータ:
    
    streamSize - 生成する値の数
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と境界(含まない)が指定された、擬似乱数long値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合、またはrandomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8
  - longs
```
public LongStream longs(long randomNumberOrigin,
                        long randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数long値を含む、事実上無制限のストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数long値が生成されます。
```
 
 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // power of two
     r = (r & m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) < 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
```
    実装上のノート:
    
    このメソッドは、longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)と同等であるように実装されます。
    
    パラメータ:
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と境界(含まない)が指定された、擬似乱数long値のストリーム
    
    例外:
    
    IllegalArgumentException - randomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8
  - doubles
```
public DoubleStream doubles(long streamSize)
```
    0(含む)から1(含まない)までの擬似乱数double値を、指定されたstreamSize数だけ生成するストリームを返します。
    メソッドnextDouble()の呼出しの結果と同様に、擬似乱数double値が生成されます。
    
    パラメータ:
    
    streamSize - 生成する値の数
    
    戻り値:
    
    double値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合
    
    導入されたバージョン:
    
    1.8
  - doubles
```
public DoubleStream doubles()
```
    0(含む)から1(含まない)までの擬似乱数double値を含む、事実上無制限のストリームを返します。
    メソッドnextDouble()の呼出しの結果と同様に、擬似乱数double値が生成されます。
    
    実装上のノート:
    
    このメソッドは、doubles(Long.MAX_VALUE)と同等であるように実装されます。
    
    戻り値:
    
    擬似乱数double値のストリーム
    
    導入されたバージョン:
    
    1.8
  - doubles
```
public DoubleStream doubles(long streamSize,
                            double randomNumberOrigin,
                            double randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数double値を、指定されたstreamSize数だけ生成するストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数double値が生成されます。
```
 
 double nextDouble(double origin, double bound) {
   double r = nextDouble();
   r = r * (bound - origin) + origin;
   if (r >= bound) // correct for rounding
     r = Math.nextDown(bound);
   return r;
 }
```
    パラメータ:
    
    streamSize - 生成する値の数
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と限界(含まない)が指定された、擬似乱数double値のストリーム
    
    例外:
    
    IllegalArgumentException - streamSizeが0未満の場合
    
    IllegalArgumentException - randomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8
  - doubles
```
public DoubleStream doubles(double randomNumberOrigin,
                            double randomNumberBound)
```
    指定された起点(含む)と境界(含まない)に準拠した擬似乱数double値を含む、事実上無制限のストリームを返します。
    起点と境界を指定した次のメソッド呼び出しの結果と同様に、擬似乱数double値が生成されます。
```
 
 double nextDouble(double origin, double bound) {
   double r = nextDouble();
   r = r * (bound - origin) + origin;
   if (r >= bound) // correct for rounding
     r = Math.nextDown(bound);
   return r;
 }
```
    実装上のノート:
    
    このメソッドは、doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)と同等であるように実装されます。
    
    パラメータ:
    
    randomNumberOrigin - 各乱数値の起点(含む)
    
    randomNumberBound - 各乱数値の境界(含まない)
    
    戻り値:
    
    それぞれ起点(含む)と限界(含まない)が指定された、擬似乱数double値のストリーム
    
    例外:
    
    IllegalArgumentException - randomNumberOriginがrandomNumberBound以上の場合
    
    導入されたバージョン:
    
    1.8

バグまたは機能を送信
詳細なAPIリファレンスおよび開発者ドキュメントについては、Java SEのドキュメントを参照してください。そのドキュメントには、概念的な概要、用語の定義、回避方法、有効なコード例などの、開発者を対象にしたより詳細な説明が含まれています。
Copyright © 1993, 2025, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Documentation Redistribution Policyも参照してください。

クラスRandom

コンストラクタのサマリー

メソッドのサマリー

クラス java.lang.Objectから継承されたメソッド

コンストラクタの詳細

Random

Random

メソッドの詳細

setSeed

next

nextBytes

nextInt

nextInt

nextLong

nextBoolean

nextFloat

nextDouble

nextGaussian

ints

ints

ints

ints

longs

longs

longs

longs

doubles

doubles

doubles

doubles