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~

我的算法方面其实挺弱的，还请各位大牛指点，再优化一下，多谢~~