NextDouble: примеры (JAVA)

Короткие примеры использования

Примеры демонстрируют разные реализации и варианты аргументов. Код и вывод приведены для иллюстрации.

1) Базовый Random.nextDouble()

import java.util.Random;

public class Example1 {
    public static void main(String[] args) {
        Random r = new Random(42);
        System.out.println(r.nextDouble());
    }
}

0.7275632551170568

2) ThreadLocalRandom с верхней границей

import java.util.concurrent.ThreadLocalRandom;

public class Example2 {
    public static void main(String[] args) {
        double value = ThreadLocalRandom.current().nextDouble(5.0);
        System.out.println(value);
    }
}

2.341274328741234  // примерный вывод в диапазоне [0.0, 5.0)

3) Диапазон origin.. bound

import java.util.concurrent.ThreadLocalRandom;

public class Example3 {
    public static void main(String[] args) {
        double v = ThreadLocalRandom.current().nextDouble(1.5, 2.5);
        System.out.println(v);
    }
}

1.83492712098321  // примерный вывод в [1.5, 2.5)

4) Потоковый API: получение потока случайных double

import java.util.Random;

public class Example4 {
    public static void main(String[] args) {
        new Random(1).doubles(3).forEach(System.out::println);
    }
}

0.730878190703=}  // примерный вывод, каждая строка - число в [0.0,1.0)

Аналоги внутри Java и их особенности

• Math.random() - удобный статический вызов, возвращает double в [0.0, 1.0). Под капотом использует глобальный генератор; поведение простое, но менее гибкое, чем явные генераторы.
• ThreadLocalRandom - оптимизирован для многопоточных сред, снижает конкуренцию при частых вызовах. Содержит перегрузки с bound и origin/bound.
• SplittableRandom - эффективен для параллельных стримов и ситуаций, где требуется воспроизводимость при разделении генератора. Быстрее и проще для параллелизма, чем общий Random.
• SecureRandom - для криптографии. Медленнее, но предоставляет непредсказуемую для атак случайность.
• Stream API (Random.doubles) - удобен для генерации последовательностей и работы со стримами, позволяет сразу получить нужное количество значений и диапазон.

Выбор зависит от требований: для многопоточности предпочтителен ThreadLocalRandom или SplittableRandom; для криптографии - SecureRandom; для простых случаев или быстрых тестов - Math.random() или Random.

Аналоги в других языках и краткие отличия

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

JavaScript - Math.random()

// JS
console.log(Math.random());

0.481273948172  // пример в [0,1)

Python - random.random и random.uniform

# Python
import random
print(random.random())
print(random.uniform(1.5, 2.5))

0.3745401188473625
1.934827123

PHP - масштабирование целого генератора

// PHP
$val = mt_rand() / mt_getrandmax();
echo $val;

0.652341237  // пример в [0,1)

SQL (пример T-SQL) - RAND()

-- T-SQL
SELECT RAND() AS r;

0.217364912

C# - Random.NextDouble()

// C#
var rnd = new System.Random(42);
Console.WriteLine(rnd.NextDouble());

0.7275632551170568

Lua - math.random (поведение зависит от аргументов)

-- Lua
-- преобразование целого в дробный
local v = math.random()
print(v)

0.834127  -- поведение может отличаться в реализации

Go - rand.Float64()

// Go
package main
import (
    "fmt"
    "math/rand"
)
func main() {
    fmt.Println(rand.Float64())
}

0.684210143  // пример в [0,1)

Kotlin - kotlin.random.Random.nextDouble

// Kotlin
import kotlin.random.Random
fun main() {
    println(Random(42).nextDouble())
    println(Random.nextDouble(1.0, 2.0))
}

0.7275632551170568
1.423912341

Отличия: в большинстве языков есть базовый генератор [0,1), но синтаксис, гарантия потокобезопасности и криптографическая надежность различаются. Некоторые языки предоставляют встроенные перегрузки для диапазона, другие требуют масштабирования вручную.

Типичные ошибки и примеры

• Ожидание включения правой границы. Многие начинающие предполагают, что bound включается; в Java значение обычно меньше bound. Последствия: редкие граничные значения никогда не появятся.
• Неправильное использование границ: origin >= bound вызывает исключение в методах с двумя аргументами.
• Создание большого количества объектов Random в короткое время приводит к одинаковым последовательностям при одинаковом сидировании по времени - потеря энтропии.
• Использование Random в многопоточном окружении может стать узким местом. ThreadLocalRandom или SplittableRandom лучше подходят для конкурирующих потоков.
• Использование Random для криптографических целей - уязвимо. Для секретных данных нужен SecureRandom.

Пример, вызывающий IllegalArgumentException:

import java.util.concurrent.ThreadLocalRandom;

public class BadExample {
    public static void main(String[] args) {
        // origin >= bound
        double v = ThreadLocalRandom.current().nextDouble(2.0, 2.0);
        System.out.println(v);
    }
}

Exception in thread "main" java.lang.IllegalArgumentException: bound must be greater than origin
    at ...

Пример побочного эффекта при частом создании Random:

import java.util.Random;

public class ManyRandoms {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Random r = new Random();
            System.out.println(r.nextDouble());
        }
    }
}

0.7275632551170568
0.7275632551170568
0.7275632551170568  // возможен одинаковый вывод в тесно инициализируемых экземплярах

Изменения в API и эволюция метода

В ранних версиях Java существовал только Random.nextDouble() без перегрузок. В последующих обновлениях экосистемы появились более богаты методы в родственных API: ThreadLocalRandom и новые интерфейсы генераторов (RandomGenerator) предоставляют версии с указанием границ, а также улучшенную поддержку потоков и стримов. Stream API дополнило удобные способы получения последовательностей (Random.doubles() и т.п.).

Ключевые точки эволюции: появление ThreadLocalRandom (для многопоточности), добавление методов диапазонов в новых генераторах и расширение Stream API для чисел типа double. Для криптографии отдельным направлением остался SecureRandom, который не стремится к высокой скорости, но улучшает стойкость.

Расширенные и нетривиальные примеры

Подробные кейсы, демонстрирующие разные задачи и приёмы.

1) Генерация double в произвольном диапазоне с контролем включений

import java.util.Random;

public class RangeUtil {
    public static double randomInRange(Random r, double min, double max) {
        return min + r.nextDouble() * (max - min);
    }

    public static void main(String[] args) {
        Random r = new Random(123);
        System.out.println(randomInRange(r, -2.0, 3.0));
    }
}

0.178423412  // примерный вывод в [-2.0,3.0)

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

2) Округление случайного double до двух знаков

import java.util.Random;

public class RoundExample {
    public static void main(String[] args) {
        Random r = new Random(7);
        double v = Math.round(r.nextDouble() * 100.0) / 100.0;
        System.out.println(v);
    }
}

0.64

3) Box-Muller: генерация нормального распределения из uniform nextDouble()

import java.util.Random;

public class BoxMuller {
    public static double nextGaussianFromUniform(Random r) {
        double u1 = r.nextDouble();
        double u2 = r.nextDouble();
        double z0 = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2*MATH.PI * u2);
        return z0; // стандартное нормальное
    }

    public static void main(String[] args) {
        Random r = new Random(42);
        System.out.println(nextGaussianFromUniform(r));
    }
}

-0.123412341  // пример стандартного нормального значения

Пояснение: метод nextDouble() применяется как источник равномерных чисел для преобразования в нормальное распределение.

4) Параллельное генерирование с SplittableRandom для производительности

import java.util.SplittableRandom;
import java.util.stream.DoubleStream;

public class ParallelSplittable {
    public static void main(String[] args) {
        SplittableRandom sr = new SplittableRandom(1);
        DoubleStream ds = sr.doubles(5, 0.0, 10.0); // 5 значений в [0,10)
        ds.forEach(System.out::println);
    }
}

6.341234
1.234123
9.123412
0.234123
4.912341  // примерный вывод

5) Криптографически стойкие double с SecureRandom

import java.security.SecureRandom;

public class SecureDouble {
    public static void main(String[] args) {
        SecureRandom sr = new SecureRandom();
        // SecureRandom наследует методы Random
        double v = sr.nextDouble();
        System.out.println(v);
    }
}

0.129384712  // примерный криптографический вывод

6) Генерация большого потока значений и фильтрация

import java.util.Random;
import java.util.stream.DoubleStream;

public class StreamFilter {
    public static void main(String[] args) {
        new Random(1).doubles()
            .filter(d -> d > 0.5)
            .limit(5)
            .forEach(System.out::println);
    }
}

0.730878190703...   // пять чисел каждый больше 0.5

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