La clase aleatoria tiene un método para generar int aleatorio en un rango dado. Por ejemplo:

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

Esto generaría un número int más o igual a 0 y menos de 100. Me gustaría hacer exactamente lo mismo con un número largo.

long y = magicRandomLongGenerator(100);

La clase aleatoria solo tiene nextLong (), pero no permite establecer el rango.

A partir de Java 7 (o Android API Nivel 21 = 5.0+) puede usar directamente ThreadLocalRandom.current().nextLong(n)(para 0 ≤ x <n) y ThreadLocalRandom.current().nextLong(m, n)(para m ≤ x <n). Vea la respuesta de @Alex para más detalles.

Si está atascado con Java 6 (o Android 4.x) necesita usar una biblioteca externa (por ejemplo org.apache.commons.math3.random.RandomDataGenerator.getRandomGenerator().nextLong(0, n-1), vea la respuesta de @mawaldne ), o implementar la suya propia nextLong(n).

De acuerdo con https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Random.html nextInt se implementa como

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

Entonces podemos modificar esto para realizar 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

ThreadLocalRandomTiene un nextLong(long bound)método.

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

También tiene nextLong(long origin, long bound)si necesita un origen distinto de 0. Pase el origen (inclusive) y el límite (exclusivo).

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

SplittableRandomtiene los mismos nextLongmétodos y le permite elegir una semilla si desea una secuencia de números reproducible.

El método estándar para generar un número (sin un método de utilidad) en un rango es usar el doble con el rango:

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

le dará un largo entre 0 (inclusive) y rango (exclusivo). Del mismo modo, si desea un número entre x e y:

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

le dará un largo desde 1234567 (inclusive) hasta 123456789 (exclusivo)

Nota: compruebe los paréntesis, porque la conversión a larga tiene mayor prioridad que la multiplicación.

Los métodos anteriores funcionan muy bien. Si está usando apache commons (org.apache.commons.math.random), consulte RandomData. Tiene un método: nextLong (largo inferior, largo superior)

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)

Use el operador '%'

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

Al usar el operador '%', tomamos el resto cuando se divide entre su valor máximo. Esto nos deja con solo números desde 0 (inclusive) hasta el divisor (exclusivo).

Por ejemplo:

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

Mejorando aún más la respuesta de kennytm: una implementación de subclase que tenga en cuenta la implementación real en Java 8 sería:

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

Si desea un pseudoaleatorio distribuido uniformemente largo en el rango de [0, m), intente usar el operador de módulo y el método de valor absoluto combinado con el nextLong()método como se ve a continuación:

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

¿Dónde randestá tu objeto aleatorio?

El operador de módulo divide dos números y genera el resto de esos números. Por ejemplo, 3 % 2es 1porque el resto de 3 y 2 es 1.

Como nextLong()genera una pseudoaleatoria distribuida uniformemente en el rango de [- (2 ^ 48), 2 ^ 48) (o en algún lugar de ese rango), deberá tomar el valor absoluto de la misma. Si no lo hace, el módulo del nextLong()método tiene una probabilidad del 50% de devolver un valor negativo, que está fuera del rango [0, m).

Lo que solicitó inicialmente fue un pseudoaleatorio distribuido uniformemente de largo en el rango de [0,100). El siguiente código lo hace:

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

Qué tal esto:

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

?

El siguiente método le devolverá un valor entre 10000000000 y 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;

}

Desde Java 8 API

Podría ser más fácil tomar la implementación real del documento API https://docs.oracle.com/javase/8/docs/api/java/util/Random.html#longs-long-long-long- lo están utilizando para generar longs stream. Y su origen puede ser "0" como en la pregunta.

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

De la página al azar :

El método nextLong lo implementa la clase Random como si:

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

Debido a que la clase Random usa una semilla con solo 48 bits, este algoritmo no devolverá todos los valores largos posibles.

Entonces, si desea obtener un Long, ya no obtendrá el rango completo de 64 bits.

Sugeriría que si tienes un rango que se acerca a una potencia de 2, acumulas Longcomo en ese fragmento, así:

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

para obtener un rango de 35 bits, por ejemplo.

Los métodos que usan r.nextDouble()deberían usar:

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

Si puede usar flujos de Java, puede intentar lo siguiente:

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

Esto generará números en el rango dado para largos.

import java.util*;

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

Esto debería funcionar

// usa el tiempo del sistema como valor semilla para obtener un buen número aleatorio

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

// Bucle hasta obtener un número mayor o igual a 0 y menor que n