随机子集的Java实现

package com.lavasoft.randomset; 

import java.util.*; 

/** 
* 数学集合概念上的随机子集的Java实现研究代码 
* 
* @author leizhimin 2010-5-17 13:25:52 
*/ 
public  class RundomSubsetToolkit { 
         public  static  void main(String[] args) { 
//                int[] rs = randomSubset(1, 5000, 300); 
//                for (int r : rs) { 
//                        System.out.println(r); 
//                } 

//                List list = new ArrayList(10); 
//                list.add("a"); 
//                list.add("b"); 
//                list.add("c"); 
//                list.add("d"); 
//                list.add("e"); 
//                list.add("f"); 
//                list.add("g"); 
//                list.add("h"); 
//                list.add("i"); 
//                list.add("j"); 
//                List rs1 = randomSubset(list, 5); 
//                for (Object o : rs1) { 
//                        System.out.println(o); 
//                } 
// 
                 int[] array = {7, 9, 2, 8, 6, 4, 3}; 
                 int[] rs3 = randomSubset(array, 4); 
                 for ( int i : rs3) { 
                        System.out.println(i); 
                } 

                Map map =  new HashMap(); 

        } 

         /** 
         * 获取某个范围内指定个数的随机自然数子集 
         * 
         * @param beginIndex 取之范围起 
         * @param endIndex     取之范围止 
         * @param subCount     子集元素数目 
         * @return 自然数子集 
         */ 
         public  static  int[] randomSubset( final  int beginIndex,  final  int endIndex,  final  int subCount) { 
                 if (beginIndex < 0 || endIndex < 1 || subCount < 0 || endIndex - beginIndex < subCount) { 
                         throw  new RuntimeException( "获取随机子集的参数不合逻辑！"); 
                } 
                 int[] rs =  new  int[subCount]; 
                 int rescount = endIndex - beginIndex + 1; 
                 int[] scope =  new  int[rescount]; 
                 for ( int i = beginIndex; i <= endIndex; i++) 
                        scope[i - beginIndex] = i; 
                Random random =  new Random(); 
                 for ( int i = 0, odd = rescount - 1; i < subCount; i++, odd--) { 
                         int ranindex = random.nextInt(odd); 
                        rs[i] = scope[ranindex]; 
                        scope[ranindex] = scope[odd]; 
                } 
                 return rs; 
        } 

         /** 
         * 获取一个集合列表指定数目的子集 
         * 
         * @param list         集合列表 
         * @param subCount 子集数目 
         * @return 子集 
         */ 
         public  static List randomSubset( final List list,  final  int subCount) { 
                 if (list ==  null || list.size() == 0 || list.size() < subCount) { 
                         throw  new RuntimeException( "获取随机子集的参数不合逻辑！"); 
                } 
                List rs =  new ArrayList(subCount); 
                 for ( int i = 0; i < subCount; i++) { 
                        rs.add( null); 
                } 
                Random random =  new Random(); 
                 for ( int i = 0, odd = list.size() - 1; i < subCount; i++, odd--) { 
                         int ranindex = random.nextInt(odd); 
                        rs.set(i, list.get(ranindex)); 
                        list.set(ranindex, list.get(odd)); 
                } 
                 return rs; 
        } 

         /** 
         * 获取一个long型数组中指定数目的子集 
         * 
         * @param array        数组 
         * @param subCount 子集数目 
         * @return 子集 
         */ 
         public  static  long[] randomSubset( long[] array,  int subCount) { 
                 long[] rs =  new  long[subCount]; 
                 if (array ==  null || array.length == 0 || array.length < subCount) { 
                         throw  new RuntimeException( "获取随机子集的参数不合逻辑！"); 
                } 
                Random random =  new Random(); 
                 for ( int i = 0, odd = array.length - 1; i < subCount; i++, odd--) { 
                         int ranindex = random.nextInt(odd); 
                        rs[i] = array[ranindex]; 
                        array[ranindex] = array[odd]; 
                } 
                 return rs; 
        } 

         /** 
         * 获取一个int型数组中指定数目的子集 
         * 
         * @param array        数组 
         * @param subCount 子集数目 
         * @return 子集 
         */ 
         public  static  int[] randomSubset( int[] array,  int subCount) { 
                 int[] rs =  new  int[subCount]; 
                 if (array ==  null || array.length == 0 || array.length < subCount) { 
                         throw  new RuntimeException( "获取随机子集的参数不合逻辑！"); 
                } 
                Random random =  new Random(); 
                 for ( int i = 0, odd = array.length - 1; i < subCount; i++, odd--) { 
                         int ranindex = random.nextInt(odd); 
                        rs[i] = array[ranindex]; 
                        array[ranindex] = array[odd]; 
                } 
                 return rs; 
        } 

         /** 
         * 获取一个Object型数组中指定数目的子集 
         * 
         * @param array        数组 
         * @param subCount 子集数目 
         * @return 子集 
         */ 
         public  static Object[] randomSubset(Object[] array,  int subCount) { 
                Object[] rs =  new Object[subCount]; 
                 if (array ==  null || array.length == 0 || array.length < subCount) { 
                         throw  new RuntimeException( "获取随机子集的参数不合逻辑！"); 
                } 
                Random random =  new Random(); 
                 for ( int i = 0, odd = array.length - 1; i < subCount; i++, odd--) { 
                         int ranindex = random.nextInt(odd); 
                        rs[i] = array[ranindex]; 
                        array[ranindex] = array[odd]; 
                } 
                 return rs; 
        } 
}