java - 是否有一个随机函数可以返回所选类型的值？

Question

有没有办法使用与给定数据类型相关的随机函数，即如果我请求类型是double那么我将获得double值，如果请求的类型是float我将获得float值？

有这样的随机化功能吗？

Answer 1

java 1.7：
要么自己调用ThreadLocalRandom.current().next<DataType>()，要么围绕这个调用编写一个包装器：

import java.util.concurrent.ThreadLocalRandom;

//...

public static int nextRandom(int maxValueExclusive)
{
    return ThreadLocalRandom.current().nextInt(maxValueExclusive);
}

public static long nextRandom(long maxValueExclusive)
{
    return ThreadLocalRandom.current().nextLong(maxValueExclusive);
}

public static double nextRandom(double maxValueExclusive)
{
    return ThreadLocalRandom.current().nextDouble(maxValueExclusive);
}

public static float nextRandom(float maxValueExclusive)
{
    if (maxValueExclusive <= 0)
        throw new IllegalArgumentException("argument must be positive: " + maxValueExclusive);
    return ThreadLocalRandom.current().nextFloat()*maxValueExclusive;
}

public static boolean nextRandom(boolean unusedValue)
{
    return ThreadLocalRandom.current().nextBoolean();
}

---

爪哇 1.6：

import java.util.Random;

//...

private static final Random random = new Random(); // be careful with multiple threads

public static int nextRandom(int maxValueExclusive)
{
    return random.nextInt(maxValueExclusive);
}

public static long nextRandom(long maxValueExclusive)
{
    //implementation from java 1.7 ThreadLocalRandom
    if (maxValueExclusive <= 0)
        throw new IllegalArgumentException("argument must be positive: " + maxValueExclusive);
    // Divide n by two until small enough for nextInt. On each
    // iteration (at most 31 of them but usually much less),
    // randomly choose both whether to include high bit in result
    // (offset) and whether to continue with the lower vs upper
    // half (which makes a difference only if odd).
    long offset = 0;
    while (maxValueExclusive >= Integer.MAX_VALUE) {
        long half = maxValueExclusive >>> 1;
        long nextn = random.nextBoolean() ? half : maxValueExclusive - half;
        if (random.nextBoolean())
            offset += maxValueExclusive - nextn;
        maxValueExclusive = nextn;
    }
    return offset + random.nextInt((int) maxValueExclusive);
}

public static double nextRandom(double maxValueExclusive)
{
    if (maxValueExclusive <= 0)
        throw new IllegalArgumentException("argument must be positive: " + maxValueExclusive);
    return random.nextDouble()*maxValueExclusive;
}

public static float nextRandom(float maxValueExclusive)
{
    if (maxValueExclusive <= 0)
        throw new IllegalArgumentException("argument must be positive: " + maxValueExclusive);
    return random.nextFloat()*maxValueExclusive;
}

public static boolean nextRandom(boolean unusedValue)
{
    return random.nextBoolean();
}