3 maneiras de obter números aleatórios em java

Introduz principalmente três métodos de obtenção de números aleatórios em Java, principalmente usando a função aleatória () para implementá -lo

Método 1

(Tipo de dados) (valor mínimo + math.random ()*(valor máximo -Minimum Value +1)) Exemplo:

 (int) (1+math.random ()*(10-1+1))

Int Tipo de 1 a 10

Método 2

Obter um número aleatório

 for (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10)

O método aleatório do pacote java.math recebe um número aleatório de 1-10

A fórmula é: valor mínimo ---- Número aleatório de valor máximo (integral)

(Tipo) min + math.random () * valor máximo

Método 3

 Aleatório ra = novo aleatório (); para (int i = 0; i <30; i ++) {System.out.println (ra.nextint (10) +1);}

Use o método NextInt de classe aleatória no pacote java.util para obter um número aleatório de 1-10

Gerar decimais aleatórios entre 0 e 1:

Para gerar um decimal aleatório no intervalo [0, d) e D é qualquer decimal positivo, você só precisa multiplicar o valor de retorno do método NextDouble por d.

[N1, N2]

Isso é ra.nextDouble () * (n2-n1)+n1

Várias maneiras de gerar números aleatórios em java

1. No J2SE, podemos usar o método Math.Random () para gerar um número aleatório. O número aleatório gerado é um dobro entre 0-1. Podemos multiplicá -lo por um determinado número, por exemplo, multiplicar por 100. É aleatório dentro de 100, que não existe no J2me.

2. No pacote java.util, é fornecida uma classe aleatória. Podemos criar um novo objeto aleatório para gerar números aleatórios. Pode gerar números números aleatórios, carros alegóricos aleatórios, duplas aleatórias e longas aleatórias. Esse também é um método de obter números aleatórios que costumamos usar nos programas J2ME.

3. Existe um método CurrentTimEmillis () em nossa classe de sistema. Este método retorna um número de milissegundos a partir das 0:00:00 em 1º de janeiro de 1970 para o atual. O tipo de retorno é longo. Podemos usá -lo como um número aleatório. Podemos usá -lo para modular alguns números e limitá -lo a um intervalo.

De fato, no método de construção padrão da Random, o terceiro método acima é usado para gerar números aleatórios.

A classe aleatória no método dois tem a seguinte descrição:

Existem duas maneiras de construir a classe java.util.random: com sementes e sem sementes

Sem sementes:

Esse método retornará números aleatórios e os resultados serão diferentes para cada execução.

 public class RandomTest {public static void main (string [] args) {java.util.random r = new java.util.random (); para (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}}}

Com sementes:

Dessa forma, não importa quantas vezes o programa seja executado, o resultado de retorno será o mesmo

 public static void main (string [] args) {java.util.random r = new java.util.random (10); para (int i = 0; i <10; i ++) {System.out.println (r.NextInt ();}}}}

A diferença entre os dois métodos é

(1) Primeiro, por favor, abra o Doc Java, veremos a descrição da classe aleatória:

Exemplos desta classe são usados ​​para gerar fluxos de números pseudo-aleatórios, que usam uma semente de 48 bits que pode ser modificada usando uma fórmula congruente linear.

Se duas instâncias aleatórias forem criadas com a mesma semente, a mesma sequência de chamadas de método será feita para cada instância e elas gerarão e retornarão a mesma sequência de números. Para garantir que esse recurso seja implementado, especificamos um algoritmo específico para a classe aleatória. Para a portabilidade total do código Java, as implementações Java devem ter a classe Random Use todos os algoritmos mostrados aqui. Mas as subclasses da classe aleatória podem usar outros algoritmos, desde que cumpram os acordos convencionais de todos os métodos.

O Java Doc explicou muito bem a classe aleatória e nossos testes verificaram isso.

(2) Se nenhum número de semente for fornecido, o número de sementes da instância aleatória serão os milissegundos do horário atual. Você pode obter os milissegundos do tempo atual através do System.CurrentTimemillis (). Abra o código -fonte do JDK e podemos ver isso com muita clareza.

 public Random () {this (System.currenttimemillis ()); }

além disso:

Descrição dos métodos NextInt (), NextInt (int n) do objeto aleatório:

int nextInt () // Retorna o próximo número pseudo-aleatório, que é o valor INT distribuído uniformemente na sequência deste gerador de números aleatórios.

int nextInt (int n) // retorna um número pseudo-aleatório, que é um valor int distribuído uniformemente entre 0 (incluindo) e o valor especificado (excluindo) retirado da sequência deste gerador de números aleatórios.

Resumo do número aleatório java

Os números aleatórios são amplamente utilizados na prática, como gerar uma corda ou número de comprimento fixo. Então, gere um número incerto ou execute uma seleção aleatória simulada, etc. O Java fornece as ferramentas mais básicas que podem ajudar os desenvolvedores a alcançar tudo isso.

1. Como gerar números aleatórios de Java

Em Java, existem três conceitos gerais de números aleatórios.

1. Use o System.CurrentTimemillis () para obter um número de milissegundos de longa duração no horário atual.

2. Retorne um valor duplo entre 0 e 1 através do Math.Random ().

3. Gere um número aleatório através da classe aleatória. Esta é uma classe de ferramentas aleatória profissional com funções poderosas.

2. Descrição da API aleatória

1. Descrição da API Java

Uma instância da classe aleatória é usada para gerar um fluxo de números pseudo-aleatórios. Esta classe usa sementes de 48 bits e usa uma fórmula congruente linear para modificá-las (consulte A Art of Computer Programming, de Donald Knuth, Volume 2, Seção 3.2.1).

Se duas instâncias aleatórias forem criadas com a mesma semente, a mesma sequência de chamadas de método será feita para cada instância e elas gerarão e retornarão a mesma sequência de números. Para garantir a implementação de atributos, um algoritmo específico é especificado para a classe aleatória.

Muitos aplicativos encontrarão o método aleatório na aula de matemática mais fácil de usar.

2. Resumo do método

Random () // Crie um novo gerador de números aleatórios.

Aleatório (semente longa) // Crie um novo gerador de números aleatórios usando uma única semente longa: public aleatoriamente (semente longa) {setseed (semente); } O próximo método o usa para salvar o estado do gerador de números aleatórios.

Protegido int próximo (int bits): gera o próximo número pseudo-aleatório.

Boolean NextBoolean (): Retorna o próximo número pseudo-aleatório, que é o valor booleano distribuído uniformemente retirado da sequência deste gerador de números aleatórios.

Void NextBytes (byte [] bytes): gera bytes aleatórios e os coloca em uma matriz de bytes fornecida pelo usuário.

Double NextDouble (): Retorna o próximo número pseudo-aleatório, que é um valor duplo distribuído uniformemente entre 0,0 e 1,0, retirado da sequência deste gerador de números aleatórios.

float nextfloat (): retorna o próximo número pseudo-aleatório, que é um valor de flutuação distribuído uniformemente entre 0,0 e 1,0 retirado da sequência deste gerador de números aleatórios.

Double Nextgaussian (): retorna o próximo número pseudo-aleatório, que é uma distribuição gaussiana ("normalmente") retirada da sequência desse gerador de números aleatórios, com um valor médio de 0,0 e um desvio padrão de 1,0.

int nextInt (): Retorna o próximo número pseudo-aleatom, que é o valor INT distribuído uniformemente na sequência deste gerador de números aleatórios.

int nextInt (int n): retorna um número pseudo-aleatório que é um valor int distribuído uniformemente retirado da sequência deste gerador de números aleatórios e é distribuído uniformemente entre 0 (incluindo) e o valor especificado (excluindo).

Long NextLong (): Retorna o próximo número pseudo-aleatório, que é um valor longo distribuído uniformemente retirado da sequência deste gerador de números aleatórios.

Conjunto de vazios (semente longa): define a semente deste gerador de números aleatórios usando uma única semente longa.

3. Instruções de uso de classe aleatória

1. A diferença entre tomar sementes e não tomar sementes. O uso fundamental da classe aleatória é dividir os exemplos aleatórios com sementes e sem sementes.

Nos termos do leigo, a diferença entre os dois é: se as sementes forem produzidas, os resultados gerados por cada execução são os mesmos.

Se você não tem sementes, o que você gera é aleatório toda vez que você executa e não há nenhum padrão.

2. Crie um objeto aleatório sem sementes

 Aleatório aleatório = novo aleatório ();

3. Existem duas maneiras de criar um objeto aleatório sem sementes:

1) aleatório aleatório = novo aleatório (555L);

2) aleatórios aleatórios = novo aleatório (); aleatório.

4. Teste

Use um exemplo para ilustrar o uso acima

 importar java.util.random; classe pública testrandomnum {public static void main (string [] args) {randomTest (); testNoseed (); testSeed1 (); testSeed2 (); } public static void RandomTest () { System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  long R1 = System.CurrentTimMillis (); System.out.println ("r2 =" + r3); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- for (int i = 0; i <3; i ++) {System.out.println (aleatory.nextInt ()); }} public static void testSeed1 () { System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Resultados em execução:

--------------teste()--------------
R1 = 1227108626582
R3 = 0,5324887850155043
r2 = -368083737
-------------- TestNoseed () --------------
809503475
1585541532
-645134204
-------------- TestSeed1 () ----------------
-1367481220
292886146
-1462441651
-------------- TestSeed2 () ----------------
-1367481220
292886146
-1462441651
Processo terminado com o código de saída 0

Através dos resultados dos métodos TestSeed1 () e TestSeed2 (), podemos ver que os dois resultados de impressão são iguais porque vêem o mesmo. Se eles correrem novamente, o resultado ainda será o mesmo. Esta é a característica de números aleatórios com sementes. Se você não tiver sementes, os resultados de cada execução são aleatórios.

V. Aplicação abrangente

A seguir, é apresentada uma classe de ferramenta de números aleatórios recentemente escrita para mostrar o uso:

 importar java.util.random; classe pública Randomutils {public static final string allchar = "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrststwxyz"; public static final string letterchar = "abcdefghijklmnopqrststuvwxyzabcdefghijklmnopqrStUvwxyz"; public static final string numberchar = "0123456789"; public static string generatestring (int length) {stringbuffer sb = new stringBuffer (); Aleatório aleatório = novo aleatório (); for (int i = 0; i <comprimento; i ++) {sb.append (allchar.charat (random.nextInt (allchar.length ()))); } return sb.toString (); } public static string generatemixstring (int length) {stringbuffer sb = new stringBuffer (); Aleatório aleatório = novo aleatório (); for (int i = 0; i <comprimento; i ++) {sb.append (allchar.charat (random.nextInt (letterchar.length ()))); } return sb.toString (); } public static string generatelowerstring (int length) {return generatemixString (comprimento) .tolowerCase (); } public static string generateUpperString (int length) {return generatemixString (length) .toupPercase (); } public static string generateZeroString (int length) {stringbuffer sb = new StringBuffer (); for (int i = 0; i <comprimento; i ++) {sb.append ('0'); } return sb.toString (); } public static string tofixdLengthString (long num, int fixDlenth) {stringBuffer sb = new StringBuffer (); String strnum = string.valueof (num); if (fixdlenth - strnum.length ()> = 0) {sb.append (generateZeroString (fixdlenth - strnum.length ()); } else {Throw RUNTimeException ("Número de convertido" + num + "Exceção ocorre quando uma exceção é feita para uma string com comprimento" + fixDlenth + ");} sb.append (strnum); return sb.toString ();} public static stric tOfixndtring string (int num, int fixdlenth) { String.ValueOf (num); } sb.append (strnum); return sb.toString (); } public static void main (string [] args) {System.out.println (generatestring (15)); System.out.println (generatemixString (15)); System.out.println (generatelowerstring (15)); System.out.println (generateupperstring (15)); System.out.println (generatezeroString (15)); System.out.println (TofixdLengthString (123, 15)); System.out.println (TofixdLengthString (123L, 15)); System.out.println (TofixdLengthString (123L, 15)); }}

Resultados em execução:

VWMBPINBZFGCPHG
23HyRAHDJKKPWMV
TIGOWETBWKM1NDE
Bpz1knejphb115n
000000000000000000
00000000000000123
00000000000000123
Processo terminado com o código de saída 0

6. Resumo

1. Os números aleatórios são muito usados. Existem três maneiras de gerá -las em Java. Números aleatórios aleatórios são os mais complexos.

2. Os objetos de classe aleatória têm uma diferença entre se eles carregam sementes. Enquanto as sementes forem iguais, elas funcionam várias vezes, e o resultado da geração de números aleatórios é sempre o mesmo.

3. Existem duas maneiras de criar objetos de sementes com números aleatórios, com o mesmo efeito. Mas números aleatórios com sementes não parecem muito úteis.

4. As funções da Random abrangem as funções de Math.Random ().

5. Você pode usar números aleatórios para implementar dados aleatórios complexos, como seqüências aleatórias.

6. Não estuda números aleatórios que não se repetem, não é muito significativo.

Em Java, podemos usar a classe java.util.random para gerar um gerador de números aleatórios. Possui duas formas de construtores, ou seja, aleatório () e aleatório (semente longa). Random () usa o tempo atual, System.CurrentTimemillis (), como a semente do gerador e aleatória (semente longa) usa a semente especificada como semente do gerador.

Depois que o objeto gerador de números aleatórios (aleatório) é gerado, diferentes tipos de números aleatórios são obtidos chamando diferentes métodos: NextInt (), NextLong (), NextFloat (), NextDouble (), etc.

1> gerar números aleatórios

 Aleatório aleatório = novo aleatório (); Aleatório aleatório = novo aleatório (100); // especificar o número de sementes 100

chama os métodos aleatórios diferentes para obter números aleatórios.

Se 2 objetos aleatórios usarem a mesma semente (por exemplo, ambos são 100) e a mesma função é chamada na mesma ordem, seus valores de retorno serão exatamente iguais. Como no código a seguir, a saída dos dois objetos aleatórios é exatamente o mesmo

 importar java.util.*; classe testrandom {public static void main (string [] args) {aleatom1 = novo aleatório (100); System.out.println (Random1.NextInt ()); System.out.println (random1.nextfloat ()); System.out.println (Random1.NextBoolean ()); Aleatório aleatório2 = novo aleatório (100); System.out.println (Random2.NextInt ()); System.out.println (Random2.NextFloat ()); System.out.println (Random2.NextBoolean ()); }}

2> números aleatórios no intervalo especificado

Números aleatórios são controlados dentro de um determinado intervalo, usando o operador do módulo %

 importar java.util.*; classe testrandom {public static void main (string [] args) {aleatório aleatório = novo aleatório (); for (int i = 0; i <10; i ++) {System.out.println (Math.abs (aleatory.nextInt ())); }}}

Os números aleatórios obtidos são positivos e negativos. Use Math.abs para tornar o intervalo de dados recuperado como números não negativos.

3> Obtenha números aleatórios não repetitivos dentro da faixa especificada

 importar java.util.*; classe testrandom {public static void main (string [] args) {int [] intret = new int [6]; intd = 0; // Números aleatórios de armazenamento int count = 0; // Registre os números aleatórios gerados int sinalizador = 0; // se o sinalizador foi gerado enquanto (contagem <6) {aleatório rdm = new aleatom (system.currenttimemillis ()); intd = math.abs (rdm.NextInt ()) 2+1; for (int i = 0; i <count; i ++) {if (intret [i] == intrd) {sinalizador = 1; quebrar; } else {flag = 0; }} if (flag == 0) {intret [count] = intd; contagem ++; }} para (int t = 0; t <6; t ++) {System.out.println (t+"->"+intret [t]); }}}

Os números aleatórios em Java podem ser repetidos? Os números aleatórios gerados em Java podem ser usados ​​para gerar teclas primárias de banco de dados? Com esta pergunta em mente, fizemos uma série de testes.

1. Teste 1: use o construtor aleatório () sem parâmetros

 public class RandomTest {public static void main (string [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {System.out.println (r.NextInt ()); }}}

Resultados em execução do programa:

-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157

Execute o programa novamente:

-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608

No teste acima, podemos ver que os números aleatórios gerados usando o construtor aleatom () sem parâmetros não serão repetidos. Então, em que circunstâncias Java produz números aleatórios duplicados? Vamos ver o teste abaixo.

2. Teste 2: defina o número de sementes para aleatório

 public class Randomtest_repeat {public static void main (string [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {System.out.println (r.NextInt ()); }}}

Não importa quantas vezes o programa seja executado, o resultado é sempre:

-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428

Mesmo se você o testar em diferentes máquinas, os resultados do teste não mudarão!

3. Análise de causa:

(1) Primeiro, por favor, abra o Doc Java, veremos a descrição da classe aleatória:

Exemplos desta classe são usados ​​para gerar fluxos de números de pseudo-aleatórios, que usam uma semente de 48 bits que pode ser modificada usando uma fórmula congruente linear (consulte a programação da arte da computação de Donald Knuth, Volume 2, Seção 3.2.1).

Se duas instâncias aleatórias forem criadas com a mesma semente, a mesma sequência de chamadas de método será feita para cada instância e elas gerarão e retornarão a mesma sequência de números. Para garantir que esse recurso seja implementado, especificamos um algoritmo específico para a classe aleatória. Para a portabilidade total do código Java, as implementações Java devem ter a classe Random Use todos os algoritmos mostrados aqui. Mas as subclasses da classe aleatória podem usar outros algoritmos, desde que cumpram os acordos convencionais de todos os métodos.

O Java Doc explicou muito bem a classe aleatória e nossos testes verificaram isso.

(2) Se nenhum número de semente for fornecido, o número de sementes da instância aleatória serão os milissegundos do horário atual. Você pode obter os milissegundos do tempo atual através do System.CurrentTimemillis (). Abra o código -fonte do JDK e podemos ver isso com muita clareza.

 public Random () {this (System.currenttimemillis ()); }

4. Conclusão:

Através dos testes e análises acima, teremos uma compreensão mais profunda da classe aleatória. Ao mesmo tempo, acho que, ao ler a documentação da API do Java DOC, nossos recursos de programação Java pode ser bastante aprimorada e "conhecer a verdade" pode ser alcançado; Uma vez que encontramos problemas intrigados, também podemos abrir o código -fonte do Java para que possamos "saber a verdade".

Geralmente, existem dois tipos de números aleatórios em Java, um é o método aleatório () em matemática e o outro é a classe aleatória.

1. Math.Random ()

Um número decimal de 0 <x <1 é gerado.

Exemplo: como escrever e gerar aleatoriamente um dos números de 0 a 100?

Math.Random () retorna apenas um decimal de 0 a 1. Se você quiser 50 a 100, você zoom em 50 vezes primeiro, ou seja, entre 0 e 50. Aqui ainda é um decimal. Se você quiser um número inteiro, você lançará Int e adicione 50 a 50 a 100.

Código final: (int) (math.random ()*50) + 50

2. Classe aleatória

 Aleatoriamente aleatório = novo aleatório (); // construtor padrão aleatório = novo aleatório (1000); // especificar o número de sementes

Ao realizar randomização, o número de origem do algoritmo aleatório é chamado de sementes, que executa uma certa transformação com base nas sementes, gerando assim os números aleatórios necessários.
Objetos aleatórios com o mesmo número de sementes, os números aleatórios gerados pelo mesmo número de vezes são exatamente os mesmos. Em outras palavras, para dois objetos aleatórios com o mesmo número de sementes, os números aleatórios gerados pela primeira vez são exatamente os mesmos, e os números aleatórios gerados pela segunda vez são exatamente os mesmos.

2. Métodos comuns em classe aleatória

Os métodos na classe aleatória são relativamente simples e as funções de cada método também são fáceis de entender. Deve -se notar que os números aleatórios gerados por cada método na classe aleatória são distribuídos uniformemente, o que significa que a probabilidade de geração numérica dentro do intervalo é igual. Aqui está uma introdução básica a esses métodos:

A, público booleano NextBoolean ()

A função desse método é gerar um valor booleano aleatório, e a probabilidade de gerar valores verdadeiros e falsos é igual, ou seja, ambos são 50%.

B, Public Double NextDouble ()

O objetivo deste método é gerar um valor duplo aleatório, o valor está entre [0, 1.0). Aqui, os colchetes representam os pontos de extremidade que contêm o intervalo, e os colchetes representam os pontos de extremidade que não incluem o intervalo, ou seja, um decimal aleatório entre 0 e 1, contendo 0, mas não 1.0.

C, Public int NextInt ()

O objetivo deste método é gerar um valor INT aleatório, que está entre a 31ª potência de -2 e 31ª potência de -1st Power of 2.

Se você precisar gerar um valor int para um intervalo especificado, precisará executar uma certa transformação matemática. Para detalhes, consulte o código no exemplo de uso abaixo.

D, Public int NextInt (int n)

A função desse método é gerar um valor INT aleatório, que está dentro do intervalo de [0, n), ou seja, um valor de int aleatório entre 0 e n, contendo 0, mas não n.

Se você deseja gerar um valor int para um intervalo especificado, também precisa executar uma certa transformação matemática. Para detalhes, consulte o código no exemplo de uso abaixo.

E, Seteed de vazio público (semente longa)

O objetivo deste método é redefinir o número de sementes no objeto aleatório. Depois de definir o número de sementes, o objeto aleatório é o mesmo que o objeto aleatório criado com a nova palavra -chave.

3. Exemplo de uso de classe aleatória

Usando a classe aleatória, geralmente é gerar números aleatórios para um intervalo especificado. O seguinte introduzirá como gerar números aleatórios para um intervalo correspondente um por um. Os códigos a seguir que geram números aleatórios são gerados usando o seguinte objeto aleatório R:

 Aleatório r = novo aleatório ();

um. Gerar decimais do intervalo [0,1.0)

 duplo d1 = r.nextDouble ();

É obtido diretamente usando o método NextDouble.

b. Gerar decimais do intervalo [0,5.0)

 duplo d2 = r.nextDouble () * 5;

Como o intervalo numérico gerado pelo método NextDouble é [0, 1.0), a expansão do intervalo em 5 vezes é o intervalo necessário.

Da mesma forma, para gerar um decimal aleatório no intervalo [0, d) e D é qualquer decimal positivo, você só precisa multiplicar o valor de retorno do método NextDouble por d.

c. Gerar o número decimal [n1, n2] do intervalo [1, 2.5) [1]

duplo d3 = r.nextDouble () * 1.5 + 1; 【isto é, r.nextDouble () * (n2-n1) + n1】

Para gerar um decimal aleatório do intervalo [1, 2.5), você só precisa gerar primeiro um número aleatório do intervalo [0, 1.5) e depois adicionar 1 ao intervalo de número aleatório gerado.

Da mesma forma, para gerar qualquer número aleatório na faixa de intervalo decimal [D1, D2) que não começa a partir de 0 (onde D1 não é igual a 0), você só precisa gerar primeiro um número aleatório no intervalo [0, D2-D1) e depois adicionar o intervalo de número aleatório gerado a D1.

d. Gerar qualquer número inteiro

 int n1 = r.nextint ();

Basta usar o método NextInt diretamente.

e. Gerar números inteiros em intervalo [0,10)

 int n2 = r.nextint (10); n2 = math.abs (r.nextint () % 10);

As duas linhas de código acima podem gerar números inteiros no intervalo [0,10).

A primeira implementação é implementada diretamente usando o método NextInt (int n) na classe aleatória.

Na segunda implementação, o método First Call NextInt () para gerar um número INT arbitrário. O intervalo gerado pela soma número do número 10 é (-10,10), porque, de acordo com a especificação matemática, o valor absoluto do restante é menor que o divisor e, em seguida, o valor absoluto do intervalo é calculado e o intervalo resultante é [0,10).

Da mesma forma, para gerar números inteiros aleatórios em qualquer intervalo [0, n), você pode usar o seguinte código:

 int n2 = r.nextint (n); n2 = math.abs (r.nextint () % n);

f. Gerar números inteiros em intervalo [0,10]

 int n3 = r.nextint (11); n3 = math.abs (r.nextint () % 11);

Comparado com o intervalo inteiro, o intervalo [0,10] e o intervalo [0,11) são equivalentes; portanto, um número inteiro do intervalo [0,11) é gerado.

g. Gerar números inteiros no intervalo [-3,15)

 int n4 = r.nextint (18) - 3; // 【isto é, r.nextint () * (n2 -n1)+n1】 n1 é um número negativo n4 = math.abs (r.nextint () % 18) - 3;

Para gerar números inteiros aleatórios que não começam a partir de 0, você pode consultar a descrição acima do princípio da implementação do intervalo decimal que não começa a partir de 0.

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.