java-生成無重隨機序列-10x速~

最近須要作個無重隨機序列，在網上找了半天，找到一個仍是效率不高，後來我想了算法思路——徹底剩餘系，本身忙裏抽空本身寫了一個。後來發現效率還能夠，特發出來請你們指點一下~

import java.util.ArrayList;
import java.util.Random;

/**
 * 生成一個整型無重隨機序列，無參構造使用數組序列生成，有參構造使用徹底剩餘系定理（效率高，包含生成質數序列）
 * @author Alvinte
 *
 */
public class UniqueRandom {
	int maxValue;
	ArrayList<Integer> prime_num = new ArrayList<Integer>();//質數序列用於查找\判斷質數用
	Random rd = new Random();
	boolean isPrimeModel = false;
	UniqueRandom(){}
	UniqueRandom(int maxValue){
		this.maxValue=maxValue+1;
		createPrimeList();
		isPrimeModel = true;
//		for(Integer pm:prime_num)System.out.print(pm+",");
	}
	private int sqrt(int value){
		return (int)Math.ceil(Math.sqrt(new Integer(value).doubleValue()));
	}

	private void createPrimeList() {
		prime_num.add(2);
		prime_num.add(3);
		if(maxValue<5)return;
		for(int i=5;i<maxValue;i=i+2){
			int sqrt = sqrt(i);
			boolean isPrime = true;
			for(Integer pm:prime_num){
				if(!isPrime||pm>sqrt)break;
				isPrime = i%pm!=0;
			}
			if(isPrime)prime_num.add(i);
		}
	}

	private int primeNumWith(int size){
		while(true){
			int pn = prime_num.get(rd.nextInt(prime_num.size()));//隨機點2
			if(pn<size && size%pn==0)continue;
			return pn;
		}
	}
	
	int[] randomList(int count,int size){
		int[] result = new int[count];
		if(isPrimeModel){
			if(size>=maxValue){
				System.out.println("size Out of range! The maxValue is:"+maxValue);
				return null;
			}
			int rdn_prm_num_for_size = primeNumWith(size);
			int initpos = (size==count)?0:rd.nextInt(size-count);//隨機點1
			for(int i=0;i<count;i++)
				result[i]=(int)((initpos+i)*(long)rdn_prm_num_for_size%size);
		}else{
			return getRandomSequence2(size,count);
		}
		return result;
	}
	
	private int[] getRandomSequence2(int maxNum, int arrSize){
        int[] sequence = new int[maxNum];
        for (int i = 0; i < maxNum; i++)
            sequence[i] = i;
        int[] output = new int[arrSize];
        int end = maxNum-1;
        for (int i = 0; i < arrSize; i++){
            int num = rd.nextInt(end + 1);
            output[i] = sequence[num];
            sequence[num] = sequence[end];
            end--;
        }
        return output;
     }

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int rate = 1000;
		int MAX = 1000*rate;
        int SIZE = 1000*rate;
        int NEED = 1000*rate;
		UniqueRandom ur = new UniqueRandom(MAX);
		long start = System.nanoTime();
		int[] result = ur.randomList(NEED, SIZE);
		System.out.println(System.nanoTime()-start);
//		for(int i:result)System.out.print(i+",");
	}

}

其中整合了在網上找的算法——利用數組，我的感受還不錯，特別一同整合進去了。

我的的算法思路就是利用徹底剩餘系定理。其中生成小於N的質數序列比較費時，建議使用的時候預先初始化一下~質數序列其實用處就是爲了作一個互質的數而已……O(∩_∩)O~

我的算法方面其實挺弱的，還請各位大牛指點，再優化一下，多謝~~