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

[careers1111]

大家好：

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

[MiceRice]

3楼的算比较不错了，虽然从逻辑上来说存在重复可能，但应该非常非常非常低了。

另外刚才还少问了一个问题，你是集群环境还是非集群环境？

[cstur4]

额，大牛请问为什么会有重复的情况？[Quote=引用 4 楼 ldh911 的回复:]

3楼的算比较不错了，虽然从逻辑上来说存在重复可能，但应该非常非常非常低了。

另外刚才还少问了一个问题，你是集群环境还是非集群环境？
[/Quote]

[cstur4]

那把毫秒数全用上吧。

		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());

[cstur4]

注释忘了修改。抱歉

		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());

[wangdong20]

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);
}

这样不知道可不可以

[wangdong20]

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);
}

少了一句

[MiceRice]

[Quote=引用 5 楼 cstur4 的回复:]
额，大牛请问为什么会有重复的情况？.
[/Quote]

大牛就免了，只是你用了时间，在并发环境下是可重复的，1毫秒可以干很多事情了，更不要说服务器往往有多CPU的情况（比如HP的Superdome满配256颗）。
另一个是随机数，随机数理论上本来就不能保证不重复。

所以我一楼的问题是问：要求绝对不能重复，还是允许有很小很小可能性的重复。



不知道是否集群环境，但建议楼主考虑在GUID的基础上进行精简处理，举例的组合如下（前两个是为了集群）：主机网卡2位尾号 + JVM进程ID + currentTimeMillis + 定长随机数 + 滚动序列号。因为滚动序列号需要加锁以防止重复获取，为了保证并发量，一般会有若干个滚动序列号，由定长随机数选择其中一个来锁定获取并自增。

以上组装过程全部应基于数值运算，否则浪费容量，最后BASE64化。


其实即便这样，还是有重复的危险（比如服务器时间被人修改了之类的），不过人为破坏问题一般就不纳入考虑了。

[减肥啊啊啊啊啊]

用uuid呢？

UUID uuid = UUID.randomUUID();
System.out.println(u);

可能会超位、把 “ - ” 截取掉

或者随机截取uuid只剩下16位嘞？

[减肥啊啊啊啊啊]

[Quote=引用 11 楼 sd4000784 的回复:]
用uuid呢？


Java code
UUID uuid = UUID.randomUUID();
System.out.println(u);


可能会超位、把 “ - ” 截取掉

或者随机截取uuid只剩下16位嘞？
[/Quote]

误会、是截取剩22位。。。

[wbo112]

[Quote=引用 3 楼 cstur4 的回复:]

Java code


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

String tStr = String.valueOf(System.currentTimeMillis());
System.out.println(tStr);
……
[/Quote]
初学Java,对这个程序有点不懂，问下
tStr.charAt(i)-'0'
是什么意思？

[cstur4]

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

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());
	}

}

[Quote=引用 10 楼 ldh911 的回复:]

引用 5 楼 cstur4 的回复:
额，大牛请问为什么会有重复的情况？.


大牛就免了，只是你用了时间，在并发环境下是可重复的，1毫秒可以干很多事情了，更不要说服务器往往有多CPU的情况（比如HP的Superdome满配256颗）。
另一个是随机数，随机数理论上本来就不能保证不重复。

所以我一楼的问题是问：要求绝对不能重复，还是允许有很小很小可能性的重复。



不知……
[/Quote]

[cstur4]

刚才疏忽了...献丑了

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());
	}

}

[e9876]

把当前的时间的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();
		}

[e9876]

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

[cstur4]

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

[唯一完美的番茄]

搬个板凳抓把瓜子来看下讨论

[xiongyu2006]

仅供楼主参考！

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); } }
		 */
	}

}

[xiongyu2006]

呃，重复了。。。，那就装到数组里一个一个比吧，搞个纯数字的试下

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));
	 
	     }
	 
}

[careers1111]

多谢了，各位！祝工作顺利！

[不关橙猫猫事的哦]

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;
	}
}