生成指定范围内的随机数这个是最常用的技术之一，程序员希望通过随机数的方式来处理众多的业务逻辑，测试过程中也希望通过随机数的方式生成包含大量数字的测试用例。
问题往往类似于：
如何随机生成 1~100 之间的随机数，取值包含边界值 1 和 100。
或者是：
如何随机生成随机的3位整数？
等等……
以 Java 语言为例，我们观察其 Random 对象的 nextInt(int) 方法，发现这个方法将生成 0 ~ 参数之间随机取值的整数。例如(假设先有 Random rand = newRandom();，下同)：
rand.nextInt(100);
这行代码将生成范围0~100 之间的随机数，有趣的是，取值可能为 0 ，但不可能为 100。我们用中学数学课学习的区间表示法，表示为：[0, 100)。
那么如果要获得区间 [1~100]的随机数，该怎么办呢？稍微动动脑筋就可以想到：区间 [0, 100) 内的整数，实际上就是区间 [0, 99]。因为最大边界为100，可惜不能等于100，因此最大可能产生的“整数”就是99。
既然rand.nextInt(100) 获得的值是区间 [0, 99]，那么在这个区间左右各加 1，就得到了区间 [1, 100]。因此，代码写成：
rand.nextInt(100)+ 1;
即可。运行下面的代码，将获得 [1, 100] 的 10 个取值。
import java.util.Random;
public class Test {
public static void main(String[] args){
Random rand = new Random();
for(int i=0; i<10; i++) {
System.out.println(rand.nextInt(100) + 1);
}
}
}
同理，很容易知道如果要获得随机两位整数，代码写成：rand.nextInt(90) + 10;
你一定很惊讶，为什么是这么写出来的。其实，在 nextInt() 方法中作为参数的数字 90 表示：你希望生成的随机数的所有取值的可能性的数量(在本命题中，两位整数取值为 [10, 99]，共90个数)；加好后面的数字 10 ，表示区间的最小取值。
你可以验证下，按照这样理解，[1, 100] 的随机数，是不是应该写成rand.nextInt(100) + 1 。千万不要把参数 100 理解为最大取值。只是区间 [1, 100] 正好从 1 开始，所以最大取值和取值可能性数量正好同为 100。
因此，
生成随机三位数的代码为：
rand.nextInt(900)+ 100;
生成区间 [64,128] 中随机值的代码为：
rand.nextInt(65)+ 64;
取值可能性的数量是如何计算出来的呢？当然是 最大取值-最小取值+1 ，所以，有最终公式如下：
// For Java
int randNumber =rand.nextInt(MAX - MIN + 1) + MIN; // randNumber 将被赋值为一个 MIN 和 MAX 范围内的随机数
下面脚本之家小编分享一个网上常用的函数
函数一、要生成在[min,max]之间的随机整数
import java.util.Random;
public class RandomTest {
public static void main(String[] args) {
int max=20;
int min=10;
Random random = new Random();
int s = random.nextInt(max)%(max-min+1) + min;
System.out.println(s);
}
}
random.nextInt(max)表示生成[0,max]之间的随机数，然后对(max-min+1)取模。
以生成[10,20]随机数为例，首先生成0-20的随机数，然后对(20-10+1)取模得到[0-10]之间的随机数，然后加上min=10，最后生成的是10-20的随机数
函数二、
import java.util.*;
import java.io.*;
public class Random_Different {
public static void main(String[] args) throws IOException{
System.out.print("输入产生的随机数范围，1到N，N=");
int n=0;
try{
n=Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());
}catch(Exception e){
System.out.println("N必须为正整数");
return;
}
if(n<1){
System.out.println("N必须为正数");
return;
}
int randArr[]=new int[n];
int i=0;
while(i
int rand=(new Random().nextInt(n)+1);
boolean isRandExist=false;
for(int j=0;j
if(randArr[j]==rand){
isRandExist=true;
break;
}
}
if(isRandExist==false){
randArr[i]=rand;
i++;
}
}
System.out.println(Arrays.toString(randArr));
}
}
首先在1~n产生一个随机数X，然后对这个之前产生的数据进行遍历，判断是否存在有数等于这个新产生的随机数的，如果有，立flag，
然后对之前的数据遍历完毕之后，判断flag是否立起来，
如果是，就不添加这个随机数进数组，重新产生随机数并收起flag，再重新遍历已有的数据中是否已有这个随机数，
如果否，就添加，直到n个数据产生完毕。
最后输出这个n个数据。
具体的运行效果如下：
为了说明这个程序是健壮的，让电脑输入N，其中这个N从1-20，可以观察到，输出的数组中没有一个数是相同的，完成任务！
更多的数也是没有问题的，你设置N=二十万，都没有问题，这里由于本猿猴的机器太渣，设置个N=33说明效果。

java中产生随机数字的方法
发布时间：2020-06-23 13:02:33
来源：亿速云
阅读：70
作者：元一
这篇文章将为大家详细讲解有关java中产生随机数字的方法，文章内容质量较高，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。
随机数的产生在一些代码中很常用，也是我们必须要掌握的。而java中产生随机数的方法主要有三种：
第一种：new Random()
第二种：Math.random()
第三种：currentTimeMillis()
第一种需要借助java.util.Random类来产生一个随机数发生器，也是最常用的一种，构造函数有两个，Random()和Random(long seed)。第一个就是以当前时间为默认种子，第二个是以指定的种子值进行。产生之后，借助不同的语句产生不同类型的数。其中Math.random()方法是一个可以产生[0.0,1.0]区间内的一个双精度浮点数的方法
种子就是产生随机数的第一次使用值,机制是通过一个函数,将这个种子的值转化为随机数空间中的某一个点上,并且产生的随机数均匀的散布在空间中。以后产生的随机数都与前一个随机数有关。以代码为例。
第三种currentTimeMills() 不是int类型，需要强制转换为int，然后余10得到一位数的随机数，
余100得到两位数的随机数。public static void main(String[] args)
{
Random r = new Random(1);
for(int i=0 ; i<5 ;  i++)
{
int ran1 = r.nextInt(100);
System.out.println(ran1);
}
}
在我的编译器下产生的五个数均为85,88,47,13,54，如果采用Random r = new Random()，产生的随机数就不同，这就是确定种子导致的结果。
而第二种方法返回的数值是[0.0,1.0)的double型数值，由于double类数的精度很高，可以在一定程度下看做随机数，借助(int)来进行类型转换就可以得到整数随机数了，代码如下。public static void main(String[] args)     {
int max=100,min=1;
int ran2 = (int) (Math.random()*(max-min)+min);
System.out.println(ran2);
}
至于第三种方法虽然不常用，但是也是一种思路。方法返回从1970年1月1日0时0分0秒(这与UNIX系统有关)到现在的一个long型的毫秒数，取模之后即可得到所需范围内的随机数。public static void main(String[] args)
{
int max=100,min=1;
long randomNum = System.currentTimeMillis();
int ran3 = (int) (randomNum%(max-min)+min);
System.out.println(ran3);
}
以上就是java中产生随机数字的方法，看完之后是否有所收获呢？如果想了解更多相关内容，欢迎关注亿速云行业资讯，感谢各位的阅读。

java语言产生0~N不重复的随机数
百度的都是乱西八槽的代码，然后参照别人自己写了一个，不废话上代码。大量数据请勿使用！！！！
    /**
	 * @param count 0~count的随机数
	 * @param num 随机数的数量
	 * @return List<Integer>不重复随机数的List集合
	 */
	public static final List<Integer> randomNumber(int count,int num) {
		List<Integer> shu = new ArrayList<Integer>();
		int i=0;
		if(count>=num-1) {//如果随机数量num大于count时
	      while(i<num-1){
	    	  int k=0;
	    	   int a=(int)(Math.random()*count);
		    	   if(shu.size()==0) {
		    		   shu.add(a);
			        }else {
				      for(Integer s:shu) {
				    	if(s.equals(a))
				    		k++;
				        };
			       if(k==0) {
			    	   shu.add(a);
			    	   i++;
			       };
			    };
	         };
		}else {//如果随机数量num小于count时
			while(i<count-1){
		    	  int k=0;
		    	   int a=(int)(Math.random()*count);
			    	   if(shu.size()==0) {
			    		   shu.add(a);
				        }else {
					      for(Integer s:shu) {
					    	if(s.equals(a))
					    		k++;
					        };
				       if(k==0) {
				    	   shu.add(a);
				    	   i++;
				       };
				    };
		         };
		}
		return shu;
	}

一：面向对象构造方法
1.1 构造方法
1.构造方法：创建对象，给对象的成员进行初始化

2.特点：定义在类中，方法名与类名相同；没有返回值类型（void也不能有)。

3.构造方法的重载
public class Student {
    private String name;
    private int age;
    //构造方法的重载，分别为没有参数，一个参数，两个参数
    public Student() {
        System.out.println("空参构造方法");
    }
    public Student(String name){
        System.out.println(name+"一个参数的构造方法");
        this.name=name;
    }
    public Student(String name,int age){
        System.out.println(name+age+"两个参数的构造方法");
        this.age=age;
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}



public class StudentTest {
    public static void main(String[] args) {
        Student student1=new Student();//空参构造方法
        Student student2=new Student("张三");//张三一个参数的构造方法
        Student student3=new Student("张三",20);//张三20两个参数的构造方法
        System.out.println(student2.getName());//张三
        System.out.println(student3.getAge());//20
        System.out.println(student3.getName());//张三
        student1.setAge(23);
        student1.setName("张二");
        System.out.println(student1.getName());//张二
        System.out.println(student1.getAge());//23
    }
}


构造方法重载的注意事项：

当没有给出构造方法是，系统将会默认的提供一个无参构造
如果给定了有参构造，系统则不再提供默认的无参构造，如果想要有无参构造的话，必须自己去给出无参构造
构造方法内存图



创建一个对象时的内存图步骤：

加载student.class文件进内存
在栈内存中为student开辟空间
在堆内存中为学生对象开辟空间，赋予地址值
学生对象的成员变量进行默认初始化
学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址赋值给student变量

1.2 static关键字
1.static关键字的特点
    a.随着类的加载而加载
    b.优先于对象存在
    c.被类的所有对象共享
    d.可以通过类名直接调用
2.static关键字的注意事项
      static关键字在方法中是不能够有this关键字的（static修饰的是在类加载的时候而加载，this是随着对象的创建而存在）
      静态比对象优先存在

public class Person {
    public String name;
    public static int num;
    public static void show(){
        System.out.println("这是一个静态方法");
    }
    public void show2(){
        System.out.println("这是一个非静态方法");
    }
}


public class Test {
    public static void main(String[] args) {
        //类名直接定义static成员变量，属于类
        //静态成员变量一旦被改变，所有的该变量都会发生变化
        Person.num = 10;
        Person p1 = new Person();
        System.out.println(p1.num);//10
        p1.name = "张三";
        System.out.println(p1.name);//张三
        Person p2 = new Person();
        System.out.println(p2.num);//10
        p2.name = "李四";
        System.out.println(p2.name);//李四
        //类名直接调用静态方法，静态方法随着类的加载而加载
        Person.show();//这是一个静态方法
        p1.show2();//这是一个非静态方法
    }
}


1.3 静态变量与成员变量的区别
1.所属不同
      静态变量属于类，也叫类变量，一般使用类名调用
      成员变量属于对象，也叫实例对象（对象变量）
2.内存中的位置不同
      静态变量存储在方法区的静态区
      成员变量存储于堆内存中
3.内存出现的时间不同
     静态变量随着类的加载而加载，随着类的消失而消失
     成员变量随着对象的创建而存在，随着对象的消失而消失
4.调用不同
      静态变量可以通过类名调用，也可以通过对象调用，推荐使用类名调用
      成员变量只能通过对象名进行调用

1.4 Math类的随机数
猜数字小游戏案例：
import java.util.Scanner;

public class number {
    public static void main(String[] args) {
    //Math.random获取一个0.0到1.0之间的随机数
    //Math.random返回的是double类型，使用强制类型转换为int
        int num= (int) (Math.random()*100+1);
        //循环五次
        for (int i = 1; i <= 5; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你猜的数字");
            int usernum = sc.nextInt();
            if (usernum<num){
                System.out.println("数字太小了"+"，你还有"+(5-i)+"次机会");
            }else if (usernum>=num){
                System.out.println("数字太大了"+"，你还有"+(5-i)+"次机会");
            }else {
                System.out.println("恭喜猜对了");
                break;
            }
        }
        System.out.println("挑战失败");
    }
}


1.5 代码块
1.Java代码中，使用{ }括起来的代码称为代码块

2.分类：局部代码块、构造代码块、静态代码块、同步代码块(多线程)

3.局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率

构造代码块：在类中、方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

静态代码块：在类中方法外出现，加了static修饰。用于给类进行初始化，在加载的时候就执行，并且只执行一次。

使用：
public class Test02 {
    static {
        System.out.println("Student 静态代码块"); //运行顺序：3
    }

    {
        System.out.println("Student 构造代码块"); //运行顺序：4  6
    }

    public Test02() {
        System.out.println("Student 构造方法"); //运行顺序：5   7
    }
}

class StudentDemo {
    static {
        System.out.println("StudentDemo的静态代码块");  //首先运行，并且运行一次
    }

    public static void main(String[] args) {
        System.out.println("我是main方法"); //运行main方法 运行顺序：2
        //加载Test02类的时候，静态代码块执行，并且执行一次
        Test02 t1=new Test02();//创建第一个对象时首先执行构造代码块，随后执行构造方法
        Test02 t2=new Test02();//创建第而个对象时先执行构造代码块，随后执行构造方法

    }
}