随机子集的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;
        }
}