Как производить случайные числа внутри ранга стоимости?

numero = (int) (Math.random() * n) + 1;

, Где n состоит даже nГєmero в том, что ты хочешь, чтобы он прибыл, + 1 для того, чтобы никогда ты не имел одного 0 и cast по отношению к int, потому что Math#random бросает стоимость типа double.

Ты можешь использовать класс ThreadLocalRandom что делает exáctamente то, в чем ты нуждаешься.

import java.util.concurrent.ThreadLocalRandom;

int numero = ThreadLocalRandom.current().nextInt(min, max + 1);

Хороший способ производить интервалы был бы следующей:

Random aleatorio = new Random();
System.out.println(8+aleatorio.nextInt( (10+1) - 8));

Таким образом числа произведутся 10 в ранге 8.

Здесь тебя оставил руководитель, очень полный и легкий для того, чтобы быть понятен на Math.random и random.nextInt:

http://javarevisited.blogspot.com.es/2013/05/how-to-generate-random-numbers-in-java-between-range.html

для твоего случая особенно, код был бы:

for(int i =0; i<3; i++){
    int randomInteger = random.nextInt(10) + 1;
    System.out.println("pseudo random int in a range : " + randomInteger);
}

Output:
pseudo random int in a range : 7
pseudo random int in a range : 1
pseudo random int in a range : 3

public static void main(String[] args){
    //hay que importar la librerai Random
    //java.util.Random

    //generador de numeros aleatorios
    Random generadorAleatorios = new Random();

    //genera un numero entre 1 y 5 y lo guarda en la variable numeroAleatorio
    int numeroAleatorio = 1+generadorAleatorios.nextInt(5);
    //imprimo el numero en consola
    System.out.println(numeroAleatorio);

}

Это пример, где мы определяем стоимость между рангом стоимости min и max:

int numeroRandom = ThreadLocalRandom.current().nextInt(min, max);

мы можем реализовывать то же самое посредством метода:

private int getNumeroRandom(int min, int max){
       return ThreadLocalRandom.current().nextInt(min, max);
   }

пример как называть метод, чтобы получать случайное число в ранге от 1 до 10:

int min = 1, max = 10;
System.out.println(getNumeroRandom(min, max));

Восток - пример 100 повторений, полученных с предложенным методом, определяя как интервал 1 в 10:

8, 9, 2, 1, 2, 4, 9, 4, 1, 4, 7, 2, 8, 9, 1, 3, 4, 2, 5, 6, 5, 5, 6, 6, 1, 3, 3, 1, 5, 2, 4, 4, 3, 1, 1, 2, 8, 6, 4, 6, 4, 6, 8, 5, 7, 5, 8, 5, 1, 6, 7, 2, 2, 6, 7, 1, 7, 4, 8, 1, 3, 5, 1, 2, 4, 6, 4, 8, 5, 4, 9, 4, 7, 5, 4, 8, 3, 7, 8, 4, 4, 1, 7, 4, 8, 3, 3, 2, 3, 3, 2, 8, 9, 4, 9, 9, 9, 4, 5, 9, 6

В Java существуют два главных класса, чтобы производить случайные числа:

• java.util.Random
• java.security.SecureRandom

Функция Math.random() используй java.util.Random на всякий случай.

Тем временем, он не является очень важным, если произведенные данные действительно случайные, Math.random() или Random сделайте работу, но есть проблема:

Если я произвожу случайные данные с той же последовательностью кода и с тем же зерном, всегда будут производиться те же данные, которые кажутся случайными, но в действительности будут подходящими для воспроизведения. По тому же разуму, типично используется печать времени (как System.currentTimeMillis()) чтобы производить новые данные.

На практике используется код:

Random aleatorio = new Random(System.currentTimeMillis());
// Producir nuevo int aleatorio entre 0 y 99
int intAletorio = aleatorio.nextInt(100);
// Más código

// Refrescar datos aleatorios 
aleatorio.setSeed(System.currentTimeMillis());
// ... o mejor
aleatorio.setSeed(aleatorio.getLong());

Что я делаю в случае, что я хочу убедиться, что я произвожу действительно случайные данные?

Если я нуждаюсь в большей безопасности, что мои случайные данные не были подходящими для воспроизведения, например в шифровании или других площадях безопасности, он был бы должен использовать другой способ производить случайные данные.

Шифрование снабжает для этих использований PRNG (pseudorandom number generator), генераторы псевдослучайных чисел. Почему pseudo? Ну, в действительности договорная вычислительная система неспособна легко делать что-то случайным, это слишком много determinístico для этого. Но существуют алгоритмы, которые поставляют приближение достаточно случайный, чтобы выполнять все задания, в которых он они нуждается.

Класс SecureRandom работай с алгоритмами SHA1PRNG Sun, которые выполняют с требованиями RFC 1750 (на английском) на поколении случайных данных криптообразно громко (не determinístico).

В поколении идентификаторов сеансов, например, он высоко рекомендуемый предпочитания SecureRandom на Random.

Как он используется?

Во-первых я должен решать, предпочитаю ли я оставлять выбор лучшего алгоритма в платформу, или если я нуждаюсь в том, чтобы определить это, чтобы гарантировать тот же алгоритм во всем устройстве.

// Generar un nuevo generador con el algoritmo por defecto
SecureRandom sr = new SecureRandom();

или

SecureRandom sr = null;
try {
    sr = SecureRandom.getInstance("SHA1PRNG", "SUN");
    // para garantizar el caracter aleatorio generemos una nueva semilla
} catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
} catch (NoSuchProviderException e) {
    e.printStackTrace();
} 

Потом нужно инициализировать генератор, который делается прося случайные байт.

// La lista byte[] es suficiente, la llamada se hace únicamente para causar la generación de una nueva semilla 
sr.nextBytes(new byte[1]);

Генератор готов, чтобы использовать, и я могу производить случайные числа в разнообразии форм. Какие-то есть оба класса общим:

// Un valor long
sr.nextLong();
// Un valor int
sr.nextInt();
// Un valor float
sr.nextFloat();
// Un valor double
sr.nextDouble();
// Un valor gaussian (entre -1 y 1))
sr.nextGaussian();
// Un valor boolean, como lanzar una moneda
sr.nextBoolean();
// ... y un valor int entre 0 (inclusivo) y int n (exclusivo)
sr.nextInt(n);
// Así para tener un valor entero aleatorio de 1 al 10, se usa
sr.nextInt(10)+1;

Кроме того, SecureRandom предложи больше методов:

// Un valor int de int x bits, ajustado a la derecha
sr.next(x);
// Para obtener una cantidad de bytes aleatorios, se `puede usar lo siguiente
byte[] b = new byte[128]
sr.getBytes(b);

Чтобы улучшать случайный символ нужно сеять генератор каждый раз между тем:

byte[] b = new byte[20];
sr.setSeed(b)
// Alternativamente se puede usar un long para resembrar
sr.setSeed(System.currentTimeMillis());

Не повторно сеять никогда загружает зависимость от случая генератора, потому что новое зерно дополняет зерно, которое было использовано изначально.