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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
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
|
1 |
(seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1) |
e retorna
|
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:
|
1 2 3 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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:
|
1 2 3 4 5 6 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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:
|
1 2 3 4 |
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:
|
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:
Fonte do código: https://www.geeksforgeeks.org/random-nextdouble-method-in-java-with-examples/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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 224 valores possíveis de flutuação da forma m x 224 , em que m é um número inteiro positivo menor que 224 , são produzidos com (aproximadamente) probabilidade igual.
O método nextFloat é implementado pela classe Random como se por:
|
1 2 3 |
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:
|
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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 232 possíveis valores int são produzidos com (aproximadamente) igual probabilidade.
O método nextInt é implementado pela classe Random como se:
|
1 2 3 |
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/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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/
|
1 2 3 4 5 6 7 8 9 |
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:
|
1 2 3 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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
|
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
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
Deixe um comentário