聖思源Java視頻36節練習源碼分享（本身的190+行代碼對比老師的39行代碼）

題目：

 * 隨機生成50個數字（整數），每一個數字範圍是[10,50]，統計每一個數字出現的次數
 * 以及出現次數最多的數字與它的個數，最後將每一個數字及其出現次數打印出來，
 * 若是某個數字出現次數爲0，則不要打印它。打印時按照數字的升序排列。

要求：

 * 使用數組的知識完成此功能，不能使用JDK的API函數。

分析：

 * 須要寫一個隨機數生成函數
 * 須要寫一個冒泡排序函數
 * 須要寫一個二分查找獲取數組中某元素個數的函數

 

代碼以下：

  1 package Array32;
  2 
  3 /**
  4  * 隨機生成50個數字（整數），每一個數字範圍是[10,50]，統計每一個數字出現的次數 以及出現次數最多的數字與它的個數，最後將每一個數字及其出現次數打印出來，
  5  * 若是某個數字出現次數爲0，則不要打印它。打印時按照數字的升序排列。
  6  * 
  7  * @author Administrator
  8  * 
  9  */
 10 public class ArrayHomeTest {
 11 
 12     public static void main(String[] args) {
 13         int[] array = new int[50];
 14         // 生成10,50間的隨機數的數組
 15         for (int i = 0; i < 50; i++) {
 16             array[i] = RandomInt(10, 50);
 17         }
 18 
 19         // 處理前打印數組
 20         System.out.println("當前生成的隨機數組以下：");
 21         PrintArray(array);
 22         System.out.println("-------------------");
 23 
 24         // 爲這個數組排序
 25         BubbleSortX(array);
 26 
 27         // 獲取存儲次數的數組（j - 10默認爲指定數字與序號的一個交叉引用……實際上這樣寫很差，應改善）
 28         int sum[] = new int[41];
 29         for (int j = 10; j <= 50; j++) {// 對比10-50中的元素與array中的元素
 30             sum[j - 10] = binarySearchGetNum(array, j);
 31         }
 32         // 獲取最多的次數（獲取數組中的最大數）
 33         int sumAfterSort[] = BubbleSort(sum);
 34         int maxTimes = sumAfterSort[sumAfterSort.length - 1];// 升序排序後的最大
 35         // 找到最大次數對應的全部數字
 36         System.out.println("出現最多的數字爲有：");
 37         for (int i = 0; i < sum.length; i++) {
 38             if (sum[i] == maxTimes) {
 39                 int num = i + 10;// i + 10默認爲指定數字與序號的一個交叉引用……實際上這樣寫很差，應改善
 40                 System.out.print(num + "|");
 41             }
 42         }
 43         System.out.println();
 44         System.out.println("出現次數爲：" + maxTimes);
 45         System.out.println("-------------------");
 46 
 47         // 打印全部的出現的數字
 48         System.out.println("數字|出現次數");
 49         for (int i = 0; i < sum.length; i++) {
 50             if (sum[i] != 0) {
 51                 System.out.printf("%4s", i + 10);
 52                 System.out.print("|");
 53                 System.out.printf("%8s", sum[i]);
 54                 System.out.println();
 55             }
 56         }
 57     }
 58 
 59     /**
 60      * 生成int隨機數，範圍fromNum-toNum
 61      * 
 62      * @param fromNum
 63      *            開始數字
 64      * @param toNum
 65      *            結束數字
 66      * @return int隨機數
 67      */
 68     public static int RandomInt(int fromNum, int toNum) {
 69         return (int) (Math.random() * (toNum - fromNum) + fromNum);
 70     }
 71 
 72     /**
 73      * 簡單冒泡排序
 74      * 
 75      * @param a
 76      */
 77     public static void BubbleSortX(int[] a) {
 78 
 79         for (int i = 0; i < a.length - 1; i++) {
 80             for (int j = 0; j < a.length - 1 - i; j++) {
 81                 if (a[j] > a[j + 1]) {// 升序
 82                     int temp;
 83                     temp = a[j];
 84                     a[j] = a[j + 1];
 85                     a[j + 1] = temp;
 86                 }
 87             }
 88         }
 89 
 90     }
 91 
 92     /**
 93      * 不影響原數組的狀況下的冒泡排序
 94      * 
 95      * @param a
 96      * @return
 97      */
 98     public static int[] BubbleSort(int[] a) {
 99         int length = a.length;
100         int[] rtnArray = new int[length];
101 
102         // 向rtnArray中賦值，複製一個a
103         for (int i = 0; i < a.length; i++) {
104             rtnArray[i] = a[i];
105         }
106 
107         // 冒泡排序
108         for (int i = 0; i < rtnArray.length - 1; i++) {
109             for (int j = 0; j < rtnArray.length - 1 - i; j++) {
110                 if (rtnArray[j] > rtnArray[j + 1]) {// 升序
111                     int temp;
112                     temp = rtnArray[j];
113                     rtnArray[j] = rtnArray[j + 1];
114                     rtnArray[j + 1] = temp;
115                 }
116             }
117         }
118 
119         return rtnArray;
120     }
121 
122     /**
123      * 二分查找返回個數
124      * 
125      * @param array數組必須有序
126      * @param value
127      * @return 返回個數
128      */
129     public static int binarySearchGetNum(int[] array, int value) {
130         int low = 0;// 待查找的下限
131         int high = array.length - 1;// 待查找的上限
132         int middle = 0;// 上限與下限的中間位置
133 
134         int returnValue = 0;
135 
136         while (low <= high) {
137             middle = (low + high) / 2;
138 
139             if (array[middle] == value) {
140                 returnValue++;// 當中間數與value相等時，計數+1
141 
142                 // 從middle向low的方向移位，判斷low側是否有相等的（由於已經完成排序了）
143                 int tempMiddle = middle;
144                 if (tempMiddle > low) {
145                     while (tempMiddle > low) {
146                         tempMiddle--;
147                         if (array[tempMiddle] == value) {
148                             returnValue++;
149                         } else {// 遇到第一個不一樣的地方跳出
150                             break;
151                         }
152                     }
153                 }
154 
155                 // 從middle向high的方向移位，判斷high側是否有相等的（由於已經完成排序了）
156                 tempMiddle = middle;
157                 if (tempMiddle < high) {
158                     while (tempMiddle < high) {
159                         tempMiddle++;
160                         if (array[tempMiddle] == value) {
161                             returnValue++;
162                         } else {// 遇到第一個不一樣的地方跳出
163                             break;
164                         }
165                     }
166                 }
167                 return returnValue;
168             } else if (value < array[middle]) {
169                 high = middle - 1;
170             } else if (value > array[middle]) {
171                 low = middle + 1;
172             }
173         }
174 
175         return returnValue;
176     }
177 
178     /**
179      * 打印指定數組
180      * 
181      * @param array
182      */
183     public static void PrintArray(int[] array) {
184         if (array == null) {
185             return;
186         }
187         for (int i = 0; i < array.length; i++) {
188             System.out.print(array[i] + " ");
189         }
190         System.out.println();
191     }
192 }

 

返回結果以下：

當前生成的隨機數組以下：
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行代碼秒殺。

 1     public static void TeachersWay(){
 2         int[] count = new int[41];
 3         
 4         Random random = new Random();
 5         
 6         //生成隨機數
 7         for(int i = 0; i < 50; i++){
 8             int number = random.nextInt(41) + 10;//[10, 50]
 9             count[number - 10]++;
10         }
11         
12         //顯示每一個隨機數的出現次數
13         for(int i = 0; i < count.length; i ++){
14             if(0 == count[i]){
15                 continue;
16             }
17             System.out.println((10 + i) + "出現次數：" + count[i]);
18         }
19         
20         int max = count[0];
21         
22         //獲取次數中的最大值
23         for(int i = 0; i < count.length ; i++){
24             if(max < count[i]){
25                 max = count[i];
26             }
27         }
28         
29         System.out.println("出現的最大次數爲：" + max + "次");
30         
31         System.out.println("最大的數有：");
32         
33         //多餘的循環打印出最大的數，實際上能夠與上面的獲取次數最大值合併
34         for(int i = 0; i < count.length; i ++){
35             if(max == count[i]){
36                 System.out.println(i + 10);
37             }
38         }
39     }

返回結果以下：

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的關係，能夠大量簡化代碼。