คลาสสุ่มมีวิธีการสร้าง int แบบสุ่มในช่วงที่กำหนด ตัวอย่างเช่น:

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

สิ่งนี้จะสร้างจำนวน int มากกว่าหรือเท่ากับ 0 และน้อยกว่า 100 ฉันต้องการทำเช่นเดียวกันกับ long number

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 (หรือ 4.x Android) คุณจำเป็นต้องใช้ห้องสมุดภายนอก (เช่นorg.apache.commons.math3.random.RandomDataGenerator.getRandomGenerator().nextLong(0, n-1)ดู@mawaldne 's คำตอบ) 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 (เฉพาะตัว)

หมายเหตุ: ตรวจสอบวงเล็บเนื่องจากการแคสต์เป็นแบบยาวมีลำดับความสำคัญสูงกว่าการคูณ

วิธีการข้างต้นใช้งานได้ดี หากคุณใช้ 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;
  }
}

หากคุณต้องการให้ pseudorandom ยาวกระจายสม่ำเสมอในช่วง [0, m) ให้ลองใช้ตัวดำเนินการโมดูโลและวิธีค่าสัมบูรณ์รวมกับnextLong()วิธีการดังที่แสดงด้านล่าง:

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

randวัตถุสุ่มของคุณอยู่ที่ไหน

ตัวดำเนินการโมดูโลหารสองตัวเลขและส่งออกส่วนที่เหลือของตัวเลขเหล่านั้น ยกตัวอย่างเช่น3 % 2เป็น1เพราะที่เหลือของ 3 และ 2 เป็น 1

เนื่องจากnextLong()สร้าง pseudorandom ที่มีการกระจายอย่างสม่ำเสมอในช่วง [- (2 ^ 48), 2 ^ 48) (หรือที่ไหนสักแห่งในช่วงนั้น) คุณจะต้องใช้ค่าสัมบูรณ์ของมัน หากไม่เป็นเช่นนั้นโมดูโลของnextLong()เมธอดมีโอกาส 50% ที่จะส่งคืนค่าลบซึ่งอยู่นอกช่วง [0, m)

สิ่งที่คุณร้องขอในตอนแรกคือ pseudorandom ที่กระจายอย่างสม่ำเสมอในช่วง [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- ที่ พวกเขากำลังใช้เพื่อ สร้างสตรีม longs และต้นกำเนิดของคุณอาจเป็น "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;
}

จากหน้าบนRandom :

วิธีการ nextLong ถูกนำไปใช้โดยคลาส Random ราวกับว่า:

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

เนื่องจากคลาส Random ใช้ seed ที่มีเพียง 48 บิตอัลกอริทึมนี้จะไม่ส่งคืนค่า long ที่เป็นไปได้ทั้งหมด

ดังนั้นหากคุณต้องการรับ a 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);
});

สิ่งนี้จะสร้างตัวเลขในช่วงที่กำหนดสำหรับ longs

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