如何生产22位不重复随机数

Question

大家好：    如何生产22位不重复随机数，可以数字字母组合，不能够重复，谢谢！

Answer 1

char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};

String tStr = String.valueOf(System.currentTimeMillis());
System.out.println(tStr);
StringBuilder sb = new StringBuilder();
/*从当前时间的毫秒获取12位数*/
for(int i=1;i<tStr.length();i++)
sb.append(letters[tStr.charAt(i)-'0']);

/*随机生成另外十位，由于前面的12位数不可能重复，所以生成的串是不重复的*/
for(int i=0;i<10;i++)
sb.append(letters[(int) (Math.random()*10)]);
System.out.println(sb.toString());

Answer 2

那把毫秒数全用上吧。 char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};

String tStr = String.valueOf(System.currentTimeMillis());
StringBuilder sb = new StringBuilder();
/*从当前时间的毫秒获取12位数*/
for(int i=0;i<tStr.length();i++)
sb.append(letters[tStr.charAt(i)-'0']);

/*随机生成另外十位，由于前面的12位数不可能重复，所以生成的串是不重复的*/
for(int i=0;i<9;i++)
sb.append(letters[(int) (Math.random()*10)]);
System.out.println(sb.toString());

Answer 3

注释忘了修改。抱歉 char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};

String tStr = String.valueOf(System.currentTimeMillis());
StringBuilder sb = new StringBuilder();
/*从当前时间的毫秒获取13位数*/
for(int i=0;i<tStr.length();i++)
sb.append(letters[tStr.charAt(i)-'0']);

/*随机生成另外九位，由于前面的13位数不可能重复，所以生成的串是不重复的*/
for(int i=0;i<9;i++)
sb.append(letters[(int) (Math.random()*10)]);
System.out.println(sb.toString());

Answer 4

boolean flag=false;
 StringBuilder sb = new StringBuilder();
char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};
for(int i=0;i<22;i++){
     do{
        int temp=(int)(Math.random()*letters.length());
        sb.append(letters[temp]);
     for(int i=0;i<sb.length();i++){
     if(letters[temp]==(sb.charAt(i))){
     flag=true;
     break;
     }
     flag=false;
     }
     }while(flag);
}这样不知道可不可以

Answer 5

boolean flag=false;
 StringBuilder sb = new StringBuilder();
char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};
for(int i=0;i<22;i++){
        do{
               int temp=(int)(Math.random()*letters.length());
               sb.append(letters[temp]);
            for(int i=0;i<sb.length();i++){
                if(letters[temp]==(sb.charAt(i))){
                    flag=true;
                    sb.deletecharAt(i);//如果加进去的是重复的，就删除它
                    break;
                }
                flag=false;
            }
        }while(flag);
}少了一句

Answer 6

大牛就免了，只是你用了时间，在并发环境下是可重复的，1毫秒可以干很多事情了，更不要说服务器往往有多CPU的情况（比如HP的Superdome满配256颗）。
另一个是随机数，随机数理论上本来就不能保证不重复。所以我一楼的问题是问：要求绝对不能重复，还是允许有很小很小可能性的重复。不知道是否集群环境，但建议楼主考虑在GUID的基础上进行精简处理，举例的组合如下（前两个是为了集群）：主机网卡2位尾号 + JVM进程ID + currentTimeMillis + 定长随机数 + 滚动序列号。因为滚动序列号需要加锁以防止重复获取，为了保证并发量，一般会有若干个滚动序列号，由定长随机数选择其中一个来锁定获取并自增。以上组装过程全部应基于数值运算，否则浪费容量，最后BASE64化。
其实即便这样，还是有重复的危险（比如服务器时间被人修改了之类的），不过人为破坏问题一般就不纳入考虑了。

Answer 7

用uuid呢？UUID uuid = UUID.randomUUID();
System.out.println(u);可能会超位、把 “ - ” 截取掉或者随机截取uuid只剩下16位嘞？

Answer 8

初学Java,对这个程序有点不懂，问下
tStr.charAt(i)-'0'
是什么意思？

Answer 9

如果使用锁，这样应该没问题吧？谢谢public class SerGenerator {

private static int dis;
private static Object lock = new Object();
private final static char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};
public static String getSer()
{
String tStr = String.valueOf(System.currentTimeMillis());
StringBuilder sb = new StringBuilder();
/*从当前时间的毫秒获取13位数*/
for(int i=0;i<tStr.length();i++)
sb.append(letters[tStr.charAt(i)-'0']);

/*随机生成另外八位，由于前面的13位数不可能重复，所以生成的串是不重复的*/
for(int i=0;i<8;i++)
sb.append(letters[(int) (Math.random()*10)]);

synchronized(lock)
{
sb.append(dis++);
}
return sb.toString();
} public static void main(String[] args) {

System.out.println(getSer());
}}

Answer 10

刚才疏忽了...献丑了public class SerGenerator {

private static int dis;
private static Object lock = new Object();
private final static char[] letters = {'A', 'C', '1', '2', '3','4', 'a', 'e', 'f', 'z'};
public static String getSer()
{
String tStr = String.valueOf(System.currentTimeMillis());
StringBuilder sb = new StringBuilder();
/*从当前时间的毫秒获取13位数*/
for(int i=0;i<tStr.length();i++)
sb.append(letters[tStr.charAt(i)-'0']);

synchronized(lock)
{
sb.append(get9Str(dis++));
}
return sb.toString();
}
private static String get9Str(int i)
{
StringBuilder sb = new StringBuilder();
sb.append(i);
while(sb.length()!=9)
sb.append(0);
return sb.toString();
}
public static void main(String[] args) {

System.out.println(getSer());
}}

Answer 11

把当前的时间的16位进制当成字符串先进行des编码，再进行Base64编码，然后去掉最后的两个等号
这样的结果刚好是22位。
try {
String time = Long.toHexString(System.currentTimeMillis());
KeyGenerator generator = KeyGenerator.getInstance("DES");
SecretKey key = generator.generateKey();
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] des_byte = cipher.doFinal(time.getBytes());
String final_String = new BASE64Encoder().encode(des_byte);
final_String = final_String.replace("==", "");
System.out.println(final_String);
} catch (Exception e) {
e.printStackTrace();
}

Answer 12

因为BASE64编码和DES编码都是可逆的，而且当前时间是唯一的，所以编码出来的结果应该是不会重复的

Answer 13

    private static String get9Str(int i)
    {
        StringBuilder sb = new StringBuilder();
        sb.append(i);
        while(sb.length()!=9)
            sb.append(0);//不同的CPU使用不同的补足
        return sb.toString();
    }

Answer 14

仅供楼主参考！package com.student.test3;import java.security.SecureRandom;class RandomString
{
private static final String POSSIBLE_CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; public String getRandomString(int length)
{
StringBuffer sbf = new StringBuffer();
SecureRandom random = new SecureRandom();
for (int i = 0; i < length; i++)
{
sbf.append(POSSIBLE_CHARS.charAt(random.nextInt(POSSIBLE_CHARS
.length())));
}
return sbf.toString();
}
}public class Ansewer66
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
System.out.println(new RandomString().getRandomString(22));
// 测试
/*
 * for (int i = 0; i < 2000000; i++) { String s = new
 * RandomString().getRandomString(10); Set<String> check = new
 * HashSet<String>(); if (check.contains(s)) { throw new
 * IllegalStateException("重复字符被发现: " + s); } else {
 * System.out.println("产生第"+(i+1)+"个字符:"+s); check.add(s); } }
 */
}}

Answer 15

呃，重复了，那就装到数组里一个一个比吧，搞个纯数字的试下package com.student.test3;import java.util.Arrays;
import java.util.Random;public class MyRandom
{
 public static void main(String[] args)
      {
         // TODO Auto-generated method stub
         int[] randArray = new int[22];
         int randInt = 0;
         int count = 0;
         boolean flag = false;
         Random rand = new Random();
         while (count < 22)
         {
             randInt = rand.nextInt(100);
             for (int i = 0; i < count; i++)
             {
                 if (randArray[i] == randInt)
                 {
                     flag = true;
                     break;
                 }
                 else
                 {
                     flag = false;
                 }
             }
             if (!flag && randInt != 0)
             {
                 randArray[count++] = randInt;
             }
         }
         System.out.println(Arrays.toString(randArray));
 
     }
 
}

Answer 16

public class test 
{
public static void main(String args[]) throws Exception
{
StringBuffer sb = new StringBuffer();
for(int i = 0;i < 22;i++)
{
sb.append(createRandomChar(sb.toString()));
}
System.out.println(sb.toString());
}
public static char createRandomChar(String str) throws Exception
{
char[] list = {'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','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'};
char c = ' ';
do
{
c = list[new Random().nextInt(list.length)];
}
while(str.indexOf(c) != -1);
return c;
}
}