* @param object       输入可选元素

* @param m              选取m个数排列

* @param out           输出排列后的元素集

* @return                  输出排列总数

类名：Permutation.java

方法：

getCountByLine(Object[] object, long m)获取无重排列数目

getCountByCircle(Object[] object, int m)获取无重圆周排列数目

getAllPermutation(Object[] in, List<Object[]> out, int index)得到所有排列

    /**
     * 获取无重线排列总数目
     * 描述：从n个元数中选取m个元数进行全排列，得出一共有多少种排法
     * 公式：A(m,n)=m!/(n-m)!
     * 优缺点：输入数据必须互不相同。求阶乘时，使用了for循环，避免了递归方法导致内存溢出的风险。
     * (object数组中元素总数为n，从object数组中选出的m个数排列)
     * @param object    输入可选元素
     * @param m            选取m个数排列
     * @return            输出排列总数
     */
    public static BigInteger getCountByLine(Object[] object, long m) {
        long n = object.length;
        BigInteger result = MathUtils.factorial(n-m+1, n);//计算n-m+1到n的阶乘
        return result;        
    }    
    /**
     * 获取无重圆周排列数目
     * 描述：从n个数中选取m个数进行圆周排列，获取一共有多少种排法
     * 公式：Q(m,n)=A(m,n)/m=m!/(m*(n-m)!)
     * 优缺点：输入数据必须互不相同。m定义了int类型，限制了计算范围。
     * (object数组中元素总数为n，从object数组中选出的m个数圆周排列)
     * @param object    输入可选元素
     * @param m            选取m个数排列
     * @return            输出排列总数
     */
    public static BigInteger getCountByCircle(Object[] object, int m) {
        int n = object.length;
        BigInteger result = MathUtils.factorial(n-m+1, n).divide(BigInteger.valueOf(m));//计算n-m+1到n的阶乘除以m
        return result;
    }
    /**
     * 全排列（递归）
     * 例：输入{1,2,3}输出{1,2,3}{1,3,2}{2,1,3}{2,3,1}{3,1,2}{3,2,1}
     * 描述：输入一个数组，对数组中的所有元素进行全排列，把每种排列放入out集合中。
     * 优缺点：输入数据必须互不相同。使用了递归的算法，当输入数据比较大时，会存在内存溢出的危险。
     * @param in    输入数据
     * @param out    输出数据
     * @param index 默认为0
     */
    public static void getAllPermutation(Object[] in, List<Object[]> out, int index) {
        if(index == in.length-1) {
            Object[] outTemp = in.clone();
            out.add(outTemp);
        }
        for(int i=index; i<in.length; i++) {
            swap(in,index,i);
            getAllPermutation(in,out,index+1);//递归
            swap(in,index,i);
        }
    }
    /**
     * 获取所有排列
     * 例：输入{1,2,3}输出{1}{2}{3}{1,2}{2,1}{1,3}{3,1}{2,3}{3,2}{1,2,3}……
     * 描述：输入一个数组，先从数组中选取一个数全排列，再选取两个两个数全排列，再选取三个数全排列，把所有的得到的排列放入out集合中。
     * 优缺点：输入元素必须互不相同。
     * @param in    输入数据
     * @param out    输出数据
     */
    public static void getSelectPermutaion(Object[] in, List<Object[]> out) {
        List<Object[]> outTemp = new ArrayList<Object[]>();
        for(int i=0; i<in.length; i++) {
            Combination.getCombination(in, outTemp, i+1);//获取所有组合
        }
        for(int i=0; i<outTemp.size(); i++) {
            getAllPermutation(outTemp.get(i), out, 0);//对每种组合进行全排列
        }
    }
    /**
     * 交换下标为i,j两个元素
     * 描述：对object数组的i,j位置的元素进行交换
     * @param object
     * @param i
     * @param j
     */
    public static void swap(Object[] object, int i, int j) {
        Object temp = object[i];
        object[i] = object[j];
        object[j] = temp;
    }

* @param in          输入可选元素

* @param m              选取m个数排列

* @param out           输出组合后的元素集

* @return                  返回组合后的数目

类名：Combination.java

方法：

getCount(Object[] in, long m)获取组合数

getCombination(Object[] in, List<Object[]> out, int m)获取组合后的所有情况

    /**
     * 获取无重组合数目
     * 描述：从n个数中选取m个元素组成一组，得到一共有多少种不同的组合
     * 公式：C(m,n)=n!/(m!*(n-m)!)
     * @param in    输入可选元素
     * @param m        每次选m个
     * @return        返回组合后的总数目
     */
    public static BigInteger getCount(Object[] in, long m) {
        long n = in.length;
        BigInteger result = BigInteger.valueOf(1);
        if(m<2/n) {//增加计算效率
            result = MathUtils.factorial(n-m+1, n).divide(MathUtils.factorial(1, m));//计算公式
        } else {
            result = MathUtils.factorial(m+1, n).divide(MathUtils.factorial(1, n-m));//计算公式
        }
        return result;
    }
    /**
     * 组合（二进制法）
     * 例：输入{1,2,3}从中选2个的数组合。输出：{1,2}{1,3}{2,3}
     * 描述：从输入的元素中，选m个元素组合，把所有的组合存在out中
     * @param in    输入数组
     * @param out    输出组合后的数组集
     * @param m        取出m个数
     */
    public static void getCombination(Object[] in, List<Object[]> out, int m) {
        int n = in.length;
        int[] array = new int[n];
        for(int i=0; i<n; i++) {//初始化
            if(i<m) 
                array[i] = 1;
            else 
                array[i] = 0;            
        }
        List<int[]> list = new ArrayList<int[]>();
        boolean flag = true;
        while(flag) {
            int[] intTemp = array.clone();
            list.add(intTemp);
            for(int i=0; i<n-1; i++) {
                if(array[i]==1 && array[i+1]==0) {
                    array[i]=0;//交换i，i+1的值
                    array[i+1]=1;
                    if(array[0]==0) {//把i位置左边的1都移到最左边
                        for(int k=0,j=0;k<i;k++) {
                            if(array[k]==1) {
                                array[j]=1;
                                array[k]=0;
                                j++;
                            }
                        }
                    }
                    break;
                }
                if(i==n-2) flag = false;
            }
        }
        for(int i=0; i<list.size(); i++) {//把二进制中的1转换成对应的数组
            Object[] objTemp = new Object[m];
            for(int j=0,k=0;j<n;j++) {
                if(list.get(i)[j]==1) {
                    objTemp[k] = in[j];
                    k++;
                }
            }
            out.add(objTemp);
        }
    }