圣思源Java视频36节练习源码分享（自己的190+行代码对比老师的39行代码）

题目：

* 随机生成50个数字（整数），每个数字范围是[10,50]，统计每个数字出现的次数
 * 以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，
 * 如果某个数字出现次数为0，则不要打印它。打印时按照数字的升序排列。

要求：

* 使用数组的知识完成此功能，不能使用JDK的API函数。

分析：

* 需要写一个随机数生成函数
 * 需要写一个冒泡排序函数
 * 需要写一个二分查找获取数组中某元素个数的函数

代码如下：

 package Array32;

 /**
  * 随机生成50个数字（整数），每个数字范围是[10,50]，统计每个数字出现的次数 以及出现次数最多的数字与它的个数，最后将每个数字及其出现次数打印出来，
  * 如果某个数字出现次数为0，则不要打印它。打印时按照数字的升序排列。
  *
  * @author Administrator
  *
  */
 public class ArrayHomeTest {

     public static void main(String[] args) {
         int[] array = new int[50];
         // 生成10,50间的随机数的数组
         for (int i = 0; i < 50; i++) {
             array[i] = RandomInt(10, 50);
         }

         // 处理前打印数组
         System.out.println("当前生成的随机数组如下：");
         PrintArray(array);
         System.out.println("-------------------");

         // 为这个数组排序
         BubbleSortX(array);

         // 获取存储次数的数组（j - 10默认为指定数字与序号的一个交叉引用……实际上这样写不好，应改善）
         int sum[] = new int[41];
         for (int j = 10; j <= 50; j++) {// 对比10-50中的元素与array中的元素
             sum[j - 10] = binarySearchGetNum(array, j);
         }
         // 获取最多的次数（获取数组中的最大数）
         int sumAfterSort[] = BubbleSort(sum);
         int maxTimes = sumAfterSort[sumAfterSort.length - 1];// 升序排序后的最大
         // 找到最大次数对应的所有数字
         System.out.println("出现最多的数字为有：");
         for (int i = 0; i < sum.length; i++) {
             if (sum[i] == maxTimes) {
                 int num = i + 10;// i + 10默认为指定数字与序号的一个交叉引用……实际上这样写不好，应改善
                 System.out.print(num + "|");
             }
         }
         System.out.println();
         System.out.println("出现次数为：" + maxTimes);
         System.out.println("-------------------");

         // 打印所有的出现的数字
         System.out.println("数字|出现次数");
         for (int i = 0; i < sum.length; i++) {
             if (sum[i] != 0) {
                 System.out.printf("%4s", i + 10);
                 System.out.print("|");
                 System.out.printf("%8s", sum[i]);
                 System.out.println();
             }
         }
     }

     /**
      * 生成int随机数，范围fromNum-toNum
      *
      * @param fromNum
      *            开始数字
      * @param toNum
      *            结束数字
      * @return int随机数
      */
     public static int RandomInt(int fromNum, int toNum) {
         return (int) (Math.random() * (toNum - fromNum) + fromNum);
     }

     /**
      * 简单冒泡排序
      *
      * @param a
      */
     public static void BubbleSortX(int[] a) {

         for (int i = 0; i < a.length - 1; i++) {
             for (int j = 0; j < a.length - 1 - i; j++) {
                 if (a[j] > a[j + 1]) {// 升序
                     int temp;
                     temp = a[j];
                     a[j] = a[j + 1];
                     a[j + 1] = temp;
                 }
             }
         }

     }

     /**
      * 不影响原数组的情况下的冒泡排序
      *
      * @param a
      * @return
      */
     public static int[] BubbleSort(int[] a) {
         int length = a.length;
         int[] rtnArray = new int[length];

         // 向rtnArray中赋值，复制一个a
         for (int i = 0; i < a.length; i++) {
             rtnArray[i] = a[i];
         }

         // 冒泡排序
         for (int i = 0; i < rtnArray.length - 1; i++) {
             for (int j = 0; j < rtnArray.length - 1 - i; j++) {
                 if (rtnArray[j] > rtnArray[j + 1]) {// 升序
                     int temp;
                     temp = rtnArray[j];
                     rtnArray[j] = rtnArray[j + 1];
                     rtnArray[j + 1] = temp;
                 }
             }
         }

         return rtnArray;
     }

     /**
      * 二分查找返回个数
      *
      * @param array数组必须有序
      * @param value
      * @return 返回个数
      */
     public static int binarySearchGetNum(int[] array, int value) {
         int low = 0;// 待查找的下限
         int high = array.length - 1;// 待查找的上限
         int middle = 0;// 上限与下限的中间位置

         int returnValue = 0;

         while (low <= high) {
             middle = (low + high) / 2;

             if (array[middle] == value) {
                 returnValue++;// 当中间数与value相等时，计数+1

                 // 从middle向low的方向移位，判断low侧是否有相等的（因为已经完成排序了）
                 int tempMiddle = middle;
                 if (tempMiddle > low) {
                     while (tempMiddle > low) {
                         tempMiddle--;
                         if (array[tempMiddle] == value) {
                             returnValue++;
                         } else {// 遇到第一个不同的地方跳出
                             break;
                         }
                     }
                 }

                 // 从middle向high的方向移位，判断high侧是否有相等的（因为已经完成排序了）
                 tempMiddle = middle;
                 if (tempMiddle < high) {
                     while (tempMiddle < high) {
                         tempMiddle++;
                         if (array[tempMiddle] == value) {
                             returnValue++;
                         } else {// 遇到第一个不同的地方跳出
                             break;
                         }
                     }
                 }
                 return returnValue;
             } else if (value < array[middle]) {
                 high = middle - 1;
             } else if (value > array[middle]) {
                 low = middle + 1;
             }
         }

         return returnValue;
     }

     /**
      * 打印指定数组
      *
      * @param array
      */
     public static void PrintArray(int[] array) {
         if (array == null) {
             return;
         }
         for (int i = 0; i < array.length; i++) {
             System.out.print(array[i] + " ");
         }
         System.out.println();
     }
 }

返回结果如下：

当前生成的随机数组如下：
44 43 36 37 36 26 31 42 45 19 11 24 33 43 28 33 35 48 20 35 35 49 45 48 45 18 34 46 47 12 41 31 10 19 15 21 20 44 16 17 14 31 29 19 43 29 32 21 39 44
-------------------
出现最多的数字为有：
19|31|35|43|44|45|
出现次数为：3
-------------------
数字|出现次数
  10|       1
  11|       1
  12|       1
  14|       1
  15|       1
  16|       1
  17|       1
  18|       1
  19|       3
  20|       2
  21|       2
  24|       1
  26|       1
  28|       1
  29|       2
  31|       3
  32|       1
  33|       2
  34|       1
  35|       3
  36|       2
  37|       1
  39|       1
  41|       1
  42|       1
  43|       3
  44|       3
  45|       3
  46|       1
  47|       1
  48|       2
  49|       1

结语：

这是自己在从C#转Java中遇到第一个手工编写的Java程序练习，主要用到了数组的知识，数据结构的知识，此外需要对于Java中的引用类型和原生数据类型的传值有一定的认识。

代码本身还不是很完善啦，如常量定义，循环的简化处理等，可以做为一个参考，其中的二分查找、冒泡排序函数都可以改进以及override出更加强大的函数。

仅作为抛砖引玉，还没有深入考虑代码的优化，老师的代码我也还没看，估计比我写的好看的多。

2015-4-8 0:15:33

补充视频中老师的方法，39行代码秒杀。

     public static void TeachersWay(){
         int[] count = new int[41];

         Random random = new Random();

         //生成随机数
         for(int i = 0; i < 50; i++){
             int number = random.nextInt(41) + 10;//[10, 50]
             count[number - 10]++;
         }

         //显示每个随机数的出现次数
         for(int i = 0; i < count.length; i ++){
             if(0 == count[i]){
                 continue;
             }
             System.out.println((10 + i) + "出现次数：" + count[i]);
         }

         int max = count[0];

         //获取次数中的最大值
         for(int i = 0; i < count.length ; i++){
             if(max < count[i]){
                 max = count[i];
             }
         }

         System.out.println("出现的最大次数为：" + max + "次");

         System.out.println("最大的数有：");

         //多余的循环打印出最大的数，实际上可以与上面的获取次数最大值合并
         for(int i = 0; i < count.length; i ++){
             if(max == count[i]){
                 System.out.println(i + 10);
             }
         }
     }

返回结果如下：

10出现次数：2
11出现次数：2
12出现次数：1
14出现次数：4
15出现次数：2
16出现次数：1
18出现次数：2
19出现次数：1
20出现次数：2
22出现次数：3
23出现次数：1
24出现次数：3
26出现次数：3
27出现次数：1
28出现次数：1
29出现次数：3
30出现次数：1
32出现次数：1
34出现次数：2
35出现次数：1
37出现次数：1
38出现次数：1
40出现次数：1
42出现次数：1
44出现次数：1
45出现次数：2
48出现次数：4
50出现次数：2
出现的最大次数为：4次
最大的数有：
14
48

第二次总结：

对于比较大小的方法有些遗忘了，实际上老师这个方法才是比较大小的好方法。排序再去取最大值，效率上有所降低的。

整体思路上还需要改进，利用序号0~40与实际范围10~50之间差10的关系，可以大量简化代码。