• random随机数

    短8位UUID思想其实借鉴微博短域名的生成方式，但是其重复概率过高，而且每次生成4个，需要随即选取一个。

    本算法利用62个可打印字符，通过随机生成32位UUID，由于UUID都为十六进制，所以将UUID分成8组，每4个为一组，然后通过模62操作，结果作为索引取出字符，

    这样重复率大大降低。

    经测试，在生成一千万个数据也没有出现重复，完全满足大部分需求。

    代码贴出来供大家参考。

    ?
    public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f",
                "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
                "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
                "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
                "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
                "W", "X", "Y", "Z" };
     
     
    public static String generateShortUuid() {
        StringBuffer shortBuffer = new StringBuffer();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        for (int i = 0; i < 8; i++) {
            String str = uuid.substring(i * 4, i * 4 + 4);
            int x = Integer.parseInt(str, 16);
            shortBuffer.append(chars[x % 0x3E]);
        }
        return shortBuffer.toString();
     
    }

    http://my.oschina.net/vvcumt/blog/491504

    ##########################################

    java中生成不重复随机的数字  

    2010-04-26 22:24:00|  分类： JAVA程序|举报|字号 订阅

      下载LOFTER我的照片书  |
     
     

    Java中产生随机数

    1 . 调用java.lang下面Math类中的random()方法产生随机数

            新建一个文件后缀名为java的文件，文件名取为MyRandom,该类中编写如下的代码：

              public class MyRandom {

                      public static void main(String[] args) {

                              int  radom = (int)(Math.random()*10);

                              System.out.println(radom); 

                      }

              }

            其中Math.random() //产生0~1之间的一个随机小数。

            产生一个0~9之间的整数为：(int)(Math.random()*10);

            产生一个1~10之间的整数则可以写着：(int)(Math.random()*10 + 1);

            以此类推：产生一个0~n之间的数就应写作：Math.random()*n;

           取出一个指定长度大小的随机正整数：

           public static int buildRandom(int length) {
                int num = 1;
                double random = Math.random();
                if (random < 0.1) {
                     random = random + 0.1;
                } for (int i = 0; i < length; i++) {
                     num = num * 10;
                }
                return (int) ((random * num));
         }

    2 . 调用java.util下面Random类,此类的实例用于生成伪随机数流，产生一个随机整数，则调用该类的nextInt()方法

          使用Random类之前，则在包下导入java.util.Random ;代码为：

    import java.util.Random;

    public class MyRandom {

         public static void main(String[] args) {

             Random rand = new Random();

            int rInt = rand.nextInt(10);

           System.out.println(rInt);

        }

    }

    其中Random rand = new Random()是创建一个新随机数生成器；rand.nextInt(int n)是从此随机数生成器的序列中取出的、在 0（包括）和指定值n（不包括）之间均匀分布的 int值。

    Java中在指定的整数范围类，循环产生不相同的随机数

    以产生6位20以内不相同的随即整数 为例如下：

    public class MyRandom {

          public static void main(String[] args) {

               int n = 20;

              Random rand = new Random();

              boolean[]  bool = new boolean[n];

              int randInt = 0;

              for(int i = 0; i < 6 ; i++) {

                   do {

                       randInt  = rand.nextInt(n);

                   }while(bool[randInt]);

                  bool[randInt] = true;

                  System.out.println(randInt);

             }

        }

    }

    其中用布尔变量数组来存储是否生成了该数字。生成后，该数字作为布尔数组下表的对应布尔值变成了true，下一次生成该数字就会再次进入do...while循环生成数字直到产生没有生成过的数字。

    例如：生成一个int类型的数组,长度为50的，并向其中随即插入0-50之间的数，并且不能重复。

    代码如下：

    public class MyRandom {

          public static void main(String[] args) {

            int[] intRandom = new int[50];
            List mylist = new ArrayList();  //生成数据集，用来保存随即生成数，并用于判断
            Random rd = new Random();
            while(mylist.size() < 50) {
                int num = rd.nextInt(51);

               /**用集合的contains方法，来判断该数据集中是否包含随即数num，

                * 如果含有返回true。不包含就是false。!表示“非”。

                *!mylist.contains(num))是个布尔值，只有当该值为true时才执行其内部的操作，即为不包含时才执行。

              */
                if(!mylist.contains(num)) {  
                   mylist.add(num);  //往集合里面添加数据。
                }
            }

           /**给数值赋值*/
           for(int i = 0;i <mylist.size();i++) {
                intRandom[i] = (Integer)(mylist.get(i));
           }

        }

    }

     
     
     
     
    阅读(22960)| 评论(2)
    http://gongyanghui1986.blog.163.com/blog/static/137485319201032610240896/
    http://developer.51cto.com/art/200906/128348.htm
     
    ##############################################################

    Java生成随机数的2种示例方法代码

    作者： 字体：[增加 减小] 类型：转载 时间：2013-11-25 我要评论

    在Java中，生成随机数有两种方法。1是使用Random类。2是使用Math类中的random方法。看下面的例子使用吧

    我们现在做个例子，比如生成20个0到10之间的随机数。

    1.使用Random类的nextInt(n)方法，n代表0到n之间，包括0，不包括n

    复制代码代码如下:

    Random random = new Random();
    for(int i=0;i<20;i++)
    {
    　　System.out.println(random.nextInt(10));
    }

    2.使用Math类中的random方法，它生成的随机数是0.0到1.0之间的double。要生成int就需要类型转换

    复制代码代码如下:

    for(int i=0;i<10;i++)
    {
        double n = Math.random();
        n *= 10;
        int m = (int)n;
        System.out.println(m);
    }
     http://www.jb51.net/article/43694.htm
     
     
    ###################################################

    Java产生不重复随机数方法

    2009-06-11 15:16 孙丰伟 百度博客 字号：T | T
    一键收藏，随时查看，分享好友！

    本文讲述了Java生成不重复随机数的两种方法，并给出了其实现的相应的代码。

    AD：51CTO网+ 首届中国APP创新评选大赛火热招募中……

    关于生成Java不重复的随机数：

    1. import java.util.*;  
    2. public class Test...{  
    3.     public static void main(String[] args)...{  
    4.         //生成 [0-n) 个不重复的随机数  
    5.         / st 用来保存这些随机数  
    6.         ArrayList list = new ArrayList();  
    7.           
    8.           
    9.         int n = 10;  
    10.         Random rand = new Random();  
    11.         boolean[] bool = new boolean[n];  
    12.           
    13.         int num =0;  
    14.           
    15.         for (int i = 0; i<n; i++)...{  
    16.               
    17.       
    18.             do...{  
    19.                 //如果产生的数相同继续循环  
    20.                 num = rand.nextInt(n);      
    21.                
    22.             }while(bool[num]);  
    23.               
    24.             bool[num] =true;  
    25.               
    26.             list.add(num);  
    27.           
    28.           
    29.         }  
    30.               
    31.       
    32.         System.out.println (list);      
    33. }          
    34.           
    35.  
    36.  
    37. public class Test  
    38. {  
    39.  
    40.     public static void main(String[] args)  
    41.     {  
    42.         int[] arr = new int[10];  
    43.  
    44.         for (int i = 0; i < 10; i++)  
    45.         {  
    46.             arr[i] = (int) (Math.random() * 40) + 1;  
    47.             for (int j = 0; j < i; j++)  
    48.             {  
    49.                 if (arr[j] == arr[i])  
    50.                 {  
    51.                     i--;  
    52.                     break;  
    53.                 }  
    54.             }  
    55.         }  
    56.         for (int i = 0; i < 10; i++)  
    57.             System.out.print(arr[i] + " ");  
    58.     }  
    59. }  
    60.  
    61.  
    62. b.  
    63.  
    64. Java code  
    65.  
    66.  
    67. import   java.util.*;   
    68. public   class   Test   
    69. {   
    70.           
    71.         public   static   void   main(String[]   args)   
    72.         {   
    73.                 int   n=40;   
    74.                 int[]   num   =   new   int[n];   
    75.                 for(int   i=0;i <num.length;i++)   
    76.                         num[i]   =   i+1;   
    77.                 int[]   arr   =   new   int[10];   
    78.                 for(int   i=0;i <arr.length;i++)   
    79.                 {   
    80.                         int   r   =(int)(Math.random()*n);   
    81.                         arr[i]=num[r];   
    82.                         num[r]=num[n-1];   
    83.                         n--;   
    84.                 }   
    85.                 for(int   i=0;i <arr.length;i++)   
    86.                         System.out.print(arr[i]+"   ");   
    87.         }   
    88. }  
    89.  
    90.  
    91.  
    92. c.  
    93.  
    94. Java code  
    95.  
    96.  
    97. import   java.util.*;   
    98. public   class   Test   
    99. {   
    100.           
    101.         public   static   void   main(String[]   args)   
    102.         {   
    103.                 LinkedList <Integer>   myList=   new   LinkedList <Integer> ();   
    104.                 int   n=40;   
    105.                 for(int   i=0;i <n;i++)   
    106.                         myList.add(i+1);   
    107.                 int[]   arr   =   new   int[10];   
    108.                 for(int   i=0;i <arr.length;i++)   
    109.                 {   
    110.                         arr[i]=myList.remove((int)(Math.random()*n));   
    111.                         n--;   
    112.                 }   
    113.                 for(int   i=0;i <arr.length;i++)   
    114.                 {   
    115.                         System.out.print(arr[i]+"   ");   
    116.                 }   
    117.         }   
    118. }  
    119.  
    120.  
    121.  
    122. d.  
    123.  
    124. Java code  
    125.  
    126.  
    127. import   java.util.*;   
    128. public   class   Test   
    129. {   
    130.           
    131.         public   static   void   main(String[]   args)   
    132.         {   
    133.                 Set <Integer>   mySet   =   new   LinkedHashSet <Integer> ();   
    134.                 while(mySet.size() <10)   
    135.                 {   
    136.                         mySet.add((int)(Math.random()*40+1));   
    137.                 }   
    138.                 for(Integer   i:mySet)   
    139.                 {   
    140.                         System.out.print(i+"   ");   
    141.                 }   
    142.         }   
    143. }  
    144.  


    方法一：
    在一个待选数组中随机产生一个数，然后把他放到待选数组的最后，然后从length-1里随机产生下一个随机数，如此类推

    1. public static int[] randoms()  
    2. {  
    3. Random r = new Random();  
    4.  
    5. int temp1,temp2;  
    6. int send[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21};  
    7. int len = send.length;  
    8. int returnValue[] = new int[22];  
    9. for(int i=0;i<22;i++)  
    10. {  
    11. temp1 = Math.abs(r.nextInt())% len;  
    12. returnValue[i] = send[temp1];  
    13. temp2 = send[temp1];  
    14. send[temp1] = send[len-1];  
    15. send[len-1] = temp2;  
    16. len--;  
    17. }  
    18. return returnValue;  
    19. }  
    20. } 

    方法二：
    还是一个固定的无重复的数组，然后把这个数组随机调换位置，多次之后这个数组就是一个无重复的随机数组了。

    1. public static int[] random2()  
    2. {  
    3.    int send[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21};  
    4.    int temp1,temp2,temp3;  
    5.    Random r = new Random();  
    6.    for(int i=0;i<send.length;i++) //随机交换send.length次  
    7.    {  
    8.     temp1 = Math.abs(r.nextInt())%(send.length-1); //随机产生一个位置  
    9.     temp2 = Math.abs(r.nextInt())%(send.length-1); //随机产生另一个位置  
    10.     if(temp1 != temp2)  
    11.     {  
    12.      temp3 = send[temp1];  
    13.      send[temp1] = send[temp2];  
    14.      send[temp2] = temp3;  
    15.     }  
    16.    }  
    17.    return send;  
    18. }  
      1. http://developer.51cto.com/art/200906/128348.htm
  • 相关阅读:
    六、Linux计划任务及压缩归档
    四、用户管理
    三、vim编辑器详解
    八、RAID磁盘阵列及CentOS7系统启动流程
    五、权限管理
    二、Linux常用命令
    七、Linux磁盘管理及LVM讲解
    一、Linux常用命令
    JS继承的实现方式 原型 原型链 prototype和_proto_的区别
    js引用类型（Object、Array）
  • 原文地址：https://www.cnblogs.com/pengmn/p/5254656.html
Copyright © 2020-2023  润新知