Random类和Math.random()方法

一、Random类的定义
Random类位于 java.util 包中，主要用于生成伪随机数
Random类将种子数作为随机算法的起源数字，计算生成伪随机数，其与生成的随机数字的区间无关
创建Random实例时，若没有指定种子数，则会以当前时间作为种子数，来计算生成伪随机数
拥有相同种子的Random实例，在相同次数下，生成的伪随机数完全相同

Random random1 = new Random(10);
Random random2 = new Random(10);
System.out.println(random1.nextInt()); // -1157793070
System.out.println(random2.nextInt()); // -1157793070

Random r = new Random(); r.nextInt(101); random的nextInt(int n)方法可以生成一个介于0(包含)到n(不包含)之间的整数 nextInt(101)生成的就是0~100之间的随机数，包含0和100

使用Random类产生5个1~30的随机整数

import java.util.Arrays;
import java.util.Random;
//使用Random类产生5个1~30的随机整数
public class Test2 {
    public static void main(String[] args){
        Random r=new Random();
        int[] arr=new int[5];
        //赋值
        for(int i=0;i<arr.length;i++){
            //1~30
            arr[i]=r.nextInt(30)+1;
        }
        System.out.println(Arrays.toString(arr));
    }
}

.使用随机数0和1来模拟抛硬币实验，统计抛出1000次后正反面出现的次数并输出，正面为1，反面为0

import java.util.Random;
//使用随机数0和1来模拟抛硬币实验，统计抛出1000次后正反面出现的次数并输出
//正面为1，反面为0
public class Test4 {
    public static void main(String[] args){
        Random r=new Random();
        int countPostive=0;
        int countNegtive=0;
        for(int i=0;i<1000;i++){
            //产0或1
            int a=r.nextInt(2);
            if(a==0){
                countNegtive++;
            }
            if(a==1){
                countPostive++;
            }
        }
        System.out.println("1出现的次数："+countPostive+",0出现的次数："+countNegtive);
    }
}

二、Random类的常用方法

1、random.nextBoolean()

用于从该随机数生成器的序列中得到下一个伪均匀分布的boolean值
Random random = new Random();
System.out.println(random.nextBoolean());
2、random.nextBytes()

用于生成随机字节并将其放入用户提供的byte数组中
Random random = new Random();
byte[] data = new byte[30];
random.nextBytes(data);
System.out.println(Arrays.toString(data));

3、random.nextDouble()

用于从该随机数生成器的序列中得到下一个伪均匀分布在0.0到1.0之间的double值，[0.0, 1.0)
Random random = new Random();
System.out.println(random.nextDouble());

4、random.nextFloat()

用于从该随机数生成器的序列中得到下一个伪均匀分布在0.0到1.0之间的float值，[0.0, 1.0)
Random random = new Random();
System.out.println(random.nextFloat());

5、random.nextInt()

random.nextInt()
用于从该随机数生成器的序列中得到下一个伪均匀分布的int值
Random random = new Random();
System.out.println(random.nextInt());

random.nextInt(int bound)
用于从该随机数生成器的序列中得到下一个0到结束值之间伪均匀分布的int值，[0, 结束值)
Random random = new Random();
System.out.println(random.nextInt(10));

6、random.nextGaussian()

用于从该随机数生成器的序列中得到下一个伪均匀分布的double值
生成的double值符合均值为0，方差为1的正态分布(高斯分布)
Random random = new Random();
System.out.println(random.nextGaussian());

7、random.setSeed(long seed)

设置随机种子
Random random = new Random();
random.setSeed(10);

8、random.ints()

random.ints()
用于得到一个有效无限的伪随机int值流
IntStream ints = random.ints();
ints.forEach(System.out::println);

random.ints(long streamSize)
用于得到一个有限长度的伪随机int值流
IntStream ints = random.ints(10);
ints.forEach(System.out::println);

random.ints(int randomNumberOrigin, int randomNumberBound)
用于得到一个有效无限的范围在起始值到结束值之间的伪随机int值流，[起始值, 结束值)
IntStream ints = random.ints(1, 10);
ints.forEach(System.out::println);

random.ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
用于得到一个有限长度的范围在起始值到结束值之间的伪随机int值流，[起始值, 结束值)
IntStream ints = random.ints(10, 1, 10);
ints.forEach(System.out::println);

9、random.longs()

random.longs()
用于得到一个有效无限的伪随机long值流
LongStream longs = random.longs();
longs.forEach(System.out::println);

random.longs(long streamSize)
用于得到一个有限长度的伪随机long值流
LongStream longs = random.longs(10);
longs.forEach(System.out::println);

random.longs(int randomNumberOrigin, int randomNumberBound)
用于得到一个有效无限的范围在起始值到结束值之间的伪随机long值流，[起始值, 结束值)
LongStream longs = random.longs(1, 10);
longs.forEach(System.out::println);

random.longs(long streamSize, int randomNumberOrigin, int randomNumberBound)
用于得到一个有限长度的范围在起始值到结束值之间的伪随机long值流，[起始值, 结束值)
LongStream longs = random.longs(10, 1, 10);
longs.forEach(System.out::println);

10、random.doubles()

random.doubles()
用于得到一个有效无限的伪随机double值流
DoubleStream doubles = random.doubles();
doubles.forEach(System.out::println);

random.doubles(long streamSize)
用于得到一个有限长度的伪随机double值流
DoubleStream doubles = random.doubles(10);
doubles.forEach(System.out::println);

random.doubles(int randomNumberOrigin, int randomNumberBound)
用于得到一个有效无限的范围在起始值到结束值之间的伪随机doubles值流，[起始值, 结束值)
DoubleStream doubles = random.doubles(1, 10);
doubles.forEach(System.out::println);

random.doubles(long streamSize, int randomNumberOrigin, int randomNumberBound)
用于得到一个有限长度的范围在起始值到结束值之间的伪随机doubles值流，[起始值, 结束值)
DoubleStream doubles = random.doubles(10, 1, 10);
doubles.forEach(System.out::println);

简单来说

Random类

import java.util.Random;

public class randomTest {
    public static void main(String args[])
    {
        Random random=new Random();//以系统当前时间作为随机数生成的种子
        System.out.println(random.nextInt(10));//返回一个大于0且小于10的整数
        System.out.println(random.nextFloat()); //返回一个随机浮点型
        System.out.println(random.nextBoolean());  //返回一个随机布尔型值
        System.out.println(random.nextDouble());  //返回一个随机双精度型
        System.out.println(random.nextLong());  //返回一个随机长整形

    }
}

运行结果

Math.random()方法是指让系统随机选取大于等于 0.0 且小于 100.0 的伪随机数。

1、函数：Math.random()；

2、功能：产生大于等于 0 小于 1 的一个随机数；

3、公式：Math.random()*(n-m)+m，生成大于等于m小于n的随机数；

例：设置一个随机1到3(取不到3)的变量

int num = (int)(Math.random()*2+1)；

Math.random()默认产生大于等于0.0且小于1.0之间的随机double型随机数

即：0.0<=Math.random()<1.0

但是稍加处理就可以产生任意随机数

public class MathRandom {

public static int getRandomInt(int num1,int num2)
{
int n=num1+(int)(Math.random()*(num2-num1));
return n;
}

public static char getRandomChar(char ch1,char ch2)
{
char ch=(char) (ch1+ Math.random()*(ch2-ch1+1));
return ch;
}

public static void main(String args[])
{
System.out.println(MathRandom.getRandomInt(1,7)); //产生的随机数包括1，不包括7
System.out.println(MathRandom.getRandomChar('a','b'));//a和b都包括
}
}
运行结果：