Lớp ngẫu nhiên có một phương thức để tạo int ngẫu nhiên trong một phạm vi nhất định. Ví dụ:

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

Điều này sẽ tạo ra một số int nhiều hơn hoặc bằng 0 và nhỏ hơn 100. Tôi muốn làm chính xác như vậy với số dài.

long y = magicRandomLongGenerator(100);

Lớp ngẫu nhiên chỉ có nextLong (), nhưng nó không cho phép đặt phạm vi.

Bắt đầu từ Java 7 (hoặc API Android cấp 21 = 5.0+), bạn có thể trực tiếp sử dụng ThreadLocalRandom.current().nextLong(n)(cho 0 ≤ x <n) và ThreadLocalRandom.current().nextLong(m, n)(cho m ≤ x <n). Xem câu trả lời của @Alex để biết chi tiết.

Nếu bạn bị mắc kẹt với Java 6 (hoặc Android 4.x), bạn cần sử dụng thư viện bên ngoài (ví dụ: org.apache.commons.math3.random.RandomDataGenerator.getRandomGenerator().nextLong(0, n-1)xem câu trả lời của @mawaldne ) hoặc tự thực hiện nextLong(n).

Theo https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Random.html nextInt được triển khai dưới dạng

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

Vì vậy, chúng tôi có thể sửa đổi điều này để thực hiện 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

ThreadLocalRandomcó một nextLong(long bound)phương pháp.

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

Nó cũng có nextLong(long origin, long bound) nếu bạn cần một nguồn gốc khác 0. Chuyển nguồn gốc (bao gồm) và ràng buộc (độc quyền).

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

SplittableRandomcó cùng nextLongphương thức và cho phép bạn chọn một hạt giống nếu bạn muốn một chuỗi số có thể lặp lại.

Phương thức tiêu chuẩn để tạo một số (không có phương thức tiện ích) trong một phạm vi là chỉ sử dụng số kép với phạm vi:

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

sẽ cung cấp cho bạn một khoảng dài từ 0 (bao gồm) và phạm vi (độc quyền). Tương tự nếu bạn muốn một số giữa x và y:

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

sẽ cung cấp cho bạn một thời gian dài từ 1234567 (bao gồm) đến 123456789 (độc quyền)

Lưu ý: kiểm tra dấu ngoặc đơn, bởi vì truyền từ lâu có mức độ ưu tiên cao hơn phép nhân.

Các phương pháp trên làm việc tuyệt vời. Nếu bạn đang sử dụng commache commons (org.apache.commons.math.random), hãy xem RandomData. Nó có một phương thức: nextLong (dài dưới, dài trên)

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)

Sử dụng toán tử '%'

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

Bằng cách sử dụng toán tử '%', chúng tôi sẽ lấy phần còn lại khi chia cho giá trị tối đa của bạn. Điều này khiến chúng tôi chỉ có các số từ 0 (đã bao gồm) đến số chia (độc quyền).

Ví dụ:

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

Cải thiện hơn nữa câu trả lời của kennytm: Việc triển khai lớp con thực hiện triển khai thực tế trong Java 8 sẽ là:

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

Nếu bạn muốn một giả danh phân phối đồng đều dài trong phạm vi [0, m), hãy thử sử dụng toán tử modulo và phương pháp giá trị tuyệt đối kết hợp với nextLong()phương thức như dưới đây:

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

Đâu randlà đối tượng ngẫu nhiên của bạn.

Toán tử modulo chia hai số và xuất ra phần còn lại của các số đó. Ví dụ, 3 % 2là1 vì phần còn lại của 3 và 2 là 1.

Vì nextLong()tạo ra một giả ngẫu nhiên phân phối đồng đều dài trong phạm vi [- (2 ^ 48), 2 ^ 48) (hoặc ở đâu đó trong phạm vi đó), bạn sẽ cần lấy giá trị tuyệt đối của nó. Nếu bạn không, modulo của nextLong()phương thức có 50% cơ hội trả về giá trị âm, nằm ngoài phạm vi [0,m ).

Những gì bạn yêu cầu ban đầu là một giả ngẫu nhiên phân phối đồng đều dài trong phạm vi [0,100). Các mã sau đây làm như vậy:

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

Còn cái này thì sao:

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

?

Phương pháp bên dưới sẽ trả về cho bạn một giá trị trong khoảng từ 10000000000 đến 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;

}

Từ API Java 8

Có thể dễ dàng thực hiện triển khai thực tế hơn từ API doc https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#longs-long-long-long- họ đang sử dụng nó để tạo luồng dài. Và nguồn gốc của bạn có thể là "0" như trong câu hỏi.

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

Từ trang trên Random :

Phương thức nextLong được lớp Thực hiện ngẫu nhiên như thể bởi:

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

Vì lớp Random sử dụng một hạt giống chỉ có 48 bit, thuật toán này sẽ không trả về tất cả các giá trị dài có thể.

Vì vậy, nếu bạn muốn có được một Long, bạn sẽ không nhận được phạm vi 64 bit đầy đủ.

Tôi sẽ đề nghị rằng nếu bạn có một phạm vi nằm gần sức mạnh 2, bạn hãy xây dựng Longnhư trong đoạn trích đó, như thế này:

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

để có được một phạm vi 35 bit, ví dụ.

Các phương pháp sử dụng r.nextDouble()nên sử dụng:

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

Nếu bạn có thể sử dụng các luồng java, bạn có thể thử như sau:

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

Điều này sẽ tạo ra các số trong phạm vi nhất định trong thời gian dài.

import java.util*;

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

Điều này sẽ làm việc

// sử dụng thời gian hệ thống làm giá trị hạt giống để có được số ngẫu nhiên tốt

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

// Lặp cho đến khi nhận được một số lớn hơn hoặc bằng 0 và nhỏ hơn n