Die Zufallsklasse verfügt über eine Methode zum Generieren von Zufalls-Int in einem bestimmten Bereich. Beispielsweise:

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

Dies würde eine int-Zahl erzeugen, die größer oder gleich 0 und kleiner als 100 ist. Ich möchte genau dasselbe mit einer langen Zahl tun.

long y = magicRandomLongGenerator(100);

Die zufällige Klasse hat nur nextLong (), erlaubt jedoch nicht, den Bereich festzulegen.

Ab Java 7 (oder Android API Level 21 = 5.0+) können Sie direkt ThreadLocalRandom.current().nextLong(n)(für 0 ≤ x <n) und ThreadLocalRandom.current().nextLong(m, n)(für m ≤ x <n) verwenden. Siehe @ Alex ‚s Antwort zum Detail.

Wenn Sie mit Java 6 (oder Android 4.x) nicht weiterkommen , müssen Sie eine externe Bibliothek verwenden ( org.apache.commons.math3.random.RandomDataGenerator.getRandomGenerator().nextLong(0, n-1)siehe z . B. die Antwort von @mawaldne ) oder eine eigene implementieren nextLong(n).

Laut https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Random.html nextInt ist implementiert als

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

Wir können dies also ändern, um Folgendes auszuführen 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

ThreadLocalRandomhat eine nextLong(long bound)Methode.

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

Es hat auch, nextLong(long origin, long bound)wenn Sie einen anderen Ursprung als 0 benötigen. Übergeben Sie den Ursprung (einschließlich) und die Grenze (exklusiv).

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

SplittableRandomhat die gleichen nextLongMethoden und ermöglicht es Ihnen, einen Startwert auszuwählen, wenn Sie eine reproduzierbare Folge von Zahlen wünschen.

Die Standardmethode zum Generieren einer Zahl (ohne Dienstprogrammmethode) in einem Bereich besteht darin, einfach das Doppelte mit dem Bereich zu verwenden:

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

gibt Ihnen eine lange zwischen 0 (einschließlich) und Bereich (exklusiv). Ebenso, wenn Sie eine Zahl zwischen x und y wollen:

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

erhalten Sie eine lange von 1234567 (einschließlich) bis 123456789 (exklusiv)

Hinweis: Überprüfen Sie die Klammern, da das Casting auf Long eine höhere Priorität als die Multiplikation hat.

Die oben genannten Methoden funktionieren hervorragend. Wenn Sie Apache Commons (org.apache.commons.math.random) verwenden, lesen Sie RandomData. Es gibt eine Methode: nextLong (lang unten, lang oben)

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)

Verwenden Sie den Operator '%'

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

Mit dem Operator '%' nehmen wir den Rest, geteilt durch Ihren Maximalwert. Dies lässt uns nur Zahlen von 0 (einschließlich) bis zum Divisor (exklusiv).

Beispielsweise:

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

Weitere Verbesserung der Antwort von kennytm: Eine Implementierung der Unterklasse unter Berücksichtigung der tatsächlichen Implementierung in Java 8 wäre:

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

Wenn Sie eine gleichmäßig verteilte Pseudozufallslänge im Bereich von [0, m) wünschen , verwenden Sie den Modulo-Operator und die Absolutwertmethode in Kombination mit der folgenden nextLong()Methode:

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

Wo randist dein zufälliges Objekt?

Der Modulo-Operator teilt zwei Zahlen und gibt den Rest dieser Zahlen aus. Zum Beispiel 3 % 2ist , 1da der Rest von 3 und 2 : 1.

Da nextLong()ein gleichmäßig verteiltes Pseudozufall im Bereich von [- (2 ^ 48), 2 ^ 48) (oder irgendwo in diesem Bereich) erzeugt wird, müssen Sie den absoluten Wert davon nehmen. Wenn Sie dies nicht tun, hat das Modulo der nextLong()Methode eine 50% ige Chance, einen negativen Wert zurückzugeben, der außerhalb des Bereichs [0,] liegt m.

Was Sie ursprünglich angefordert haben, war eine gleichmäßig verteilte Pseudozufallslänge im Bereich von [0,100]. Der folgende Code tut dies:

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

Wie wäre es damit:

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

?

Die folgende Methode gibt einen Wert zwischen 10000000000 und 9999999999 zurück

long min = 1000000000L
long max = 9999999999L    

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

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

}

Von der Java 8 API

Es könnte einfacher sein, die tatsächliche Implementierung aus dem API-Dokument https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#longs-long-long-long- zu übernehmen, für das sie es verwenden Longs Stream generieren. Und Ihr Ursprung kann wie in der Frage "0" sein.

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

Von der Seite auf Random :

Die Methode nextLong wird von der Klasse Random wie folgt implementiert:

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

Da die Klasse Random einen Startwert mit nur 48 Bit verwendet, gibt dieser Algorithmus nicht alle möglichen langen Werte zurück.

Wenn Sie also eine erhalten möchten, erhalten LongSie bereits nicht die volle 64-Bit-Reichweite.

Ich würde vorschlagen, dass Sie, wenn Sie eine Reichweite haben, die nahe einer Potenz von 2 liegt, die Longin diesem Snippet wie folgt aufbauen:

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

um beispielsweise einen 35-Bit-Bereich zu erhalten.

Die Methoden, die r.nextDouble()das verwenden, sollten Folgendes verwenden:

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

Wenn Sie Java-Streams verwenden können, können Sie Folgendes versuchen:

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

Dadurch werden für Longs Zahlen im angegebenen Bereich generiert.

import java.util*;

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

Das sollte funktionieren

// Verwenden Sie die Systemzeit als Startwert, um eine gute Zufallszahl zu erhalten

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

// Schleife, bis eine Zahl größer oder gleich 0 und kleiner als n ist