Classe Random #3

longs(long randomNumberOrigin, long randomNumberBound)

longs(long randomNumberOrigin, long randomNumberBound) – Retorna um fluxo efetivamente ilimitado de valores longos pseudo-aleatórios, cada um em conformidade com a origem especificada (inclusive) e vinculado (exclusivo).

public LongStream longs(long randomNumberOrigin, long randomNumberBound) – Retorna um fluxo efetivamente ilimitado de valores longos pseudo-aleatórios, cada um em conformidade com a origem especificada (inclusive) e vinculado (exclusivo).
Um valor longo pseudoaleatório é gerado como se fosse o resultado da chamada do seguinte método com a origem e o limite:

 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n &amp; m) == 0L)  // power of two
     r = (r &amp; m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) &lt; 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r &lt; origin || r >= bound)
       r = nextLong();
   }
   return r;
 }

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;

}

Nota de implementação:

Este método é implementado para ser equivalente a longs (Long.MAX_VALUE, randomNumberOrigin, randomNumberBound).

Parâmetros:

randomNumberOrigin – a origem (inclusive) de cada valor aleatório
randomNumberBound – o limite (exclusivo) de cada valor aleatório

Retornos:

um fluxo de valores longos pseudo-aleatórios, cada um com a origem especificada (inclusive) e vinculado (exclusivo)

Lançamentos:

IllegalArgumentException – se randomNumberOrigin for maior ou igual a randomNumberBound

Esse método existe desde a versão 1.8.

Fonte do código: https://www.javatpoint.com/java-threadlocalrandom-longs-method

import java.util.concurrent.ThreadLocalRandom;
public class ThreadLocalRandomLongsExample2 {
public static void main(String[] args) {
// Returns a stream of pseudorandom long values
System.out.println(“stream of pseudorandom long value is: ” +ThreadLocalRandom.current().longs(20, 30));
}
}

longs(long streamSize, long randomNumberOrigin, long randomNumberBound)

longs(long streamSize, long randomNumberOrigin, long randomNumberBound) – Retorna um fluxo que produz o número streamSize especificado de comprimento pseudo-aleatório, cada um em conformidade com a origem especificada (inclusive) e vinculado (exclusivo).

public LongStream longs(long streamSize, long randomNumberOrigin, long randomNumberBound) – Retorna um fluxo que produz o número streamSize especificado de comprimento pseudo-aleatório, cada um em conformidade com a origem especificada (inclusive) e vinculado (exclusivo).
Um valor longo pseudoaleatório é gerado como se fosse o resultado da chamada do seguinte método com a origem e o limite:

 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n &amp; m) == 0L)  // power of two
     r = (r &amp; m) + origin;
   else if (n > 0L) {  // reject over-represented candidates
     for (long u = r >>> 1;            // ensure nonnegative
          u + m - (r = u % n) &lt; 0L;    // rejection check
          u = nextLong() >>> 1) // retry
         ;
     r += origin;
   }
   else {              // range not representable as long
     while (r &lt; origin || r >= bound)
       r = nextLong();
   }
   return r;
 }

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;

}

Parâmetros:

streamSize – o número de valores a serem gerados
randomNumberOrigin – a origem (inclusive) de cada valor aleatório
randomNumberBound – o limite (exclusivo) de cada valor aleatório

Retornos:

um fluxo de valores longos pseudo-aleatórios, cada um com a origem especificada (inclusive) e vinculado (exclusivo)

Lançamentos:

IllegalArgumentException – se streamSize for menor que zero ou randomNumberOrigin for maior ou igual a randomNumberBound

Esse método existe desde a versão 1.8.

Fonte do código: https://www.javatpoint.com/java-threadlocalrandom-longs-method

import java.util.concurrent.ThreadLocalRandom;
public class ThreadLocalRandomLongsExample6 {
public static void main(String[] args) {
// Returns a stream of pseudorandom long values
System.out.println(“stream of pseudorandom long value is: ” +ThreadLocalRandom.current().longs(10, 20, 30));
}
}

next(int bits)

next(int bits) – Gera o próximo número pseudo-aleatório.

protected int next(int bits) – Gera o próximo número pseudo-aleatório. As subclasses devem substituir isso, pois isso é usado por todos os outros métodos.
O contrato geral de next é que ele retorne um valor int e se os bits do argumento estiverem entre 1 e 32 (inclusive), muitos bits de ordem inferior do valor retornado serão (aproximadamente) valores de bits escolhidos independentemente, cada um dos quais é (aproximadamente) igualmente provável que seja 0 ou 1. O método a seguir é implementado pela classe Random, atualizando atomicamente a semente para

(seed * 0x5DEECE66DL + 0xBL) &amp; ((1L &lt;&lt; 48) - 1)

1	(seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)

e retorna

(int)(seed >>> (48 - bits)).

1	(int)(seed >>> (48 - bits)).

Este é um gerador linear de números pseudo-aleatórios congruentes, conforme definido por D. H. Lehmer e descrito por Donald E. Knuth em A Arte da Programação por Computador, Volume 2: Algoritmos Seminuméricos, seção 3.2.1.

Parâmetros:

bits – bits aleatórios

Retornos:

o próximo valor pseudo-aleatório dessa sequência geradora de número aleatório

Esse método existe desde a versão 1.1.

nextBoolean()

nextBoolean() – Retorna o próximo valor booleano pseudo-aleatório e uniformemente distribuído da sequência desse gerador de números aleatórios.

public boolean nextBoolean() – Retorna o próximo valor booleano pseudo-aleatório e uniformemente distribuído da sequência desse gerador de números aleatórios. O contrato geral do nextBoolean é que um valor booleano é gerado e retornado pseudo-aleatoriamente. Os valores verdadeiro e falso são produzidos com (aproximadamente) igual probabilidade.

O método nextBoolean é implementado pela classe Random como se por:

public boolean nextBoolean() {
   return next(1) != 0;
 }

public boolean nextBoolean() {

return next(1) != 0;

}

Retornos:

o próximo valor booleano pseudo-aleatório e uniformemente distribuído da sequência desse gerador de números aleatórios

Esse método existe desde a versão 1.2.

Fonte do código: https://www.tutorialspoint.com/java/util/random_nextboolean.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();

      // get next next boolean value 
      boolean value = randomno.nextBoolean();

      // check the value  
      System.out.println("Value is: " + value);
   }     
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// get next next boolean value

boolean value = randomno.nextBoolean();

// check the value

System.out.println("Value is: " + value);

}

nextBytes(byte[] bytes)

nextBytes(byte[] bytes) – Gera bytes aleatórios e os coloca em uma matriz de bytes fornecida pelo usuário.

public void nextBytes(byte[] bytes) – Gera bytes aleatórios e os coloca em uma matriz de bytes fornecida pelo usuário. O número de bytes aleatórios produzidos é igual ao comprimento da matriz de bytes.
O método nextBytes é implementado pela classe Random como se por:

 public void nextBytes(byte[] bytes) {
   for (int i = 0; i &lt; bytes.length; )
     for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
          n-- > 0; rnd >>= 8)
       bytes[i++] = (byte)rnd;
 }

public void nextBytes(byte[] bytes) {

for (int i = 0; i < bytes.length; )

for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);

n-- > 0; rnd >>= 8)

bytes[i++] = (byte)rnd;

}

Parâmetros:

bytes – a matriz de bytes a ser preenchida com bytes aleatórios

Lançamentos:

NullPointerException – se a matriz de bytes for nula

Esse método existe desde a versão 1.1.

Fonte do código: https://www.tutorialspoint.com/java/util/random_nextbytes.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();

      // create byte array
      byte[] nbyte = new byte[30];

      // put the next byte in the array
      randomno.nextBytes(nbyte);

      // check the value of array   
      System.out.println("Value of byte array: " + nbyte);
   }      
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// create byte array

byte[] nbyte = new byte[30];

// put the next byte in the array

randomno.nextBytes(nbyte);

// check the value of array

System.out.println("Value of byte array: " + nbyte);

}

nextDouble()

nextDouble() – Retorna o próximo valor duplo pseudoaleatório, distribuído uniformemente entre 0,0 e 1,0 a partir desta sequência do gerador de números aleatórios.

public double nextDouble() – Retorna o próximo valor duplo pseudoaleatório, distribuído uniformemente entre 0,0 e 1,0 a partir desta sequência do gerador de números aleatórios.
O contrato geral de nextDouble é que um valor duplo, escolhido (aproximadamente) uniformemente do intervalo 0,0d (inclusive) a 1,0d (exclusivo), seja gerado e retornado pseudo-aleatoriamente.

O método nextDouble é implementado pela classe Random como se por:

 public double nextDouble() {
   return (((long)next(26) &lt;&lt; 27) + next(27))
     / (double)(1L &lt;&lt; 53);
 }

public double nextDouble() {

return (((long)next(26) << 27) + next(27))

/ (double)(1L << 53);

}

O hedge “aproximadamente” é usado na descrição anterior apenas porque o próximo método é apenas aproximadamente uma fonte imparcial de bits escolhidos independentemente. Se fosse uma fonte perfeita de bits escolhidos aleatoriamente, o algoritmo mostrado escolheria valores duplos no intervalo declarado com perfeita uniformidade.

[Nas versões anteriores do Java, o resultado era calculado incorretamente como:

   return (((long)next(27) &lt;&lt; 27) + next(27))
     / (double)(1L &lt;&lt; 54);

1 2	return (((long)next(27) << 27) + next(27)) / (double)(1L << 54);

Isso pode parecer equivalente, se não melhor, mas, na verdade, introduziu uma grande não uniformidade devido ao viés no arredondamento dos números de ponto flutuante: era três vezes mais provável que o bit de ordem inferior do significando fosse 0. do que isso seria 1! Essa não uniformidade provavelmente não importa muito na prática, mas buscamos a perfeição.]

Retornos:

o próximo pseudoaleatório, valor duplo uniformemente distribuído entre 0,0 e 1,0 da sequência desse gerador de números aleatórios

Veja também:

Math.random()

Fonte do código: https://www.geeksforgeeks.org/random-nextdouble-method-in-java-with-examples/

import java.util.*; 
public class GFG { 
    public static void main(String[] args) 
    { 
  
        // create random object 
        Random r = new Random(); 
  
        // check next double value  and print it 
        System.out.println("Next double value is = "
                           + r.nextDouble()); 
    } 
}

import java.util.*;

public class GFG {

public static void main(String[] args)

{

// create random object

Random r = new Random();

// check next double value and print it

System.out.println("Next double value is = "

+ r.nextDouble());

}

nextFloat()

nextFloat() – Retorna o próximo valor flutuante pseudo-aleatório e uniformemente distribuído entre 0,0 e 1,0 a partir desta sequência do gerador de números aleatórios.

public float nextFloat() – Retorna o próximo valor flutuante pseudo-aleatório e uniformemente distribuído entre 0,0 e 1,0 a partir desta sequência do gerador de números aleatórios.

O contrato geral do nextFloat é que um valor flutuante, escolhido (aproximadamente) uniformemente do intervalo 0,0f (inclusive) a 1,0f (exclusivo), seja gerado e retornado pseudo-aleatoriamente. Todos os 2²⁴ valores possíveis de flutuação da forma m x 2²⁴ , em que m é um número inteiro positivo menor que 2²⁴ , são produzidos com (aproximadamente) probabilidade igual.

O método nextFloat é implementado pela classe Random como se por:

 public float nextFloat() {
   return next(24) / ((float)(1 &lt;&lt; 24));
 }

public float nextFloat() {

return next(24) / ((float)(1 << 24));

}

O hedge “aproximadamente” é usado na descrição anterior apenas porque o próximo método é apenas aproximadamente uma fonte imparcial de bits escolhidos independentemente. Se fosse uma fonte perfeita de bits escolhidos aleatoriamente, o algoritmo mostrado escolheria valores flutuantes no intervalo declarado com perfeita uniformidade.

[Nas versões anteriores do Java, o resultado era calculado incorretamente como:

return next(30) / ((float)(1 &lt;&lt; 30));

1	return next(30) / ((float)(1 << 30));

Isso pode parecer equivalente, se não melhor, mas, de fato, introduziu uma leve não uniformidade por causa do viés no arredondamento dos números de ponto flutuante: era um pouco mais provável que o bit de ordem inferior do significando fosse 0 do que que seria 1.]

Retornos:

o próximo pseudoaleatório, valor flutuante uniformemente distribuído entre 0,0 e 1,0 da sequência desse gerador de números aleatórios

Fonte do código: https://www.tutorialspoint.com/java/util/random_nextfloat.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();
    
      // check next float value  
      System.out.println("Next float value: " + randomno.nextFloat());
   }      
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// check next float value

System.out.println("Next float value: " + randomno.nextFloat());

}

nextGaussian()

nextGaussian() – Retorna o próximo pseudoaleatório Gaussiano (“normalmente”) distribuído com valor duplo com média 0,0 e desvio padrão 1,0 a partir desta sequência do gerador de números aleatórios.

public double nextGaussian() – Retorna o próximo pseudoaleatório Gaussiano (“normalmente”) distribuído com valor duplo com média 0,0 e desvio padrão 1,0 a partir desta sequência do gerador de números aleatórios.
O contrato geral do nextGaussian é que um valor duplo, escolhido (aproximadamente) a distribuição normal usual com média 0,0 e desvio padrão 1,0, seja gerado e retornado pseudo-aleatoriamente.

O método nextGaussian é implementado pela classe Random como se fosse uma versão threadsafe do seguinte:

 private double nextNextGaussian;
 private boolean haveNextNextGaussian = false;

 public double nextGaussian() {
   if (haveNextNextGaussian) {
     haveNextNextGaussian = false;
     return nextNextGaussian;
   } else {
     double v1, v2, s;
     do {
       v1 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       v2 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
       s = v1 * v1 + v2 * v2;
     } while (s >= 1 || s == 0);
     double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
     nextNextGaussian = v2 * multiplier;
     haveNextNextGaussian = true;
     return v1 * multiplier;
   }
 }

private double nextNextGaussian;

private boolean haveNextNextGaussian = false;

public double nextGaussian() {

if (haveNextNextGaussian) {

haveNextNextGaussian = false;

return nextNextGaussian;

} else {

double v1, v2, s;

do {

v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0

v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0

s = v1 * v1 + v2 * v2;

} while (s >= 1 || s == 0);

double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);

nextNextGaussian = v2 * multiplier;

haveNextNextGaussian = true;

return v1 * multiplier;

}

Isso usa o método polar de GEP Box, ME Muller e G. Marsaglia, conforme descrito por Donald E. Knuth em A Arte da Programação por Computador, Volume 2: Algoritmos Seminuméricos, seção 3.4.1, subseção C, algoritmo P. Observe que ele gera dois valores independentes ao custo de apenas uma chamada para StrictMath.log e uma chamada para StrictMath.sqrt.

Retornos:

No próximo pseudo-aleatório, Gaussiano (“normalmente”) distribuiu valor duplo com média 0,0 e desvio padrão 1,0 da sequência desse gerador de números aleatórios

Fonte do código: https://www.tutorialspoint.com/java/util/random_nextgaussian.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();
    
      // check next Gaussian value  
      System.out.println("Next Gaussian value: " + randomno.nextGaussian());
   }      
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// check next Gaussian value

System.out.println("Next Gaussian value: " + randomno.nextGaussian());

}

nextInt()

nextInt() – Retorna o próximo valor int de pseudoaleatório, distribuído uniformemente, a partir dessa sequência do gerador de números aleatórios.

public int nextInt() – Retorna o próximo valor int de pseudoaleatório, distribuído uniformemente, a partir dessa sequência do gerador de números aleatórios. O contrato geral de nextInt é que um valor int seja gerado e retornado pseudo-aleatoriamente. Todos os 2³² possíveis valores int são produzidos com (aproximadamente) igual probabilidade.
O método nextInt é implementado pela classe Random como se:

 public int nextInt() {
   return next(32);
 }

public int nextInt() {

return next(32);

}

Retornos:

o próximo pseudoaleatório, valor int uniformemente distribuído da sequência desse gerador de números aleatórios

Fonte do código: https://www.geeksforgeeks.org/java-util-random-nextint-java/

import java.util.*; 
public class NextInt1 { 
    public static void main(String[] args) 
    { 
  
        // create random object 
        Random ran = new Random(); 
  
        // generating integer 
        int nxt = ran.nextInt(); 
  
        // Printing the random Number 
        System.out.println 
        ("The Randomly generated integer is : " + nxt); 
    } 
}

import java.util.*;

public class NextInt1 {

public static void main(String[] args)

{

// create random object

Random ran = new Random();

// generating integer

int nxt = ran.nextInt();

// Printing the random Number

System.out.println

("The Randomly generated integer is : " + nxt);

}

nextInt(int bound)

nextInt(int bound) -Retorna um valor int pseudoaleatório, distribuído uniformemente entre 0 (inclusive) e o valor especificado (exclusivo), extraído dessa sequência do gerador de números aleatórios.

public int nextInt(int bound) – Retorna um valor int pseudoaleatório, distribuído uniformemente entre 0 (inclusive) e o valor especificado (exclusivo), extraído dessa sequência do gerador de números aleatórios. O contrato geral de nextInt é que um valor int no intervalo especificado seja gerado e retornado pseudo-aleatoriamente. Todos os valores int possíveis vinculados são produzidos com (aproximadamente) probabilidade igual. O método nextInt (int bound) é implementado pela classe Random como se por:

 public int nextInt(int bound) {
   if (bound &lt;= 0)
     throw new IllegalArgumentException("bound must be positive");

   if ((bound &amp; -bound) == bound)  // i.e., bound is a power of 2
     return (int)((bound * (long)next(31)) >> 31);

   int bits, val;
   do {
       bits = next(31);
       val = bits % bound;
   } while (bits - val + (bound-1) &lt; 0);
   return val;
 }

public int nextInt(int bound) {

if (bound <= 0)

throw new IllegalArgumentException("bound must be positive");

if ((bound & -bound) == bound) // i.e., bound is a power of 2

return (int)((bound * (long)next(31)) >> 31);

int bits, val;

do {

bits = next(31);

val = bits % bound;

} while (bits - val + (bound-1) < 0);

return val;

}

O hedge “aproximadamente” é usado na descrição anterior apenas porque o próximo método é apenas aproximadamente uma fonte imparcial de bits escolhidos independentemente. Se fosse uma fonte perfeita de bits escolhidos aleatoriamente, o algoritmo mostrado escolheria valores int do intervalo declarado com perfeita uniformidade.

O algoritmo é um pouco complicado. Ele rejeita valores que resultariam em uma distribuição desigual (devido ao fato de 2 ^ 31 não ser divisível por n). A probabilidade de um valor ser rejeitado depende de n. O pior caso é n = 2 ^ 30 + 1, para o qual a probabilidade de uma rejeição é 1/2 e o número esperado de iterações antes do loop terminar é 2.

590/5000O algoritmo trata o caso em que n é uma potência de dois especialmente: retorna o número correto de bits de alta ordem do gerador de números pseudo-aleatórios subjacentes. Na ausência de tratamento especial, o número correto de bits de baixa ordem seria retornado. Sabe-se que geradores de números pseudo-aleatórios lineares congruentes, como o implementado por esta classe, têm períodos curtos na sequência de valores de seus bits de ordem inferior. Portanto, esse caso especial aumenta muito o comprimento da sequência de valores retornados por chamadas sucessivas para esse método se n for uma pequena potência de dois.

Parâmetros:

bound – o limite superior (exclusivo). Deve ser positivo.

Retornos:

o próximo pseudoaleatório, valor int uniformemente distribuído entre zero (inclusive) e vinculado (exclusivo) a partir desta sequência do gerador de números aleatórios

Lançamentos:

IllegalArgumentException – se o limite não for positivo

Esse método existe desde a versão 1.2.

Fonte do código: https://mkyong.com/java/java-generate-random-integers-in-a-range/

private static int getRandomNumberInRange(int min, int max) {

	if (min >= max) {
		throw new IllegalArgumentException("max must be greater than min");
	}

	Random r = new Random();
	return r.nextInt((max - min) + 1) + min;
}

private static int getRandomNumberInRange(int min, int max) {

if (min >= max) {

throw new IllegalArgumentException("max must be greater than min");

}

Random r = new Random();

return r.nextInt((max - min) + 1) + min;

}

nextLong()

nextLong() – Retorna o próximo valor longo pseudoaleatório, uniformemente distribuído, a partir da sequência desse gerador de números aleatórios.

public long nextLong() – Retorna o próximo valor longo pseudoaleatório, uniformemente distribuído, a partir da sequência desse gerador de números aleatórios. O contrato geral de nextLong é que um valor longo é gerado e retornado pseudo-aleatoriamente.
O método nextLong é implementado pela classe Random como se por:

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

public long nextLong() {

return ((long)next(32) << 32) + next(32);

}

Como a classe Random usa uma semente com apenas 48 bits, esse algoritmo não retornará todos os valores longos possíveis.

Retornos:

o próximo valor longo pseudo-aleatório e uniformemente distribuído a partir da sequência desse gerador de números aleatórios

Fonte do código: https://www.tutorialspoint.com/java/util/random_nextlong.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();

      // get next long value 
      long value = randomno.nextLong();

      // check the value  
      System.out.println("Long value is: " + value);
   }    
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// get next long value

long value = randomno.nextLong();

// check the value

System.out.println("Long value is: " + value);

}

setSeed(long seed)

setSeed(long seed) – Define a semente deste gerador de números aleatórios usando uma única semente longa.

public void setSeed(long seed) – Define a semente deste gerador de números aleatórios usando uma única semente longa. O contrato geral de setSeed é que ele altera o estado desse objeto gerador de números aleatórios, de modo a estar exatamente no mesmo estado como se tivesse acabado de ser criado com o argumento seed como um seed. O método setSeed é implementado pela classe Random, atualizando atomicamente a semente para

(seed ^ 0x5DEECE66DL) &amp; ((1L &lt;&lt; 48) - 1)

1	(seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)

e limpando o sinalizador haveNextNextGaussian usado por nextGaussian().

A implementação de setSeed pela classe Random passa a usar apenas 48 bits da semente especificada. Em geral, no entanto, um método de substituição pode usar todos os 64 bits do argumento longo como um valor inicial.

Parâmetros:

semente – a semente inicial

Fonte do código: https://www.tutorialspoint.com/java/util/timezone_setseed.htm

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {
   public static void main( String args[] ) {
      
      // create random object
      Random randomno = new Random();

      // setting seed
      randomno.setSeed(20);

      // value after setting seed
      System.out.println("Object after seed: " + randomno.nextInt());
   }    
}

package com.tutorialspoint;

import java.util.*;

public class RandomDemo {

public static void main( String args[] ) {

// create random object

Random randomno = new Random();

// setting seed

randomno.setSeed(20);

// value after setting seed

System.out.println("Object after seed: " + randomno.nextInt());

}

Fonte: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/util/Random.html

longs(long randomNumberOrigin, long randomNumberBound)

longs(long streamSize, long randomNumberOrigin, long randomNumberBound)

next(int bits)

nextBoolean()

nextBytes(byte[] bytes)

nextDouble()

nextFloat()

nextGaussian()

nextInt()

nextInt(int bound)

nextLong()

setSeed(long seed)

Passando Dados Utilizando Funções de Invocações

Simplesmente um Programa HelloWorld

Como Formatar um PC

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

longs​(long randomNumberOrigin, long randomNumberBound)

longs​(long streamSize, long randomNumberOrigin, long randomNumberBound)

next​(int bits)

nextBoolean()

nextBytes​(byte[] bytes)

nextDouble()

nextFloat()

nextGaussian()

nextInt()

nextInt​(int bound)

nextLong()

setSeed​(long seed)

Passando Dados Utilizando Funções de Invocações

Simplesmente um Programa HelloWorld

Como Formatar um PC

Para enviar seu comentário, preencha os campos abaixo:

Deixe um comentário Cancelar resposta

Seja o primeiro a comentar!

Damos valor à sua privacidade

Cookies estritamente necessários

Cookies de desempenho

Cookies de funcionalidade

Cookies de publicidade

longs(long randomNumberOrigin, long randomNumberBound)

longs(long streamSize, long randomNumberOrigin, long randomNumberBound)

next(int bits)

nextBytes(byte[] bytes)

nextInt(int bound)

setSeed(long seed)