精华内容
下载资源
问答
  • Math.random(); //0.0 ~ 1.0 之间的一个伪随机数。【包含0不包含1】 //比如0.8647578968666494 2、实例说明: Math.ceil(Math.random()*10); // 获取从1到10的随机整数 ,取0的概率极小。 Math.round(Math.random...

    1、Math 对象方法:

    Math.ceil();  //向上取整。
    Math.floor();  //向下取整。
    Math.round();  //四舍五入。
    Math.random();  //0.0 ~ 1.0 之间的一个伪随机数。【包含0不包含1】 //比如0.8647578968666494


    2、实例说明:

    Math.ceil(Math.random()*10);      // 获取从1到10的随机整数 ,取0的概率极小。
    Math.round(Math.random());   //可均衡获取0到1的随机整数。
    Math.floor(Math.random()*10);  //可均衡获取0到9的随机整数。
    Math.round(Math.random()*10);  //基本均衡获取0到10的随机整数,其中获取最小值0和最大值10的几率少一半。 
    //因为结果在0~0.4 为0,0.5到1.4为1  ...  8.5到9.4为9,9.5到9.9为10。所以头尾的分布区间只有其他数字的一半

     

    展开全文
  • randomjava中我们有时候也需要使用使用random来产生随机数,下面我来简单的介绍下java中random的使用方法public static double random()返回带正号的double值,该值大于等于0.0且小于1.0。返回值是一个伪随机选择的...

    random

    java中我们有时候也需要使用使用random来产生随机数,下面我来简单的介绍下java中random的使用方法

    public static double random()

    返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。

    第一次调用该方法时,它将创建一个新的伪随机数生成器,与以下表达式完全相同

    new java.util.Random

    之后,新的伪随机数生成器可用于此方法的所有调用,但不能用于其他地方。

    此方法是完全同步的,可允许多个线程使用而不出现错误。但是,如果许多线程需要以极高的速率生成伪随机数,那么这可能会减少每个线程对拥有自己伪随机数生成器的争用。

    返回:

    大于等于 0.0 且小于 1.0 的伪随机 double 值。public classRandomDemo {public static voidmain(String[] args) {//创建一个Math.random()的对象

    double random =Math.random();//输出的值是[0.0-1.0)之间的随机数

    System.out.println(random);/** 输出的结果

    * 第一次:0.8302600019925631

    * 第二次:0.27576570444589144

    * ...

    **/}

    }

    第二种:random()

    Random():创建一个新的随机数生成器。

    Random(long seed):使用单个 long 种子创建一个新的随机数生成器。

    Random 有一个特点是:

    相同种子数的Random对象,对应相同次数生成的随机数字是完全相同的

    public classRandomDemo {public static voidmain(String[] args) {

    Random random1= new Random(20);//这个20代表种子数 创建一个新的随机数生成器

    Random random2 = new Random(20);//用for循环输出随机次数

    for (int i = 0; i < 20; i++) {//打印20次随机生成的数字

    System.out.print("random1=" + random1.nextInt(20) + ",");

    }

    System.out.println();for (int j = 0; j < 20; j++) {

    System.out.print("random2=" + random2.nextInt(20) + ",");

    }

    }/** 输出的结果

    * random1=13,random1=16,random1=1,random1=1,random1=5,random1=15,random1=13,

    * random1=15,random1=13,random1=8,

    * random1=6,random1=2,random1=5,random1=10,

    * random1=8,random1=16,random1=4,random1=8,random1=17,random1=6,

    * random2=13,random2=16,random2=1,random2=1,random2=5,random2=15,random2=13,

    * random2=15,random2=13,random2=8,

    * random2=6,random2=2,random2=5,random2=10,

    * random2=8,random2=16,random2=4,random2=8,random2=17,random2=6,

    * 可以看出来输出的结果完全相同。*/}

    无种子数random随机树

    //没有提前给定种子数

    Random random3 = newRandom();for(int x=0;x<20;x++){

    System.out.print("random3="+random3.nextInt(20)+",");

    }/** 结果为

    * random3=0,random3=9,random3=17,random3=1,random3=8,random3=3,random3=1,random3=9,

    * random3=18,random3=13,random3=8,random3=14,random3=14,random3=4,random3=6,random3=5,random3=4,random3=15,random3=5,random3=19,

    * 每次输出的结果都不相同

    **/

    下面给大家带来一些java随机数的源代码

    1,

    nextLong

    public long nextLong()

    返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的 long 值。nextLong 的常规协定是,伪随机地生成并返回一个 long 值。

    Random 类按如下方式实现 nextLong 方法:

    public long nextLong() {

    return ((long)next(32) << 32) + next(32);

    }

    因为 Random 类使用只以 48 位表示的种子,所以此算法不会返回所有可能的 long 值。返回:下一个伪随机数,它是此随机数生成器序列中均匀分布的 long 值。

    2,

    nextBoolean

    public boolean nextBoolean()

    返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的 boolean 值。nextBoolean 的常规协定是,伪随机地生成并返回一个 boolean 值。值 true 和 false 的生成概率(大致)相同。

    Random 类按如下方式实现 nextBoolean 方法:

    public boolean nextBoolean() {

    return next(1) != 0;

    }返回:下一个伪随机数,它是此随机数生成器的序列中均匀分布的 boolean 值。

    3,

    nextFloat

    public float nextFloat()

    返回下一个伪随机数,它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。

    nextFloat 的常规协定是,伪随机地生成并返回一个从 0.0f(包括)到 1.0f(包括)范围内均匀选择(大致)的 float 值。所有可能的 224 个 float 值(其形式为 m x2-24,其中 m 是一个小于 224的正整数)的生成概率(大致)相同。

    Random 类按如下方式实现 nextFloat 方法:

    public float nextFloat() {

    return next(24) / ((float)(1 << 24));

    }

    前面的描述中使用了不确定的词“大致”,因为 next 方法只是一个大致上独立选择位的无偏源。如果它是一个随机选择位的最佳来源,那么给出的算法应该从规定范围完全一致地选择 float 值。

    [在 Java 的早期版本中,结果被错误地计算为:

    return next(30) / ((float)(1 << 30));

    这可能看似等效(如果不是更好的话),但实际上由于浮点数舍入中的偏差,它会导致轻微的不均匀性:有效数的低位更可能是 0 而不是 1。]返回:下一个伪随机数,它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值

    4,

    nextDouble

    public double nextDouble()

    返回下一个伪随机数,它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。

    nextDouble 的常规协定是,伪随机地生成并返回一个从 0.0d(包括)到 1.0d(不包括)范围内均匀选择(大致)的 double 值。

    Random 类按如下方式实现 nextDouble 方法:

    public double nextDouble() {

    return (((long)next(26) << 27) + next(27))

    / (double)(1L << 53);

    }

    前面的描述中使用了不确定的词“大致”,因为 next 方法只是一个大致上独立选择位的无偏源。如果它是一个随机选择位的最佳源,那么给出的算法应该从规定范围完全一致地选择 double 值。

    [在 Java 的早期版本中,结果被错误地计算为:

    return (((long)next(27) << 27) + next(27))

    / (double)(1L << 54);

    这可能看似等效(如果不是更好的话),但实际上由于浮点数舍入中的偏差,它会引入较大的不均匀性:有效数的低位出现 0 的可能性是 1 的三倍!这种不均匀性在实践中可能没什么关系,但我们总是力求完美。]返回:下一个伪随机数,它是此随机数生成器序列中 0.0 和 1.0 之间均匀分布的 double 值

    5,

    nextGaussian

    public double nextGaussian()

    返回下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布的 double 值,其平均值是 0.0,标准差是 1.0。

    nextGaussian 的常规协定是,伪随机地生成并返回一个 double 值,该值从(大致)具有平均值 0.0 和标准差 1.0 的标准正态分布中选择。

    Random 类按以下这种线程安全的方式实现 nextGaussian 方法:

    private double nextNextGaussian;

    private boolean haveNextNextGaussian = false;

    public double nextGaussian() {

    if (haveNextNextGaussian) {

    haveNextNextGaussian = false;

    return nextNextGaussian;

    } else {

    double v1, v2, s;

    do {

    v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0

    v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0

    s = v1 * v1 + v2 * v2;

    } while (s >= 1 || s == 0);

    double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);

    nextNextGaussian = v2 * multiplier;

    haveNextNextGaussian = true;

    return v1 * multiplier;

    }

    }

    这使用了 G. E. P. Box、M. E. Muller 和 G. Marsaglia 的极坐标法 (polar method),该方法在 Donald E. Knuth 的 The Art of Computer Programming, Volume 3:Seminumerical Algorithms 的第 3.4.1 节,小节 C,算法 P 中进行了描述。注意,它只需调用一次 StrictMath.log 和调用一次 StrictMath.sqrt> 就可以生成两个独立的值。返回:下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布的 double 值,其平均值是 0.0,标准差是 1.0。

    6,

    nextInt

    public int nextInt(int n)

    返回一个伪随机数,它是取自此随机数生成器序列的、在 0(包括)和指定值(不包括)之间均匀分布的 int 值。nextInt 的常规协定是,伪随机地生成并返回指定范围中的一个 int 值。所有可能的 n 个 int 值的生成概率(大致)相同。Random 类按如下方式实现 nextInt(int n) 方法:

    public int nextInt(int n) {

    if (n<=0)

    throw new IllegalArgumentException("n must be positive");

    if ((n & -n) == n) // i.e., n is a power of 2

    return (int)((n * (long)next(31)) >> 31);

    int bits, val;

    do {

    bits = next(31);

    val = bits % n;

    } while(bits - val + (n-1) < 0);

    return val;

    }

    前面的描述中使用了不确定的词“大致”,因为 next 方法只是一个大致上独自选择位的无偏源。如果它是一个随机选择位的最佳源,那么给出的算法应该从规定范围完全一致地选择 int 值。

    该算法稍微有些复杂。它拒绝那些会导致不均匀分布的值(由于 2^31 无法被 n 整除)。某个值被拒绝的概率取决于 n。最坏的情况是 n=2^30+1,拒绝的概率是 1/2,循环终止前的预计迭代次数是 2。

    该算法特别对待 n 是 2 的次幂的情况:它从底层伪随机数生成器中返回正确的高位数。在不是特殊处理的情况中,将返回正确的低 位数。众所周知,线性同余伪随机数生成器(比如此类所实现的)在其低位的值序列中周期较短。因此,如果 n 是 2 的次幂(幂值较小),则这种特殊情况将大大增加此方法的后续调用所返回的值序列长度。参数:n - 要返回的随机数的范围。必须为正数。返回:下一个伪随机数,在此随机数生成器序列中 0(包括)和 n(不包括)之间均匀分布的 int 值。抛出:

    7,

    nextInt

    public int nextInt()

    返回下一个伪随机数,它是此随机数生成器的序列中均匀分布的 int 值。nextInt 的常规协定是,伪随机地生成并返回一个 int 值。所有 232 个可能 int 值的生成概率(大致)相同。

    Random 类按如下方式实现 nextInt 方法:

    public int nextInt() {

    return next(32);

    }返回:下一个伪随机数,它是此随机数生成器的序列中均匀分布的 int 值。

    8,

    nextBytes

    public void nextBytes(byte[] bytes)

    生成随机字节并将其置于用户提供的 byte 数组中。所生成的随机字节数等于该 byte 数组的长度。

    Random 类按如下方式实现 nextBytes 方法:

    public void nextBytes(byte[] bytes) {

    for (int i = 0; i < bytes.length; )

    for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);

    n-- > 0; rnd >>= 8)

    bytes[i++] = (byte)rnd;

    }参数:bytes - 用随机字节填充的 byte 数组抛出:

    9,

    next

    protected int next(int bits)

    生成下一个伪随机数。当被所有其他方法使用时,子类应该重写此方法。

    next 的常规协定是,返回一个 int 值,如果参数 bits 位处于 1 和 32(包括)之间,那么返回值的多数低位都将(大致)是单独选择的位值,每个位值是 0 或 1 的机会(大致)相等。通过将种子自动更新为

    (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)

    并返回

    (int)(seed >>> (48 - bits)),Random 类可实现 next 方法。

    这是一个线性同余伪随机数生成器,由 D. H. Lehmer 定义,Donald E. Knuth 在 The Art of Computer Programming, Volume 3: Seminumerical Algorithms 的第 3.2.1 节中进行了描述。参数:bits - 随机位。返回:随机数生成器序列的下一个伪随机值。

    希望有对java随机数有深入了解的朋友可以给我讲解讲解!

    (个人观点,错误的地方请谅解)

    展开全文
  • 今天小编就为大家分享一篇关于实例讲解Java中random.nextInt()与Math.random()的基础用法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • Math.random()

    2020-10-27 20:09:29
    Math.random()用法 Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值。 返回指定范围的随机数[m,n]的公式:Math.random()*(n-m+1)+m; Math.round()用法 Math.round()就是括号内的数+0.5...

    在java好几次用到了Math.random()这个函数,每次使用容易和Math.round()用法混淆,都要百度如何取范围,今天又需要了,写下来当总结。

    Math.random()用法

    Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值。

    返回指定范围的随机数[m,n]的公式:Math.random()*(n-m+1)+m;

    Math.round()用法

    Math.round()就是括号内的数+0.5之后,向下取值

    【demo】随机取1-10之间的数

    var a = Math.round(Math.random()*9+1);
    注意:因为Math.random()返回的是<1的数,是不包括1的,如果不加Math.round可能就会把边界漏掉!!!

    展开全文
  • Math.random()用法

    万次阅读 多人点赞 2018-12-19 19:58:22
    Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值 2.使用方法: 例: int num = (int)(Math.random()*2+1) //以上代码即设置一个随机1到3(取不到3)的变量num。 例:  【应用场景...

    Math.random( ) 的使用


    1.介绍:

    Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 

    2.使用方法:

    例:

    int  num = (int)(Math.random()*2+1)
    //以上代码即设置一个随机1到3(取不到3)的变量num。

    例: 
    【应用场景描述:】 
    用Math类的random()方法产生一个字符,若该字符是一个大写英文字母,则输入 “Yes!”,否则输出“NO”。 
    random()方法产生的随机数在0.0和1.0之间,乘以128后,其值在0.0和128.0之间,将它转换为char类型后,用if来判断是否在’A’ 和’Z’之间。

    public class IsUpper{
        public static void main(String [] args){
        char ch;
        ch = ( char ) ( Math.random() * 128);
        if ( ch >= 'A' && ch <= 'Z'){
            System.out.println("Yes!");}
        else{
            System.out.println("No!");}
        }
    }
    

    3.总结归纳:

    //产生一个[0,1)之间的随机数。
    Math.random():
    
    //返回指定范围的随机数(m-n之间)的公式:
    Math.random()*(n-m)+m;
    或者
    Math.random()*(n+1-m)+m

    4.Math类的random()方法

    Math类的random()方法可以生成大于等于0.0、小于1.0的double型随机数。

    Math.random()方法语句基础上处理可获得多种类型、或任意范围的随机数。

    公式:

    int num=(int)(Math.random()*n);			//返回大于等于0小于n之间的随机数
    int num0=m+(int)(Matn.randon()*n);		//返回大于等于m小于m+n(不包括m+n)之间的随机数

    例如:我们需要取2~22之间的偶数

    public class MathRandomDemo{
    	public static int GetevenNum(double num1,double num2){
    		int s=(int)num1+(int)(Math.random()*(num2-num1));
    		if(s%2==0){
    			return s;
    		}
    		else
    			retuen s+!;
    	}
    	public static void main(String[] args){
    		System.out.println("任意一个"+num1+"~"+num2+"之间的偶数:"+GeteneNum(2,22));
    	}
    }

    还可以随机生成字符

    例如:

    1.随机生成a~z之间的字符

    (char)('a'+Math.random()*('z'-'a'+1));

    2.随机生成cha1~cha2的字符

    (char)(cha1+Math.random()*(cha2-cha1+1));

     

    5.Random类生成随机数

    除了Math类的Random()方法可以获取随机数之外,还可以Java.util.Random类,可以通过实例化一个Random对象创建一个随机数生成器。

    1.语法:

    Random ran=new Random();

    Random类的实例对象以这种形式实例化对象时,Java编译器以系统当前时间作为随机数生成器的种子,因为每时每刻的时间都不可能相同,所以产生的随机数也不同。如果运行速度太快,也会产生两次运行结果相同的随机数。

    2.可以在实例化Random类对象时,自定义随机数生成器的种子。
    语法:

    Random ran=new Random(seedValue);
    
    Random类中还提供各种类型随机数的方法:
    nextInt():返回一个随机整数(int)
    nextInt(int n):返回大于等于0、小于n的随机整数(int)
    nextLong():返回一个随机长整型值(long)
    nextBoolean():返回一个随机布尔型值(boolean)
    nextFloat():返回一个随机浮点型值(float)
    nextDouble():返回一个随机双精度型值(double)
    nextGaussian():概率密度为高斯分布的双精度值(double)

    import java.util.Random;
    public class Demo{
    	public static void main(String[] args){
    		Random ran=new Random();
    		System.out.println("产生一个随机整数:"+ran.nextlnt());
    	}
    }

     

    Math.random( ) 的使用

    Math类和Random类生成的随机数

    JAVA中的Random()函数

    Java中Double保留后小数位的几种方法

    展开全文
  • Math.random() 为 java.lang.Math 类中的静态方法。 2、用法 产生0-n的伪随机数(伪随机数参看最后注解): // 两种生成对象方式:带种子和不带种子(两种方式的区别见注解) Random random = new Random(); Integer ...
  • Math.random() Math.random()是一个随机函数,利用该函数可以随机产生一个p(0<...//Math.random()用法 public class Random_Math { public static void main(String[] args) { // TODO Auto-genera...
  • Math.random() 为 java.lang.Math 类中的静态方法。2、用法产生0-n的伪随机数(伪随机数参看最后注解):// 两种生成对象方式:带种子和不带种子(两种方式的区别见注解)Random random = new Random();Integer res = ...
  • Math.random() 为 java.lang.Math 类中的静态方法。2、用法产生0-n的伪随机数(伪随机数参看最后注解):// 两种生成对象方式:带种子和不带种子(两种方式的区别见注解)Random random = new Random();Integer res = ...
  • JavaScript Math.random()函数用法详解

    千次阅读 2019-12-18 15:37:51
    JavaScript Math.random()函数用法详解 Math.random()函数返回0到1之间的伪随机数,包含0,但是不包含1,[0,1}。 逻辑梳理: 生成m-n,包含m但不包含n的整数: 第一步算出 n-m的值,假设等于w 第二步Math....
  • 用法一: 不给范围,就随机算一个0~1之间的小数: 用法二:给一个参数,就取1~n之间的随机数 ...math.randomseed()用法: 由于C中所产生的随机序列是固定的。也就是每次执行时取得的随机数是一样的。 ...
  • math.random()函数用法

    万次阅读 2017-08-28 17:58:28
    math.random()函数是取[0,1)之间的随机数,则math.random()*100表示[0,100)之间的随机数,(math.random()*40)*10表示[0,400)之间的随机数,如需取整则int((math.random()*40)*10)这样。
  • Math.random()用法 Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值。 返回指定范围的随机数[m,n]的公式:Math.random()*(n-m+1)+m; Math.round()用法 Math.round()就是括号内的数+0...
  • return Math.random()*(max-min)+min; //返回的是一个非整数小于两个实参之间的浮点型的随机值。 } 2.得到一个两数之间的随机整数 function getRandom(min,max){ return Math.floor(Math.random()*(max-min))+...
  • Math.random()和Math.round()总结

    千次阅读 2015-04-05 19:01:32
    在java、c#、js里面都...Math.random()用法 Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值。 返回指定范围的随机数[m,n]的公式:Math.random()*(n-m+1)+m; Math.round()用法 Mat
  • 生成随机数 Math.random()用法

    千次阅读 2019-07-06 10:07:40
    生成随机数 Math.random()用法 https://blog.csdn.net/levae1024/article/details/85106292
  • 文章详细的介绍了关于java随机数Math.random()函数用法,以前利用实例来说明random()函数详情,有需要的同学可以看看。1、Math库里的static(静态)方法random()该方法的作用是产生0到1之间(包括0,但不包括1)的一个...
  • random.nextInt()与Math.random()区别

    千次阅读 2017-12-01 20:40:36
    Math.random() 为 java.lang.Math 类中的静态方法。 2、用法 产生0-n的伪随机数(伪随机数参看最后注解): // 两种生成对象方式:带种子和不带种子(两种方式的区别见注解) Random random = new Random...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 430
精华内容 172
关键字:

math.random()用法