ランダムクラスには、指定された範囲でランダムな整数を生成するメソッドがあります。例えば：

Random r = new Random(); 
int x = r.nextInt(100);

これは、0以上100未満のint数を生成します。長い数でもまったく同じようにしたいと思います。

long y = magicRandomLongGenerator(100);

ランダムクラスにはnextLong（）しかありませんが、範囲を設定することはできません。

始まったJava 7あなたが直接使用することができます（または= 5.0以上のAndroid APIレベル21）ThreadLocalRandom.current().nextLong(n)（≤X <nは0）とThreadLocalRandom.current().nextLong(m, n)（≤X <N Mのため）。詳細については、@ Alexの回答を参照してください。

あなたがで立ち往生している場合はJava 6の（またはAndroid 4.xの）あなたは外部ライブラリを使用する必要がある（例えばorg.apache.commons.math3.random.RandomDataGenerator.getRandomGenerator().nextLong(0, n-1)、参照@mawaldneの答えを）、または自分自身を実装しますnextLong(n)。

https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Random.htmlに よるとnextInt、

 public int nextInt(int n) {
     if (n<=0)
                throw new IllegalArgumentException("n must be positive");

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

     int bits, val;
     do {
         bits = next(31);
         val = bits % n;
     } while(bits - val + (n-1) < 0);
     return val;
 }

したがって、これを変更して実行することができますnextLong。

long nextLong(Random rng, long n) {
   // error checking and 2^x checking removed for simplicity.
   long bits, val;
   do {
      bits = (rng.nextLong() << 1) >>> 1;
      val = bits % n;
   } while (bits-val+(n-1) < 0L);
   return val;
}

ThreadLocalRandom

ThreadLocalRandom持っているnextLong(long bound)方法を。

long v = ThreadLocalRandom.current().nextLong(100);

またnextLong(long origin, long bound)、0以外の原点が必要な場合もあります。原点（包括的）と境界（排他的）を渡します。

long v = ThreadLocalRandom.current().nextLong(10,100); // For 2-digit integers, 10-99 inclusive.

SplittableRandom同じnextLong方法があり、再現可能な数列が必要な場合はシードを選択できます。

範囲内で（ユーティリティメソッドなしで）数値を生成する標準的な方法は、範囲でdoubleを使用することです。

long range = 1234567L;
Random r = new Random()
long number = (long)(r.nextDouble()*range);

0（包括的）と範囲（排他的）の間のlongを提供します。同様に、xとyの間の数値が必要な場合：

long x = 1234567L;
long y = 23456789L;
Random r = new Random()
long number = x+((long)(r.nextDouble()*(y-x)));

1234567（両端を含む）から123456789（両端を含まない）までの長い

注：longへのキャストは乗算よりも優先されるため、括弧を確認してください。

上記の方法はうまく機能します。Apache Commons（org.apache.commons.math.random）を使用している場合は、RandomDataを確認してください。それには次のメソッドがあります：nextLong（長い下、長い上）

http://commons.apache.org/math/userguide/random.html

http://commons.apache.org/math/api-1.1/org/apache/commons/math/random/RandomData.html#nextLong(long,%20long）

'％'演算子を使用する

resultingNumber = (r.nextLong() % (maximum - minimum)) + minimum;

'％'演算子を使用することで、最大値で除算したときの余りが使用されます。これにより、0（包括的）から除数（排他的）までの数値のみが残ります。

例えば：

public long randLong(long min, long max) {
    return (new java.util.Random().nextLong() % (max - min)) + min;
}

kennytmの答えをさらに改善する：Java 8での実際の実装を考慮したサブクラス実装は次のようになります。

public class MyRandom extends Random {
  public long nextLong(long bound) {
    if (bound <= 0) {
      throw new IllegalArgumentException("bound must be positive");
    }

    long r = nextLong() & Long.MAX_VALUE;
    long m = bound - 1L;
    if ((bound & m) == 0) { // i.e., bound is a power of 2
      r = (bound * r) >> (Long.SIZE - 1);
    } else {
      for (long u = r; u - (r = u % bound) + m < 0L; u = nextLong() & Long.MAX_VALUE);
    }
    return r;
  }
}

[0、m）の範囲の長い均一分布の疑似乱数が必要な場合は、nextLong()以下に示すように、モジュロ演算子と絶対値メソッドをメソッドと組み合わせて使用​​してみてください。

Math.abs(rand.nextLong()) % m;

randランダムオブジェクトはどこにありますか。

モジュロ演算子は2つの数値を除算し、それらの数値の余りを出力します。例えば、3 % 2ある13及び2の余りが1であるためです。

nextLong()[-（2 ^ 48）、2 ^ 48）の範囲（またはその範囲のどこか）で均一に分散された疑似乱数を生成するので、その絶対値を取る必要があります。そうでない場合、nextLong()メソッドのモジュロは50％の確率で負の値を返しますが、これは[0、m）の範囲外です。

最初に要求したのは、[0,100）の範囲の長い均一に分布した疑似ランダムでした。次のコードはそうします：

Math.abs(rand.nextLong()) % 100;

これはどう：

public static long nextLong(@NonNull Random r, long min, long max) {
    if (min > max)
        throw new IllegalArgumentException("min>max");
    if (min == max)
        return min;
    long n = r.nextLong();
    //abs (use instead of Math.abs, which might return min value) :
    n = n == Long.MIN_VALUE ? 0 : n < 0 ? -n : n;
    //limit to range:
    n = n % (max - min);
    return min + n;
}

？

以下のメソッドは、10000000000から9999999999の間の値を返します

long min = 1000000000L
long max = 9999999999L    

public static long getRandomNumber(long min, long max){

    Random random = new Random();         
    return random.nextLong() % (max - min) + max;

}

Java 8 API から

それから、実際の実装を取るために容易になる可能性がAPIドキュメント https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#longs-long-long-long-を 、彼らはそれを使用していますlongストリームを生成します。そして、あなたの起源は質問のように「0」にすることができます。

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

ランダムのページから：

nextLongメソッドは、次のようにRandomクラスによって実装されます。

public long nextLong() {
   return ((long)next(32) << 32) + next(32);
}

クラスRandomは48ビットのみのシードを使用するため、このアルゴリズムはすべての可能なlong値を返しません。

したがって、を取得したい場合Long、64ビットの範囲全体を取得することはできません。

2の累乗に近い範囲がある場合Long、次のようにそのスニペットのようにを構築することをお勧めします。

next(32) + ((long)nextInt(8) << 3)

たとえば、35ビットの範囲を取得します。

を使用するメソッドでは、以下を使用するr.nextDouble()必要があります。

long number = (long) (rand.nextDouble()*max);


long number = x+(((long)r.nextDouble())*(y-x));

public static long randomLong(long min, long max)
{
    try
    {
        Random  random  = new Random();
        long    result  = min + (long) (random.nextDouble() * (max - min));
        return  result;
    }
    catch (Throwable t) {t.printStackTrace();}
    return 0L;
}

Javaストリームを使用できる場合は、以下を試すことができます。

Random randomizeTimestamp = new Random();
Long min = ZonedDateTime.parse("2018-01-01T00:00:00.000Z").toInstant().toEpochMilli();
Long max = ZonedDateTime.parse("2019-01-01T00:00:00.000Z").toInstant().toEpochMilli();
randomizeTimestamp.longs(generatedEventListSize, min, max).forEach(timestamp -> {
  System.out.println(timestamp);
});

これにより、指定された範囲のlongの数値が生成されます。

import java.util*;

    Random rnd = new Random ();
    long name = Math.abs(rnd.nextLong());

これはうまくいくはずです

//システム時間をシード値として使用して、適切な乱数を取得します

   Random random = new Random(System.currentTimeMillis());
              long x;
             do{
                x=random.nextLong();
             }while(x<0 && x > n); 

// 0以上でnより小さい数になるまでループします