Java统计n个数字组合在若干组固定长度随机数组中出现的概率
```Java
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
* 统计出n个数字组成的组合在随机个数的固定长度的Integer数组中出现次数最多的组合
*
* @author denghuafeng(it@denghuafeng.com)
*
*/
public class NumComStatistics {

/**
 * 统计出n个数字组成的组合在随机个数的固定长度的Integer数组中出现次数最多的组合
 * 
 * @author denghuafeng(it@denghuafeng.com)
 * 
 * @param n
 * @param intArrs
 */
public static void numComAppearTimesStatistics(int n, Integer[]... intArrs) {
    numComAppearTimesStatistics(n, Arrays.asList(intArrs));
}

/**
 * 统计出n个数字组成的组合在随机个数的固定长度的Integer数组中出现次数最多的组合
 * 
 * @author denghuafeng(it@denghuafeng.com)
 * 
 * @param n
 * @param intArrList
 * @return
 */
public static void numComAppearTimesStatistics(int n, List<Integer[]> intArrList) {
    Map<String, Integer> arrAppearTimes = new LinkedHashMap<String, Integer>();
    String mostKey = "";// 记录出现次数最多组合的key
    Integer mostAppearTimes = null;// 记录最多出现次数
    for (int i = 0; i < intArrList.size(); i++) {
       Integer[] intArr = intArrList.get(i);
       if(intArr.length<n){//如果小于n，则不用统计了
         continue;
       }
       for (int j = 0; j < intArr.length; j++) {
         StringBuffer sb = new StringBuffer();
         // 组成n个数字的组合
         for (int k = 0; k < n; k++) {
          sb.append(intArr[j + k]);
          if (k + 1 != n) {
              sb.append(",");
          }
         }
         String key = sb.toString();// 作为key存入map里
         Integer times = arrAppearTimes.get(key);// 出现的次数
         if (times == null) {
          arrAppearTimes.put(key, 1);
          // 初始
          if (mostKey == "" && mostAppearTimes == null) {
              mostKey = key;
              mostAppearTimes = 1;
          }
         } else {
          times = times.intValue() + 1;
          arrAppearTimes.put(key, times);
          // 如果大于最大出现次数，则记录
          if (times > mostAppearTimes) {
              mostKey = key;
              mostAppearTimes = times;
          }
         }
         // 最后的n-1个数，不足以组成n个数字的组合。
            // 例如n=3，数组长度是7在遍历完下标为4的数后，剩余的数字个数为2，
            // 则不能再遍历，因为剩余的数不足以组成3个数字的组合
         if (j == intArr.length - n) {
          break;
         }
       }
    }
    System.out.println("统计结果=> 出现次数最多的组合：" + mostKey + " 次数：" + mostAppearTimes);
    System.out.println("=================输出每个组合出现的次数=======================");
    // ************以下代码校验用：输出每个组合出现的次数，并比较算出出现次数最多的**********/
    mostKey = "";
    mostAppearTimes = null;
    Iterator<Map.Entry<String, Integer>> iter = arrAppearTimes.entrySet().iterator();
    int i = 1;
    while (iter.hasNext()) {
       Map.Entry<String, Integer> entry = iter.next();
       String key = entry.getKey();
       Integer times = entry.getValue();//出现次数
       if (mostKey != "" && mostAppearTimes != null) {
         // 如果大于最大出现次数，则记录
         if (times.intValue() > mostAppearTimes) {
          mostKey = key;
          mostAppearTimes = times;
         }
       } else {// 初始
         mostKey = key;
         mostAppearTimes = times;
       }
       System.out.println("组合" + i + "：" + key + " 次数：" + times);
       i++;
    }
    System.out.println("===============================================");
    System.out.println("校验结果=> 出现次数最多的组合：" + mostKey + " 次数：" + mostAppearTimes);
}

public static void main(String[] args) throws IOException {
    int n=3;//n个数字组成的组合

    System.out.println("##################手动录入数组######################");
    Integer[] i1 = new Integer[] { 1, 2, 9, 4, 5, 3, 15 };
    Integer[] i2 = new Integer[] { 2, 3, 4, 5, 6, 7, 18 };
    Integer[] i3 = new Integer[] { 3, 4, 5, 6, 7, 8, 12 };
    numComAppearTimesStatistics(n, i1, i2, i3);
    System.out.println();

    System.out.println("##################随机生成数组数字######################");
    List<Integer[]> arrList=new LinkedList<Integer[]>();
    int f = 5;//随机数范围
    int rd = new Random().nextInt(f)+n;//范围数为最小n  最大f
    for(int i=0;i<rd;i++){
       System.out.print("数组"+(i+1)+"：");
       int size = new Random().nextInt(f)+n;//范围数为最小n  最大f
       Integer[] intArr=new Integer[size];
       for(int j=0;j<size;j++){
         intArr[j]= new Random().nextInt(f);
         System.out.print(intArr[j]);
         if(j+1!=size){
          System.out.print(", ");
         }
       }
       arrList.add(intArr);
       System.out.println();
    }
    numComAppearTimesStatistics(n, arrList);
}

}

```

思路：使n个数以"，"号分隔链接在一起组成map的key，再利用map统计每个组合出现的次数，看看这个《Java给定小写字符串，统计并输出每个字符及其所在字符串中的个数》。最多次数计算，用全局变量来记录，第一次初始化，在遍历数组统计个数那块代码进行比较，大的则记录对应的key（即使数字组合）和出现次数。

注意：只记录最多组合中的第一次出现的组合，例如存在3, 4, 5和5, 6, 7 组合的出现次数都为2次，但最先出现的组合是3, 4, 5，则显示最多出现次数的组合是3, 4, 5 次数是2次，用得是LinkedHashMap实现，是有序的。根据需求而定，如果要全部显示出来，可以用string数组来记录最多次数的key。