java 如何创建一个类或方法能够给出产生指定位数的一个随机数？

Posted 2023-04-18

java 如何创建一个类或方法能够给出产生指定位数的一个随机数？
例如
Rnd（2） 可给出一个随机两位数 比如 23
Rnd（5） 可给出一个随机五位数 比如 33344

最好有具体代码，谢谢！

　　可以用Math.random()函数生成一个随机数，然后检查位数，如果位数不符合要求，就重新生成一个随机数，下面的程序是一个实现。

public class RandomTest

    public static int rand(int n)
    
        int ans = 0;
        while(Math.log10(ans)+1<n)
            ans = (int)(Math.random()*Math.pow(10, n));
        return ans;
    
    public static void main(String[] args)
    
        for(int i=0;i<1000;i++)
        
            System.out.println(rand(4));
        
    

参考技术A

具体的代码

    /*
     * 返回长度为【strLength】的随机数，在前面补0
     */
    private static String getFixLenthString(int strLength) 
        
        Random rm = new Random();
        
        // 获得随机数
        double pross = (1 + rm.nextDouble()) * Math.pow(10, strLength);

        // 将获得的获得随机数转化为字符串
        String fixLenthString = String.valueOf(pross);

        // 返回固定的长度的随机数
        return fixLenthString.substring(1, strLength + 1);
    

这么用

 
     System.out.println(getFixLenthString(6));
     i++;

追问

请问是否能按照上面的方法给出一个十万位的“大数随机数”，谢谢！

本回答被提问者采纳 参考技术B 【俊狼猎英】团队为您解答~
感觉应该不难，比如说产生一个三位数
首先用(int)Math.Random()*1000产生一个0~999的整数，然后只要加一个判断，如果小于100，就再产生一次，如果符合条件返回就可以了 参考技术C static Random random=new Random();//生成随机数的对象
public static void main(String[] args) 
System.out.println(rand(5));

public static String rand(int count)
String result="";
for (int i = 0; i < count; i++) 
int number=random.nextInt(9);//随机生成0-9之间的数字
if(i==0&&number==0)
i--;//第一位数字不能为0
continue;

result+=number;

return result;

参考技术D 按照这位网友的回答，稍加改动可能更合理一些。把产生数字的代码写成：(int)Math.Random() * 900 + 100;
这样得到的数字就是三位数：100到999了。

java创建多线程（转载）

转载自：Java创建线程的两个方法

Java提供了线程类Thread来创建多线程的程序。其实，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程，有两种方法：

◆需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法； 
◆实现Runnalbe接口，重载Runnalbe接口中的run()方法。

 

为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.

（1）通过扩展Thread类来创建多线程

假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

<span style="font-size: 16px;">public class MutliThreadDemo {     public static void main(String [] args){         MutliThread m1=new MutliThread("Window 1");         MutliThread m2=new MutliThread("Window 2");         MutliThread m3=new MutliThread("Window 3");         m1.start();         m2.start();         m3.start();     } } class MutliThread extends Thread{     private int ticket=100;//每个线程都拥有100张票     MutliThread(String name){         super(name);//调用父类带参数的构造方法     }     public void run(){         while(ticket>0){             System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());         }     } } </span>

 

 程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。

从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。

可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。

（2）通过实现Runnable接口来创建多线程

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

<span style="font-size: 16px;">public class MutliThreadDemo2 {     public static void main(String [] args){         MutliThread m1=new MutliThread("Window 1");         MutliThread m2=new MutliThread("Window 2");         MutliThread m3=new MutliThread("Window 3");         Thread t1=new Thread(m1);         Thread t2=new Thread(m2);         Thread t3=new Thread(m3);         t1.start();         t2.start();         t3.start();     } } class MutliThread implements Runnable{     private int ticket=100;//每个线程都拥有100张票     private String name;     MutliThread(String name){         this.name=name;     }     public void run(){         while(ticket>0){             System.out.println(ticket--+" is saled by "+name);         }     } } </span>

由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。

可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

 

由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。

可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

（3）通过实现Runnable接口来实现线程间的资源共享

 现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

<span style="font-size: 16px;">public class MutliThreadDemo3 {     public static void main(String [] args){         MutliThread m=new MutliThread();         Thread t1=new Thread(m,"Window 1");         Thread t2=new Thread(m,"Window 2");         Thread t3=new Thread(m,"Window 3");         t1.start();         t2.start();         t3.start();     } } class MutliThread implements Runnable{     private int ticket=100;//每个线程都拥有100张票     public void run(){         while(ticket>0){             System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());         }     } } </span>

 结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。