Java–RandomLong,Float,IntegerandDouble
1
2
3
4
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() {
long
generatedLong =
new
Random().nextLong();
}
2. Generate a Long Within a Range
2.1. Random Long With Plain Java
Next – let"s look at creating a random bounded Long – that is, a Long value within a given range or interval:
1
2
3
4
5
6
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() {
long
leftLimit = 1L;
long
rightLimit = 10L;
long
generatedLong = leftLimit + (
long
) (Math.random() * (rightLimit - leftLimit));
}
2.2. Random Long with Apache Commons Math
Let"s take a look at generating the random Long with a cleaner API and Commons Math:
1
2
3
4
5
6
@Test
public
void
givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() {
long
leftLimit = 10L;
long
rightLimit = 100L;
long
generatedLong =
new
RandomDataGenerator().nextLong(leftLimit, rightLimit);
}
3. Generate an Unbounded Integer
Let"s move right on to generating a random Integer with no bounds:
1
2
3
4
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() {
int
generatedInteger =
new
Random().nextInt();
}
As you can see, it"s pretty close to generating a long.
4. Generate an Integer Within a Range
4.1. Random Integer With Plain Java
Next – a random integer within a given range:
1
2
3
4
5
6
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() {
int
leftLimit =
1
;
int
rightLimit =
10
;
int
generatedInteger = leftLimit + (
int
) (
new
Random().nextFloat() * (rightLimit - leftLimit));
}
4.2. Random Integer with Commons Math
And the same with Common Math:
1
2
3
4
5
6
@Test
public
void
givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() {
int
leftLimit =
1
;
int
rightLimit =
10
;
int
generatedInteger =
new
RandomDataGenerator().nextInt(leftLimit, rightLimit);
}
5. Generate an Unbounded Float
Now, let"s go over generating random floats – first unbounded:
1
2
3
4
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() {
float
generatedFloat =
new
Random().nextFloat();
}
6. Generate a Float Within a Range
6.1. Random Float With Plain Java
And a bounded random float:
1
2
3
4
5
6
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() {
float
leftLimit = 1F;
float
rightLimit = 10F;
float
generatedFloat = leftLimit +
new
Random().nextFloat() * (rightLimit - leftLimit);
}
6.2. Random Float with Commons Math
Now – a bounded random float with Commons Math:
1
2
3
4
5
6
7
@Test
public
void
givenUsingApache_whenGeneratingRandomFloatBounded_thenCorrect() {
float
leftLimit = 1F;
float
rightLimit = 10F;
float
randomFloat =
new
RandomDataGenerator().getRandomGenerator().nextFloat();
float
generatedFloat = leftLimit + randomFloat * (rightLimit - leftLimit);
}
7. Generate an Unbounded Double
7.1. Random Unbounded Double With Plain Java
Finally – we"re going to generate random double values – first, with the Java Math API:
1
2
3
4
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
double
generatedDouble = Math.random();
}
7.2. Random Unbounded Double with Commons Math
As well as a random double value with the Apache Commons Math library:
1
2
3
4
@Test
public
void
givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() {
double
generatedDouble =
new
RandomDataGenerator().getRandomGenerator().nextDouble();
}
8. Generate a Double Within a Range
8.1. Random Bounded Double With Plain Java
In this example, let"s take a look at a random double generated within an interval – with Java:
1
2
3
4
5
6
@Test
public
void
givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() {
double
leftLimit = 1D;
double
rightLimit = 10D;
double
generatedDouble = leftLimit +
new
Random().nextDouble() * (rightLimit - leftLimit);
}
8.2. Random Bounded Double with Commons Math
And lastly – a random double within an interval, using the Apache Commons Math library:
1
2
3
4
5
6
@Test
public
void
givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() {
double
leftLimit = 1D;
double
rightLimit = 100D;
double
generatedDouble =
new
RandomDataGenerator().nextUniform(leftLimit, rightLimit);
}
And there you have it – quick and to the point examples of how to generate both unbounded and bounded values for the most common numerical primitives in Java.
9. Conclusion
This tutorial illustrated how we could generate random numbers either bound or unbound, using different techniques and libraries.
As always, the implementation of all of these examples and snippets can be found in the GitHub project. This is a Maven-based project so it should be easy to import and run.
以上是 Java–RandomLong,Float,IntegerandDouble 的全部内容， 来源链接： utcz.com/z/513070.html
