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.
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 modifica-as usando fórmulas de congruência linear (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
Aleatório()
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 Random (semente longa) {SETSEED (SEED);
protegido int a seguir (int bits)
Gere o próximo número pseudo-aleatom.
Boolean NextBoolean ()
Retorna o próximo número pseudo-aleatório, que é um valor booleano distribuído uniformemente retirado da sequência deste gerador de números aleatórios.
Void NextBytes (byte [] bytes)
Gere bytes aleatórios e coloque-os 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.
duplo 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 uma média 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 entre 0 (incluindo) e o valor especificado (excluindo) retirado da sequência deste gerador de números aleatórios.
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)
Defina 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 transportar sementes e não transportar sementes
O uso fundamental da classe aleatória é dividir as instâncias aleatórias com sementes e sem sementes.
Nos termos do leigo, a diferença entre os dois é:
Para sementes, o resultado gerado por cada execução é o mesmo.
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. Crie um objeto aleatório sem sementes
Existem duas maneiras:
1) aleatório aleatório = novo aleatório (555L);
2) aleatório aleatório = novo aleatório ();
Random.SeedSeed (555L);
4. Aplicação abrangente
A seguir, é apresentada uma classe de ferramenta de números aleatórios recentemente escrita para mostrar o uso:
A cópia do código é a seguinte:
importar java.util.random;
/**
* Número aleatório, ferramenta de string
* Usuário: Leizhimin
* Data: 2008-11-19 9:43:09
*/
classe pública Randomutils {
String final da estática pública Allchar = "0123456789abcdefghijklmnopqrstStuvwxyzabcdefghijklmnopqrStUvwxyz";
public static final string letterchar = "abcdefghijklmnopqrststuvwxyzabcdefghijklmnopqrStUvwxyz";
public static final string numberchar = "0123456789";
/**
* Retorne uma corda aleatória de comprimento fixo (incluindo apenas letras e números superiores e minúsculos)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
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 ();
}
/**
* Retorne um comprimento fixo Random Pure Letter String (incluindo apenas letras superiores e minúsculas)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
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 ();
}
/**
* Retornar um comprimento fixo Random Capital Pure Capital Letter String (incluindo apenas letras maiúsculas)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
public static string generatelowerstring (int length) {
retornar generatemixString (comprimento) .tolowerCase ();
}
/**
* Retorne um comprimento fixo Random Pure Boretcase String (incluindo apenas letras maiúsculas e minúsculas)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
public static string generateupupperstring (int length) {
retornar generatemixString (comprimento) .toupPercase ();
}
/**
* Gere uma string pura de 0 de comprimento fixo
*
* @param Comprimento do comprimento do comprimento
* @return pure 0 string
*/
public Static String GenerateZeroString (Int Length) {
StringBuffer sb = new StringBuffer ();
for (int i = 0; i <comprimento; i ++) {
sb.append ('0');
}
return sb.toString ();
}
/**
* Gere uma sequência de comprimento fixo com base no número, o comprimento não é suficiente para ser adicionado ao anterior.
*
* @param num número
* @param fixdlenth string comprimento
* @return string de comprimento fixo
*/
public static string tofixdlengthString (long num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
sb.append (generateztrostring (fixdlenth - strnum.length ()));
} outro {
lançar a nova RUNTimeException ("Número de converter" + num + "em uma string com comprimento" + FixDLENTH + "Exceção ocorre!");
}
sb.append (strnum);
return sb.toString ();
}
/**
* Gere uma sequência de comprimento fixo com base no número, o comprimento não é suficiente para ser adicionado ao anterior.
*
* @param num número
* @param fixdlenth string comprimento
* @return string de comprimento fixo
*/
public static string tofixdlengthString (int num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
sb.append (generateztrostring (fixdlenth - strnum.length ()));
} outro {
lançar a nova RUNTimeException ("Número de converter" + num + "em uma string com comprimento" + FixDLENTH + "Exceção ocorre!");
}
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));
}
}
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.
2. Os objetos de classe aleatória têm uma diferença entre eles carregam sementes.
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.
Código Suplementar:
A cópia do código é a seguinte:
pacote com.test;
importar java.util.random;
classe pública Randomutils {
String final da estática pública Allchar = "0123456789abcdefghijklmnopqrstStuvwxyzabcdefghijklmnopqrStUvwxyz";
public static final string letterchar = "abcdefghijkllmnopqrstuvwxyzabcdefghijklmnopqrstStuvwxyz";
public static final string numberchar = "0123456789";
/**
* Retorne uma corda aleatória de comprimento fixo (incluindo apenas letras e números superiores e minúsculos)
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
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 ();
}
/**
* Retorne um comprimento fixo Random Pure Letter String (incluindo apenas letras superiores e minúsculas)
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
Public Static String GeneratemixString (INT Length)
{
StringBuffer sb = new StringBuffer ();
Aleatório aleatório = novo aleatório ();
para (int i = 0; i <comprimento; i ++)
{
sb.append (allchar.charat (random.nextint (letterchar.length ())));
}
return sb.toString ();
}
/**
* Retornar um comprimento fixo Random Capital Pure Capital Letter String (incluindo apenas letras maiúsculas)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
public static string generatelowerstring (int length) {
retornar generatemixString (comprimento) .tolowerCase ();
}
/**
* Retorne um comprimento fixo Random Pure Boretcase String (incluindo apenas letras maiúsculas e minúsculas)
*
* @Param Comprimento do comprimento aleatório da corda
* @return string aleatória
*/
public static string generateupupperstring (int length) {
retornar generatemixString (comprimento) .toupPercase ();
}
/**
* Gere uma string pura de 0 de comprimento fixo
*
* @param Comprimento do comprimento do comprimento
* @return pure 0 string
*/
public Static String GenerateZeroString (Int Length) {
StringBuffer sb = new StringBuffer ();
for (int i = 0; i <comprimento; i ++) {
sb.append ('0');
}
return sb.toString ();
}
/**
* Gere uma sequência de comprimento fixo com base no número, o comprimento não é suficiente para ser adicionado ao anterior.
*
* @param num número
* @param fixdlenth string comprimento
* @return string de comprimento fixo
*/
public static string tofixdlengthString (long num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
sb.append (generateztrostring (fixdlenth - strnum.length ()));
} outro {
lançar a nova RUNTimeException ("Número de converter" + num + "em uma string com comprimento" + FixDLENTH + "Exceção ocorre!");
}
sb.append (strnum);
return sb.toString ();
}
/**
* Gere uma sequência de comprimento fixo com base no número, o comprimento não é suficiente para ser adicionado ao anterior.
*
* @param num número
* @param fixdlenth string comprimento
* @return string de comprimento fixo
*/
public static string tofixdlengthString (int num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
sb.append (generateztrostring (fixdlenth - strnum.length ()));
} outro {
lançar a nova RUNTimeException ("Número de converter" + num + "em uma string com comprimento" + FixDLENTH + "Exceção ocorre!");
}
sb.append (strnum);
return sb.toString ();
}
/**
* O número de dígitos len gerados cada vez é diferente
* @param param
* @return Número de comprimento fixo
*/
public static int getNotsImple (int [] param, int len)
{
Rand aleatório = novo aleatório ();
for (int i = param.length; i> 1; i--)
{
int index = rand.nextint (i);
int tmp = param [index];
param [index] = param [i - 1];
param [i - 1] = tmp;
}
int resultado = 0;
para (int i = 0; i <len; i ++)
{
resultado = resultado * 10 + param [i];
}
resultado de retorno;
}
public static void main (string [] args) {
System.out.println (generateString (10));
System.out.println (generatemixString (10));
System.out.println (generatelowerstring (10));
System.out.println (generateupperString (10));
System.out.println (generatezeroString (10));
System.out.println (TofixdLengthString (123, 10));
System.out.println (TofixdLengthString (123L, 10));
int [] in = {1,2,3,4,5,6,7};
System.out.println (getNotsImple (in, 3));
}
}