是否有返回所选类型值的随机化函数

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();
}