精华内容
下载资源
问答
  • java随机数生成函数

    千次阅读 2017-07-23 11:58:44
    1、import java.util.Random; 然后定义一个对象r 2、Random r=new Random(); 3、nextInt(x)方法用与获取 0-x 之间的整数数,不包括x。 4、int s=r.nextInt(10); // s为 [0,9] 之间的任意整数 ...
    首先加载相应的包,相当于c++中的头文件

    1、import java.util.Random;

    然后定义一个对象r

    2、Random r=new Random();

    3、nextInt(x)方法用与获取 0-x 之间的整数数,不包括x。

    4、int s=r.nextInt(10); // s为 [0,9] 之间的任意整数

    如果要获取指定范围的随机整数可以用下面的方法

    5、int randNumber =rand.nextInt(MAX - MIN + 1) + MIN;

    或者使用

       int s = random.nextInt(max)%(max-min+1) + min;

    对 “int randNumber =rand.nextInt(MAX - MIN + 1) + MIN;”的解释
    例如:
          int max=20;
          int min =10;
          则rand.nextInt(max-min+1)代表取[0,11)(即[0,10])之间的随机整数,在后面加上min后,代表取[10,20]之间的任意整数


    展开全文
  • 前言 2021春季社招正在火热招聘当中,很多人都挂在了技术知识掌握...近日,经过一朋友的透露,Alibaba自爆了一份“Java核心架构笔记”,里面记载的知识点非常齐全,看完之后才知道,差距真的不止一点点! 这份笔记按照

    前言

    2021春季社招正在火热招聘当中,很多人都挂在了技术知识掌握还是不够广,不够深,甚至连一些基础的问题都只能模模糊糊的回答出来。你说,这跳槽不是跳了个寂寞吗?

    其实,根本原因还是对于自己的技术栈掌握的不够系统化。从目前招聘要求来看,夯实的基础是一个程序员必备的技术点,除此之外,对于技术栈的广度以及深度你更需要去探索,形成一份自己的技术路线X-Mind。

    近日,经过一朋友的透露,Alibaba自爆了一份“Java核心架构笔记”,里面记载的知识点非常齐全,看完之后才知道,差距真的不止一点点!

    这份笔记按照开发经验对程序员进行分层,可以很清晰的知道在哪个阶段你应该掌握哪些技术栈,下面我会介绍到这份笔记主要涵盖的知识点,由于篇幅限制,仅只能展示部分截图内容,完整的内容可以在文末下载。

    二、解析

    1. 硬件层的并发优化基础知识

    存储器的层次结构图如下:

    各级缓存耗时对比:

    采用分层缓存的层次结构会带来数据不一致问题,如下图:

    那么如何保证数据的一致性,现代CPU处理办法有两种:

    (1) 锁系统总线;

    (2) 利用缓存一致性协议MESI(Intel处理器用的比较多,还有很多其他的缓存一致性协议),大致结构如下图:

    2. CPU的乱序执行

    CPU中有个乱序执行的概念,概念图如下:

    CPU在执行指令的时候,往往不是顺序执行,但是会遵守as-if-serial原则,也就是最终一致性原则。CPU为了提高指令执行效率,会在一条指令执行过程中(比如去内存读数据),去同时执行另一条指令,前提是这两条指令没有依赖关系。虽然指令执行顺序发生改变,但是不会影响单线程执行结果。多线程情况下为了不让CUP进行指令重排序,则需要用到Volatile关键字,因为Volatile的重要作用之一就是防止指令重排序。

    CPU还会存在合并写的现象。当第一条指令往上级缓存写入数据时,由于上级缓存访问速度比较慢,可能第二条指令又对上一条指令的结果进行了修改,那么CPU将这两条指令合并的最终结果一次性的写入到缓存中,这就成为合并写。

    3. 如何保证不乱序执行

    (1) 内存屏障:java采用的是内存屏障,内存屏障其实就是一个CPU指令,在硬件层面上来说可以扥为两种:Load Barrier 和 Store Barrier即读屏障和写屏障。主要有两个作用:

    a. 阻止屏障两侧的指令重排序;

    b. 强制把写缓冲区/高速缓存中的脏数据等写回主内存,让缓存中相应的数据失效。

    写在最后

    以上分享的全部资料都可免费分享领取—— 【点击这里下载】

    还有一份JAVA核心知识点整理(PDF):JVM,JAVA集合,JAVA多线程并发,JAVA基础,Spring原理,微服务,Netty与RPC,网络,日志,Zookeeper,Kafka,RabbitMQ,Hbase,MongoDB,Cassandra,设计模式,负载均衡,数据库,一致性哈希,JAVA算法,数据结构,加密算法,分布式缓存,Hadoop,Spark,Storm,YARN,机器学习,云计算…

    哈希,JAVA算法,数据结构,加密算法,分布式缓存**,Hadoop,Spark,Storm,YARN,机器学习,云计算…

    image

    展开全文
  • JAVA随机数生成

    2020-09-14 20:33:19
    JAVA随机数生成方式一:java.lang.Math.Random方式二:java.util.Random JAVA中有两种方式生成随机数: 方式一:java.lang.Math.Random 调用Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,...


    JAVA中有两种方式生成随机数:

    方式一:java.lang.Math.Random

    调用Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。例子如下:

    package IO;
    import java.util.Random;
    
    public class TestRandom {
        
        public static void main(String[] args) {
            // 案例1
            System.out.println("Math.random()=" + Math.random());// 结果是个double类型的值,区间为[0.0,1.0)
            //例如:生成0-2的随机数
            int num = (int) (Math.random() * 3); // 注意不要写成(int)Math.random()*3,这个结果为0,因为先执行了强制转换
            System.out.println("num=" + num);
            
    

    方式二:java.util.Random

    Random()有两种构造方法:

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

    我们可以在构造Random对象的时候指定种子(这里指定种子有何作用,请接着往下看),如:Random r1 = new Random(20);

    或者默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();

    需要说明的是:你在创建一个Random对象的时候可以给定任意一个合法的种子数,种子数只是随机算法的起源数字,和生成的随机数的区间没有任何关系。如下面的Java代码:

    Random rand =new Random(25);
    int i;
    i=rand.nextInt(100);
    

    初始化时25并没有起直接作用(注意:不是没有起作用),rand.nextInt(100);中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

    具体用法如下例:

    package com.kun.package02;
    
    import java.util.ArrayList;
    import java.util.Random;
    
    /**
     * @author Kunaly
     * @date 2020-09-13 23:25
     */
    public class TestRandom {
    
        public static void main(String[] args) {
    
            // 案例2
            // 对于种子相同的Random对象,生成的随机数序列是一样的。
            Random ran1 = new Random(10);
            System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
            for (int i = 0; i < 10; i++) {
                System.out.print(ran1.nextInt(10) + " ");
            }
            System.out.println();
            Random ran2 = new Random(10);
            System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
            for (int i = 0; i < 10; i++) {
                System.out.print(ran2.nextInt(10) + " ");
            }
            /**
             * 输出结果为:
             *
             * 使用种子为10的Random对象生成[0,10)内随机整数序列:
             * 3 0 3 0 6 6 7 8 1 4
             * 使用另一个种子为10的Random对象生成[0,10)内随机整数序列:
             * 3 0 3 0 6 6 7 8 1 4
             *
             */
    
            // 案例3
            // 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
            Random r3 = new Random();
            System.out.println();
            System.out.println("使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列");
            for (int i = 0; i < 10; i++) {
                System.out.print(r3.nextInt(10)+" ");
            }
            /**
             * 输出结果为:
             *
             * 使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列
             * 1 2 0 1 7 7 1 2 4 5 
             *
             */
    
            // 另外,直接使用Random无法避免生成重复的数字,如果需要生成不重复的随机数序列,需要借助数组和集合类
            ArrayList list=new TestRandom().getDiffNO(10);
            System.out.println();
            System.out.println("产生的n个不同的随机数:"+list);
        }
    
        /**
         * 生成n个不同的随机数,且随机数区间为[0,10)
         * @param n
         * @return
         */
        public ArrayList getDiffNO(int n){
            // 生成 [0-n) 个不重复的随机数
            // list 用来保存这些随机数
            ArrayList list = new ArrayList();
            Random rand = new Random();
            boolean[] bool = new boolean[n];
            int num = 0;
            for (int i = 0; i < n; i++) {
                do {
                    // 如果产生的数相同继续循环
                    num = rand.nextInt(n);
                } while (bool[num]);
                bool[num] = true;
                list.add(num);
            }
            return list;
        }
    }
    
    

    Java.util.Random()方法摘要:
    1.protected int next(int bits):生成下一个伪随机数。
    2.boolean nextBoolean():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的boolean值。
    3.void nextBytes(byte[] bytes):生成随机字节并将其置于用户提供的 byte 数组中。
    4.double nextDouble():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
    5.float nextFloat():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
    6.double nextGaussian():返回下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布的double值,其平均值是0.0标准差是1.0。
    7.int nextInt():返回下一个伪随机数,它是此随机数生成器的序列中均匀分布的 int 值。
    8.int nextInt(int n):返回一个伪随机数,它是取自此随机数生成器序列的、在(包括和指定值(不包括)之间均匀分布的int值。
    9.long nextLong():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的 long 值。
    10.void setSeed(long seed):使用单个 long 种子设置此随机数生成器的种子。

    使用举例:
    1.生成[0,1.0)区间的小数:double d1 = new Random().nextDouble();
    2.生成[0,5.0)区间的小数:double d2 = new Random().nextDouble() * 5;
    3.生成[1,2.5)区间的小数:double d3 = new Random().nextDouble() * 1.5 + 1;
    4.生成[0,10)区间的整数:
    int n2 = new Random().nextInt(10); //方法一
    int n2 = Math.abs(new Random().nextInt() % 10); //方法二
    int n2 = (int) (Math.random() * 10); //方法三

    package org.xiaowu.random.demo;
    
    import java.util.Random;
    
    import org.junit.Test;
    
    public class RandomDemo {
        
        @Test
        public void Demo(){
            Random rnd = new Random();
            int code = rnd.nextInt(8999) + 1000;
            System.out.println("code:"+code);
        }
    
        
        @Test
        public void Demo1(){
            Random r = new Random();
            int nextInt = r.nextInt();
            Random r1 = new Random(10);
            int nextInt2 = r1.nextInt();
            System.out.println("nextInt:"+nextInt);
            System.out.println("nextInt2:"+nextInt2);
        }
    
        
        /**
         * 生成[0,1.0)区间的小数
         * 
         */
        @Test
        public void Demo2(){
            Random r = new Random();
            double d1 = r.nextDouble();
            System.out.println("d1:"+d1);
        }
    
        
        /**
         * 生成[0,5.0)区间的小数
         * 
         */
        @Test
        public void Demo3(){
            Random r = new Random();
            double d2 = r.nextDouble()* 5;
            System.out.println("d1:"+d2);
        }
    
        
        /**
         * 生成[1,2.5)区间的小数
         * 
         */
        @Test
        public void Demo4(){
            Random r = new Random();
            double d3 = r.nextDouble() * 1.5 + 1;
            System.out.println("d1:"+d3);
        }
    
        
        /**
         * 生成任意整数
         * 
         */
        @Test
        public void Demo5(){
            Random r = new Random();
            int n1 = r.nextInt();
            System.out.println("d1:"+n1);
        }
    
        
        
        /**
         * 生成[0,10)区间的整数
         * 
         */
        @Test
        public void Demo6(){
            Random r = new Random();
            int n2 = r.nextInt(10);
            int n3 = Math.abs(r.nextInt() % 10);
            System.out.println("n2:"+n2);
            System.out.println("n3:"+n3);
        }
    
        
        
        /**
         * 生成[0,10]区间的整数
         * 
         */
        @Test
        public void Demo7(){
            Random r = new Random();
            int n3 = r.nextInt(11);
            int n4 = Math.abs(r.nextInt() % 11);
            System.out.println("n3:"+n3);
            System.out.println("n4:"+n4);
        }
    
        
        /**
         * 生成[-3,15)区间的整数
         * 
         */
        @Test
        public void Demo8(){
            Random r = new Random();
            int n4 = r.nextInt(18) - 3;
            int n5 = Math.abs(r.nextInt() % 18) - 3;
            System.out.println("n4:"+n4);
            System.out.println("n5:"+n5);
        }
        
    }
    
    展开全文
  • Java随机数生成(简单)

    千次阅读 2020-12-07 18:35:11
    第一种是要借助java.util.Random类来产生一个随机数发生器,也是常见的一种,构造函数有两个,Random()和Random(long seed)。第一个就是以当前时间为默认种子,第二个是以指定的种子值进行。产生之后,借助不同的语句...

    在Java中随机生成数是我们程序员必须掌握的一项技能,那么java中随机生成数主要的有两种方法:
    第一种:new Random()
    第二种:Math.random()

    第一种是要借助java.util.Random类来产生一个随机数发生器,也是常见的一种,构造函数有两个,Random()和Random(long seed)。第一个就是以当前时间为默认种子,第二个是以指定的种子值进行。产生之后,借助不同的语句产生不同类型的数。

    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);
      }
    }
    通过Random对象获取随机数。Random支持的随机值类型包括:boolean, byte, int, long, float, double。
    比如,获取[0, 100)之间的int整数。方法如下:
    
    int i2 = random.nextInt(100);
    
    
    
    在我的编译器下产生的五个数均为82,89,41,14,67

    而第二种方法返回的数值是[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);
         }
    
    展开全文
  • java随机数生成

    2015-10-17 17:41:00
    一.java.lang.Math.Random 调用这个Math.Random()函数能够返回带正号的double值,取值... 二.java.util.Random 常用函数 protected int next(int bits):生成下一个伪随机数。 boolean nextBoolean():返回下一个伪...
  • java-随机数生成

    2020-12-22 03:52:30
    Java随机数生成 随机数有三种生成方式 1.通过Math.random()方法 2.通过System.currentTimeMillis()方法获取毫秒数, 3.通过Random类 ——————————————————————使用开发工具MyEclipse10 第一种:...
  • 7、Java IO,NIO,Java中有没有实现异步IO Java IO实现的是同步阻塞,它是怎么实现同步阻塞的。我拿了read()方法举例来讲的。NIO实现的是同步非阻塞,我详细讲了一下Selector中的select()方法轮询说明它是如何实现...
  • 7、Java IO,NIO,Java中有没有实现异步IO Java IO实现的是同步阻塞,它是怎么实现同步阻塞的。我拿了read()方法举例来讲的。NIO实现的是同步非阻塞,我详细讲了一下Selector中的select()方法轮询说明它是如何实现...
  • 由于J2me中的Java.util.Random只包含了nextInt(),nextLong()两个方法,所以写了2个函数作为nextInt()的扩展,在编程中经常用到。 /** * 小于t大于0的随机数 * @param t int * @return byte */ private byte ...
  • 我有一个需求,需要随机生成大量16位的...我用我比较熟悉的java试过,生成了1000万个数字也没用出现重复情况。毕竟1000万只是16位数字所包含量的上亿分之一。 可是我换到PHP却发现情况不同了,原先使用rand()生成随机数
  • Random的构造函数会生成一个随机数生成器。每次调用构造函数生成的随机数种子都不一样。 nextInt方法:返回下一个均匀分布的伪随机整数,合计共2的32次方的整数值。 ThreadLocalRandom ThreadLocalRandom是线程...
  • java的三种随机数生成方式 随机数的产生在一些代码中很常用,也是我们必须要掌握的。而java中产生随机数的方法主要有三种:  第一种:new Random()  第二种:Math.random()  第三种:currentTimeMillis() 第一种...
  • 符合28个概率分布函数随机数生成Java代码实现(更新中)具体代码,接口中序号后有---的分布还没有上传进去
  • 文章目录java的三种随机数生成方式 java的三种随机数生成方式 随机数的产生在一些代码中很常用,也是我们必须要掌握的。而java中产生随机数的方法主要有三种: 第一种:new Random() 第二种:Math.random() 第三种:...
  • 1、Random对象的生成 Random类包含两个构造方法,下面依次进行介绍: a、public Random()该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数,然后使用这个种子数构造Random对象。 b、public ...
  • java生成随机数

    2020-10-25 16:41:04
    可以使用java.util.Random类构造一个随机数生成器,构造函数有两种: (1)Random() :创建一个新的随机数生成器 (2)Random(long seed) :使用单个long种子创建一个新的随机数生成器。 示例: (1) 这里用Random...
  • Java随机数函数Random()详解+案例

    千次阅读 2019-10-17 09:35:48
    Random():创建一个新的随机数生成器,这种方式采用默认的种子。 Random(long seed):使用seed为种子创建一个新的随机数生成器。 种子的作用:我们在创建Random对象的时候,如果不设定种子,对象会采用默认的...
  • java 随机数

    2014-12-17 09:46:23
    // 构造函数(一): 创建一个新的随机数生成器。 Random() // 构造函数(二): 使用单个 long 种子创建一个新随机数生成器: public Random(long seed) { setSeed(seed); } next 方法使用它来保存随机数生成器的状态...
  • (1)JAVA语言产生随机数,random函数,定义参数max的作用是给出最大随机数生成范围,当然也可以产生一组随机数,定义数组mat[],在random中定义int n, int max,n代表生成数组里有几个随机数,max还是生成范围。...
  • java生成随机数

    2020-04-01 01:16:45
    rand.nextInt(100); 这行代码将生成范围0~100 之间的随机数,取值可能为 0 ,但不可能为 100。我们用中学数学课学习的区间...借助java.util.Random类来产生一个随机数发生器,也是最常用的一种,构造函数有两个,Ran...
  • java随机数

    2012-11-13 14:39:13
    1.java.lang.Math.random() 在所有其他语言中,生成随机数就像是使用Math工具类,如abs, pow, floor, sqrt和其他数学函数。大多数人通过书籍、教程和课程来了解这个类。一个简单的例子:从0.0到1.0之间可以生成一个...
  • Java随机数

    2016-12-29 18:11:00
    Java中提供了两种方法(Random函数)来生成随机数java.lang.Math.Random;java.util.Random;这两个的详细区别可以看下面的参考文章下面使用java.util.Random 来生成String类型的一个4位随机数String str = ...
  • JAVA - 生成随机数

    2018-06-09 23:57:23
    Java随机数产生原理JAVA中的随机数都是伪随机数。伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。Java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的。只要这个随机数是...

空空如也

空空如也

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

java随机数生成函数

java 订阅