Question

Is there a way to use a randomize function with relation to a give data type, i.e.
if I request the type is double then I will get double values, and if the requested type is float I will get float values?

Is there such a randomize function?

Answer 1

java 1.7:
Either you call ThreadLocalRandom.current().next<DataType>() by yourself, or you write a wrapper around this call:

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

---

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