随机类具有一种在给定范围内生成随机int的方法。例如：

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

这将生成一个大于或等于0且小于100的int数。我想对long数做完全相同的操作。

long y = magicRandomLongGenerator(100);

随机类仅具有nextLong（），但不允许设置范围。

从Java 7（或Android API级别21 = 5.0+）开始，您可以直接使用ThreadLocalRandom.current().nextLong(n)（对于0≤x <n）和ThreadLocalRandom.current().nextLong(m, n)（对于m≤x <n）。有关详细信息，请参见@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方法，如果您想要可重复的数字序列，则可以选择种子。

生成范围内数字的标准方法（无实用方法）是对范围使用双精度数：

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

将为您提供介于0（含）和范围（不含）之间的较长时间。同样，如果您想要一个介于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（long lower，long upper）

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您的随机对象。

模运算符将两个数相除，然后输出这些数的余数。例如，3 % 2是1由于在3和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 doc https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#longs-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，您将不会获得完整的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);
});

这将长时间生成给定范围内的数字。

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的数字