Introduce principalmente tres métodos para obtener números aleatorios en Java, principalmente utilizando la función aleatoria () para implementarlo
Método 1
(Tipo de datos) (valor mínimo + math.random ()*(valor máximo -minimum valor +1)) Ejemplo:
(int) (1+math.random ()*(10-1+1))
Into de 1 a 10
Método 2
Obtener un número aleatorio
para (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10) El método aleatorio del paquete Java.Math obtiene un número aleatorio int de 1-10
La fórmula es: valor mínimo ---- número aleatorio de valor máximo (integral)
(Tipo) min + math.random () * Valor máximo
Método 3
Random RA = new Random (); for (int i = 0; i <30; i ++) {System.out.println (ra.nextint (10) +1);} Use el método NextInt de clase aleatoria en el paquete java.util para obtener un número aleatorio int de 1-10
Genere los decimales aleatorios entre 0 y 1:
Para generar un decimal aleatorio en el intervalo [0, d) y D es cualquier decimal positivo, solo necesita multiplicar el valor de retorno del método NextDouble por d.
[N1, N2]
Eso es ra.nextDouble () * (n2-n1)+n1
Varias formas de generar números aleatorios en Java
1. En J2SE, podemos usar el método Math.Random () para generar un número aleatorio. El número aleatorio generado es un doble entre 0-1. Podemos multiplicarlo por cierto número, por ejemplo, multiplicar por 100. Es un aleatorio dentro de 100, que no existe en J2ME.
2. En el paquete java.util, se proporciona una clase aleatoria. Podemos crear un nuevo objeto aleatorio para generar números aleatorios. Puede generar enteros aleatorios, flotadores aleatorios, dobles aleatorios y largos aleatorios. Este es también un método para tomar números aleatorios que a menudo usamos en los programas J2ME.
3. Hay un método CurrentTimemillis () en nuestra clase de sistema. Este método devuelve un número de milisegundos a partir de las 0:00:00 el 1 de enero de 1970 al actual. El tipo de retorno es largo. Podemos usarlo como un número aleatorio. Podemos usarlo para modular algunos números y limitarlo a un rango.
De hecho, en el método de construcción predeterminado de Random, el tercer método anterior se usa para generar números aleatorios.
La clase aleatoria en el método dos tiene la siguiente descripción:
Hay dos formas de construir la clase java.util.random: con semillas y sin semillas
Sin semillas:
Este método devolverá números aleatorios, y los resultados serán diferentes para cada ejecución.
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 ());}} Con semillas:
De esta manera, no importa cuántas veces se ejecute el programa, el resultado de retorno será el mismo
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 ());}} La diferencia entre los dos métodos es
(1) Primero, abra Java Doc, veremos la descripción de la clase aleatoria:
Se utilizan ejemplos de esta clase para generar secuencias de números pseudo-aleatorios, que usan una semilla de 48 bits que puede modificarse utilizando una fórmula congruente lineal.
Si se crean dos instancias aleatorias con la misma semilla, se realiza la misma secuencia de llamadas de método en cada instancia y generarán y devolverán la misma secuencia de números. Para garantizar que se implementa esta característica, especificamos un algoritmo específico para la clase aleatoria. Para la portabilidad completa del código Java, las implementaciones de Java deben tener la clase de uso aleatorio todos los algoritmos que se muestran aquí. Pero las subclases de clase aleatoria pueden usar otros algoritmos siempre que cumplan con los acuerdos convencionales de todos los métodos.
Java Doc ha explicado muy bien la clase aleatoria, y nuestras pruebas lo han verificado.
(2) Si no se proporciona un número de semilla, el número de semillas de la instancia aleatoria será los milisegundos de la hora actual. Puede obtener los milisegundos de la hora actual a través de System.CurrentTimemillis (). Abra el código fuente de JDK y podemos ver esto muy claramente.
public Random () {this (System.CurrentTimemillis ()); } además:
Descripción de los métodos NextInt (), NextInt (int n) del objeto aleatorio:
int nextInt () // Devuelve el siguiente número de pseudo-aleatorio, que es el valor INT distribuido uniformemente en la secuencia de este generador de números aleatorios.
int nextInt (int n) // Devuelve un número pseudo-aleatorio, que es un valor int distribuido entre 0 (incluido) y el valor especificado (excluyendo) tomado de la secuencia de este generador de números aleatorios.
Resumen de número aleatorio de Java
Los números aleatorios se usan ampliamente en la práctica, como generar una cadena o número de longitud fija. Luego, genere una serie de longitud incierta o realice una selección aleatoria simulada, etc. Java proporciona las herramientas más básicas que pueden ayudar a los desarrolladores a lograr todo esto.
1. Cómo generar números aleatorios de Java
En Java, hay tres conceptos generales de números aleatorios.
1. Use System.CurrentTimemillis () para obtener un número de milisegundos de tipo largo en la hora actual.
2. Devuelva un valor doble entre 0 y 1 a través de Math.Random ().
3. Genere un número aleatorio a través de la clase aleatoria. Esta es una clase profesional de herramientas aleatorias con funciones poderosas.
2. Descripción aleatoria de la API
1. Descripción de la API de Java
Se utiliza una instancia de la clase aleatoria para generar una secuencia de números pseudo-aleatorio. Esta clase usa semillas de 48 bits y usa una fórmula congruente lineal para modificarlas (ver Donald Knuth's The Art of Computer Programming, Volumen 2, Sección 3.2.1).
Si se crean dos instancias aleatorias con la misma semilla, se realiza la misma secuencia de llamadas de método en cada instancia y generarán y devolverán la misma secuencia de números. Para garantizar la implementación de atributos, se especifica un algoritmo específico para la clase aleatoria.
Muchas aplicaciones encontrarán el método aleatorio en la clase de matemáticas más fácil de usar.
2. Resumen del método
Random () // Cree un nuevo generador de números aleatorios.
Aleatorio (semilla larga) // crea un nuevo generador de números aleatorios usando una sola semilla larga: pública aleatoria (semilla larga) {setseed (semilla); } El siguiente método lo usa para guardar el estado del generador de números aleatorios.
Protected int Next (int bits): genera el siguiente número pseudo-aleatorio.
Boolean NextBoolean (): Devuelve el siguiente número de pseudo-aleatorio, que es el valor booleano distribuido uniformemente tomado de la secuencia de este generador de números aleatorios.
Void NextBytes (byte [] bytes): genera bytes aleatorios y los coloca en una matriz de bytes proporcionada por el usuario.
Double NextDouble (): Devuelve el siguiente número de pseudo-aleatorio, que es un valor doble distribuido entre 0.0 y 1.0, tomado de la secuencia de este generador de números aleatorios.
Float NextFloat (): Devuelve el siguiente número pseudo-aleatorio, que es un valor de flotación distribuido entre 0.0 y 1.0 tomado de la secuencia de este generador de números aleatorios.
Doble NextGaussian (): Devuelve el siguiente número de pseudo-aleatorio, que es una distribución gaussiana ("normalmente") tomada de la secuencia de este generador de números aleatorios, con un valor promedio de 0.0 y una desviación estándar de 1.0.
int nextInt (): Devuelve el siguiente número de pseudo-aleatorio, que es el valor INT distribuido uniformemente en la secuencia de este generador de números aleatorios.
int NextInt (int n): Devuelve un número pseudo-aleatorio que es un valor INT distribuido uniformemente tomado de la secuencia de este generador de números aleatorios y se distribuye uniformemente entre 0 (incluyendo) y el valor especificado (excluyendo).
Long NextLong (): Devuelve el siguiente número pseudo-aleatorio, que es un valor largo distribuido uniformemente tomado de la secuencia de este generador de números aleatorios.
Vacío Setseed (semilla larga): establece la semilla de este generador de números aleatorios usando una sola semilla larga.
3. Instrucciones de uso de clase aleatoria
1. La diferencia entre tomar semillas y no tomar semillas. El uso fundamental de la clase aleatoria es dividir los ejemplos de aleatorios con semillas y sin semillas.
En términos de laicos, la diferencia entre los dos es: si se producen las semillas, los resultados generados por cada ejecución son los mismos.
Si no tiene semillas, lo que genera es aleatorio cada vez que corre, y no hay ningún patrón en absoluto.
2. Crea un objeto aleatorio sin semillas
Aleatorio aleatorio = new Random ();
3. Hay dos formas de crear un objeto aleatorio sin semillas:
1) aleatorio aleatorio = nuevo aleatorio (555L);
2) aleatorio aleatorio = new Random (); Random.SetSeed (555L);
4. Prueba
Use un ejemplo para ilustrar el uso de arriba
import java.util.random; public class testRandomNum {public static void main (string [] args) {randomTest (); testnoseed (); testSeed1 (); testSeed2 (); } public static void randomTest () { System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- long R1 = System.CurrentTimemillis (); System.out.println ("r2 =" + r3); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Random(); for (int i = 0; i <3; i ++) {System.out.println (random.nextInt ()); }} public static void testSeed1 () { System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- Resultados de ejecución:
--------------prueba()--------------
R1 = 1227108626582
R3 = 0.5324887850155043
R2 = -368083737
-------------- Testnoseed () --------------
809503475
1585541532
-645134204
-------------- TestSeed1 () --------------
-1367481220
292886146
-1462441651
-------------- TestSeed2 () --------------
-1367481220
292886146
-1462441651
Proceso terminado con el código de salida 0
A través de los resultados de los métodos TestSeed1 () y TestSeed2 (), podemos ver que los dos resultados de impresión son los mismos porque ven lo mismo. Si vuelven a funcionar, el resultado seguirá siendo el mismo. Esta es la característica de los números aleatorios con semillas. Si no tiene semillas, los resultados de cada ejecución son aleatorios.
V. Aplicación integral
La siguiente es una clase de herramienta de número aleatorio recientemente escrita para mostrar el uso:
import java.util.random; public class RandomUtils {public static final String Allchar = "0123456789ABCDefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public static final String LetterChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ"; public static final String numberChar = "0123456789"; public static String GenerateString (int long) {StringBuffer sb = new StringBuffer (); Aleatorio aleatorio = new Random (); for (int i = 0; i <longitud; i ++) {sb.append (allchar.charat (random.nextint (allchar.length ())); } return sb.ToString (); } public static String GeneratEmIxString (int longitud) {StringBuffer sb = new StringBuffer (); Aleatorio aleatorio = new Random (); for (int i = 0; i <longitud; i ++) {sb.append (allchar.charat (random.nextint (lotterchar.length ())); } return sb.ToString (); } public static String GenerAtelowerString (int longitud) {return GenerAtemIrString (longitud) .tolowerCase (); } public static String GenerateUpperString (int longitud) {return GeneratEmIxString (longitud) .ToUpperperCase (); } public static String GenerAcleString (int longitud) {StringBuffer sb = new StringBuffer (); for (int i = 0; i <longitud; 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 (generateElozerString (fixDLenth - strnum.length ())); } else {Throw New RuntimeException ("Convertir número" + num + "La excepción se produce cuando se realiza una excepción a una cadena con longitud" + fixDlenth + ");} sb.append (strnum); return sb.ToString ();} public static static string tofixdlengthing (int String.ValueOf (num); } sb.append (strnum); return sb.ToString (); } public static void main (string [] args) {system.out.println (generatring (15)); System.out.println (GenerateMixString (15)); System.out.println (GenerAtelowerString (15)); System.out.println (generateUpperstring (15)); System.out.println (GenerAleseString (15)); System.out.println (tofixdLengthString (123, 15)); System.out.println (tofixdLengthString (123l, 15)); System.out.println (tofixdLengthString (123l, 15)); }}Resultados de ejecución:
vwmbpinbzfgcphg
23hyrahdjkpwmv
tigowetbwkm1nde
Bpz1knejphb115n
00000000000000000000
0000000000000000123
0000000000000000123
Proceso terminado con el código de salida 0
6. Resumen
1. Los números aleatorios se usan muy comúnmente. Hay tres formas de generarlos en Java. Los números aleatorios aleatorios son los más complejos.
2. Los objetos de clase aleatoria tienen una diferencia entre si llevan semillas. Mientras las semillas sean las mismas, funcionan varias veces, y el resultado de generar números aleatorios es siempre el mismo.
3. Hay dos formas de crear objetos de semillas con números aleatorios, con el mismo efecto. Pero los números aleatorios con semillas no parecen ser de gran utilidad.
4. Las funciones aleatorias cubren las funciones de Math.random ().
5. Puede usar números aleatorios para implementar datos aleatorios complejos como cadenas aleatorias.
6. No estudie números aleatorios que no se repitan, no es muy significativo.
En Java podemos usar la clase java.util.random para generar un generador de números aleatorios. Tiene dos formas de constructores, a saber, aleatorio () y aleatorio (semilla larga). Random () usa la hora actual, System.CurrentTimemillis (), como la semilla del generador, y al azar (semilla larga) usa la semilla especificada como la semilla del generador.
Después de generar el objeto de generador de números aleatorios (aleatorio), se obtienen diferentes tipos de números aleatorios llamando a diferentes métodos: nextInt (), nextLong (), nextFloat (), nextDouble (), etc.
1> Generar números aleatorios
Aleatorio aleatorio = new Random (); Aleatorio aleatorio = nuevo aleatorio (100); // especificar el número de semillas 100
Llama al azar diferentes métodos para obtener números aleatorios.
Si 2 objetos aleatorios usan la misma semilla (por ejemplo, ambos son 100) y la misma función se llama en el mismo orden, entonces sus valores de retorno son exactamente los mismos. Como en el siguiente código, la salida de los dos objetos aleatorios es exactamente el mismo
import java.util.*; clase testRandom {public static void main (string [] args) {random random1 = new Random (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (Random1.NextBoolean ()); Aleatorio aleatorio2 = nuevo aleatorio (100); System.out.println (random2.NextInt ()); System.out.println (random2.Nextfloat ()); System.out.println (random2.NextBoolean ()); }} 2> Números aleatorios en el rango especificado
Los números aleatorios se controlan dentro de un rango determinado, utilizando el operador de módulo %
import java.util.*; class testRandom {public static void main (string [] args) {random random = new Random (); for (int i = 0; i <10; i ++) {System.out.println (math.abs (random.nextInt ())); }}}Los números aleatorios obtenidos son positivos y negativos. Use math.abs para hacer que el rango de datos recupere como números no negativos.
3> Obtener números aleatorios no repetitivos dentro del rango especificado
import java.util.*; class testRandom {public static void main (string [] args) {int [] intet = new int [6]; intrd = 0; // almacenamiento de números aleatorios int count = 0; // Registre los números aleatorios generados int flag = 0; // si el indicador se ha generado mientras (cuente <6) {random rdm = new Random (System.CurrentTimemillis ()); intrd = math.abs (rdm.nextint ()) 2+1; for (int i = 0; i <count; i ++) {if (intet [i] == intrd) {flag = 1; romper; } else {flag = 0; }} if (flag == 0) {intet [count] = intrd; contar ++; }} para (int t = 0; t <6; t ++) {system.out.println (t+"->"+intet [t]); }}} ¿Se pueden repetir los números aleatorios en Java? ¿Se pueden usar números aleatorios generados en Java para generar claves primarias de la base de datos? Con esta pregunta en mente, hicimos una serie de pruebas.
1. Prueba 1: use el constructor aleatorio () sin 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 ()); }}} Programa de ejecución de resultados:
-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157
Ejecute el programa nuevamente:
-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608
De la prueba anterior podemos ver que los números aleatorios generados mediante el uso del constructor aleatorial () sin parámetros no se repetirán. Entonces, ¿en qué circunstancias produce Java números aleatorios duplicados? Veamos la prueba a continuación.
2. Prueba 2: Establezca el número de semillas para
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 ()); }}} No importa cuántas veces se ejecute el programa, el resultado es siempre:
-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
Incluso si lo prueba en diferentes máquinas, ¡los resultados de la prueba no cambiarán!
3. Análisis de causa:
(1) Primero, abra Java Doc, veremos la descripción de la clase aleatoria:
Los ejemplos de esta clase se utilizan para generar transmisiones de números pseudo-aleatorios, que usan una semilla de 48 bits que puede modificarse utilizando una fórmula congruente lineal (ver el arte de la programación de computadoras de Donald Knuth, Volumen 2, Sección 3.2.1).
Si se crean dos instancias aleatorias con la misma semilla, se realiza la misma secuencia de llamadas de método en cada instancia y generarán y devolverán la misma secuencia de números. Para garantizar que se implementa esta característica, especificamos un algoritmo específico para la clase aleatoria. Para la portabilidad completa del código Java, las implementaciones de Java deben tener la clase de uso aleatorio todos los algoritmos que se muestran aquí. Pero las subclases de clase aleatoria pueden usar otros algoritmos siempre que cumplan con los acuerdos convencionales de todos los métodos.
Java Doc ha explicado muy bien la clase aleatoria, y nuestras pruebas lo han verificado.
(2) Si no se proporciona un número de semilla, el número de semillas de la instancia aleatoria será los milisegundos de la hora actual. Puede obtener los milisegundos de la hora actual a través de System.CurrentTimemillis (). Abra el código fuente de JDK y podemos ver esto muy claramente.
public Random () {this (System.CurrentTimemillis ()); } 4. Conclusión:
A través de las pruebas y análisis anteriores, tendremos una comprensión más profunda de la clase aleatoria. Al mismo tiempo, creo que al leer la documentación de la API de Java Doc, nuestras capacidades de programación de Java pueden mejorarse enormemente y "saber la verdad" puede lograrse; Una vez que nos encontramos con problemas perplejos, también podríamos abrir el código fuente de Java para que podamos "conocer la verdad".
Generalmente hay dos tipos de números aleatorios en Java, uno es el método aleatorio () en matemáticas, y el otro es la clase aleatoria.
1. Math.Random ()
Se genera un número decimal de 0 <x <1.
Ejemplo: ¿Cómo escribir y generar aleatoriamente uno de los números de 0 a 100?
Math.random () devuelve solo un decimal de 0 a 1. Si desea 50 a 100, ampliará 50 veces primero, es decir, entre 0 y 50. Todavía es un decimal. Si desea un entero, lanzará INT y luego agregue 50 a 50 a 100.
Código final: (int) (math.random ()*50) + 50
2. Clase aleatoria
Random Random = new Random (); // Constructor predeterminado Random Random = New Random (1000); // Especificar el número de semillas
Al realizar la aleatorización, el número de origen del algoritmo aleatorio se llama semillas, que realiza una cierta transformación basada en las semillas, generando así los números aleatorios requeridos.
Objetos aleatorios con el mismo número de semillas, los números aleatorios generados por el mismo número de veces son exactamente los mismos. En otras palabras, para dos objetos aleatorios con el mismo número de semilla, los números aleatorios generados por primera vez son exactamente los mismos, y los números aleatorios generados por segunda vez son exactamente los mismos.
2. Métodos comunes en clase aleatoria
Los métodos en la clase aleatoria son relativamente simples, y las funciones de cada método también son fáciles de entender. Cabe señalar que los números aleatorios generados por cada método en la clase aleatoria se distribuyen uniformemente, lo que significa que la probabilidad de generación numérica dentro del intervalo es igual. Aquí hay una introducción básica a estos métodos:
A, público booleano nextboolean ()
La función de este método es generar un valor booleano aleatorio, y la probabilidad de generar valores verdaderos y falsos es igual, es decir, ambos son del 50%.
B, público doble nextDouble ()
El propósito de este método es generar un valor doble aleatorio, el valor es entre [0, 1.0). Aquí, los soportes representan los puntos finales que contienen el intervalo, y los soportes representan los puntos finales que no incluyen el intervalo, es decir, un decimal aleatorio entre 0 y 1, que contiene 0 pero no 1.0.
C, public int NextInt ()
El propósito de este método es generar un valor INT aleatorio, que se encuentra entre la potencia 31 de -2 y 31 de potencia de -1 ° de potencia de 2.
Si necesita generar un valor INT para un intervalo específico, debe realizar una cierta transformación matemática. Para más detalles, consulte el código en el ejemplo de uso a continuación.
D, Public int Nextint (int n)
La función de este método es generar un valor INT aleatorio, que está dentro del intervalo de [0, n), es decir, un valor INT aleatorio entre 0 y N, que contiene 0 pero no n.
Si desea generar un valor INT para un intervalo específico, también debe realizar una cierta transformación matemática. Para más detalles, consulte el código en el ejemplo de uso a continuación.
E, Public Void Setseed (semilla larga)
El propósito de este método es restablecer el número de semillas en el objeto aleatorio. Después de establecer el número de semillas, el objeto aleatorio es el mismo que el objeto aleatorio creado con la nueva palabra clave.
3. Ejemplo de uso de clase aleatoria
Usando la clase aleatoria, generalmente es generar números aleatorios para un intervalo especificado. Lo siguiente introducirá cómo generar números aleatorios para un intervalo correspondiente uno por uno. Los siguientes códigos que generan números aleatorios se generan utilizando el siguiente objeto aleatorio R:
Random r = new Random ();
a. Genere decimales del intervalo [0,1.0)
doble d1 = R.NextDouble ();
Se obtiene directamente utilizando el método NextDouble.
b. Generar decimales del intervalo [0,5.0)
doble d2 = R.NextDouble () * 5;
Debido a que el intervalo número generado por el método NextDouble es [0, 1.0), expandir el intervalo por 5 veces es el intervalo requerido.
Del mismo modo, generar un decimal aleatorio en el intervalo [0, d) y D es cualquier decimal positivo, solo necesita multiplicar el valor de retorno del método NextDouble por d.
do. Genere el número decimal [N1, N2] del intervalo [1, 2.5) [1]
doble d3 = R.NextDouble () * 1.5 + 1; 【Es decir, R.NextDouble () * (N2-N1) + N1】
Para generar un decimal aleatorio del intervalo [1, 2.5), solo necesita generar primero un número aleatorio del intervalo [0, 1.5) y luego agregar 1 al intervalo de número aleatorio generado.
Del mismo modo, para generar cualquier número aleatorio en el rango de intervalo decimal [D1, D2) que no comienza desde 0 (donde D1 no es igual a 0), solo necesita generar primero un número aleatorio en el intervalo [0, D2-D1) y luego agregar el intervalo de número aleatorio generado a D1.
d. Generar cualquier entero
int n1 = R.NextInt ();
Simplemente use el método NextInt directamente.
mi. Genere enteros en intervalo [0,10)
int n2 = R.NextInt (10); N2 = Math.abs (R.NextInt () % 10);
Las dos líneas de código anteriores pueden generar enteros en el intervalo [0,10).
La primera implementación se implementa directamente utilizando el método NextInt (int n) en la clase aleatoria.
En la segunda implementación, primero llame al método NextInt () para generar un número INT arbitrario. El intervalo generado por la suma número del número 10 es (-10,10), porque de acuerdo con la especificación matemática, el valor absoluto del resto es menor que el divisor, y luego se calcula el valor absoluto del intervalo, y el intervalo resultante es [0,10).
Del mismo modo, para generar enteros aleatorios en cualquier intervalo [0, n) puede usar el siguiente código:
int n2 = r.nextInt (n); n2 = math.abs (r.nextint () % n);
F. Genere enteros en intervalo [0,10]
int n3 = R.NextInt (11); n3 = Math.abs (R.NextInt () % 11);
En comparación con el intervalo entero, el intervalo [0,10] y el intervalo [0,11) son equivalentes, por lo que se genera un entero del intervalo [0,11).
gramo. Genere enteros en el intervalo [-3,15)
int n4 = R.NextInt (18) - 3; // 【Es decir, R.NextInt () * (N2 -N1)+N1】 N1 es un número negativo N4 = Math.abs (R.NextInt () % 18) - 3;
Para generar enteros aleatorios que no comienzan desde 0, puede consultar la descripción anterior del principio de implementación del intervalo decimal que no comienza desde 0.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.