モジュール java.base
パッケージ 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型のシードを使って、この乱数ジェネレータのシードを設定します。
    • コンストラクタの詳細

      • 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型の値を返し、引数bits1 - 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 2: 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型の値が擬似乱数として生成されて返されます。 232個のすべての可能な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型の値が擬似乱数として生成されて返されます。 truefalseが(ほぼ)均等な確率で生成されます。

        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は224未満の正の整数)の、224個のすべての可能な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』第2巻『Seminumerical Algorithms』のセクション3.4.1のC、アルゴリズムPで説明されています。 StrictMath.logStrictMath.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未満の場合、またはrandomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        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 - randomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        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未満の場合、またはrandomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        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 - randomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        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 - randomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        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 - randomNumberOriginrandomNumberBound以上の場合
        導入されたバージョン:
        1.8