隨機生成數組游戲

1 隨機生成數組

封裝一個方法generateArray，該方法實現生成指定長度的int數組，該數組的元素為0到指定范圍內的隨機數，並將該數組返回。

參考答案

首先，分析generateArray方法要實現的功能，該方法要求生成指定長度的數組，那么，指定長度要作為方法的參數，用戶調用該方法時，傳入指定的長度即可。另外，該方法還要求數組中的元素為指定范圍的，那么，指定范圍也要作為方法的參數，這樣用戶調用該方法時，傳入這個范圍的值即可。

其次，該方法，要求返回生成后的數組，根據要求我們就可以確定該方法的返回值類型為int[]數組類型。

最后，在實現generateArray方法。在實現該方法的過程中，注意將參數使用到方法中正確位置。

實現此案例需要按照如下步驟進行。

步驟一：定義generateArray方法

首先，定義一個名為ArrayUtil的類，在該類中添加generateArray方法，代碼如下所示：

 

1. public class ArrayUtil {
2.     /**
3.      * 該方法實現生成指定長度的int數組，該數組的元素為指定范圍內的隨機數，並返回該數組
4.      *
5.      * @param length
6.      * 指定數組的長度
7.      * @param max
8.      * 指定范圍的值
9.      * @return 生成的數組
10.      */
11.     public static int[] generateArray(int length, int max) {
12.         
13.     }
14. }

查看上面代碼中定義的generateArray方法，其中，參數length表示要生成的數組的長度，參數max表示隨機生成數組元素的最大范圍。另外，int[]表示數組的返回值類型。

步驟二：設置返回值

在generateArray方法中，定義長度為length的數組。代碼如下：

 

1. public class ArrayUtil {
2.     /**
3.      * 該方法實現生成指定元素數目的數組，該數組的元素為指定范圍內的隨機數，並返回該數組
4.      *
5.      * @param length
6.      * 指定數組的長度
7.      * @param max
8.      * 指定范圍的最大值
9.      * @return 生成的數組
10.      */
11.     public static int[] generateArray(int length, int max) {
12.         // 創建長度為length的數組
13.         int[] arr = new int[length];
16.         // 返回生成的數組
17.         return arr;
18.     }
19. }

在編寫代碼時，定義完成數組后，可以直接寫出return語句，返回數組arr，這樣就除去了開發工具提示的編譯錯誤。

步驟三：數組的賦值

使用 for 語句構建一個 length次的循環，在每次循環中，隨機產生一個 0到max之間的整數，並存入數組。

此案例中，使用 Random 類的 nextInt方法產生隨機數。代碼如下所示：

 

1. import java.util.Random;
3. public class ArrayUtil {
4.     /**
5.      * 該方法實現生成指定元素數目的數組，該數組的元素為指定范圍內的隨機數，並返回該數組
6.      *
7.      * @param length
8.      * 指定數組的長度
9.      * @param max
10.      * 指定范圍的最大值
11.      * @return 生成的數組
12.      */
13.     public static int[] generateArray(int length, int max) {
14.         // 創建長度為length的數組
15.         int[] arr = new int[length];
17.         // 循環生成length個數值，並賦值給數組的元素
18.         Random ran = new Random();
19.         for (int i = 0; i < length; i++) {
20.             arr[i] = ran.nextInt(max);
21.         }
22.         // 返回生成的數組
23.         return arr;
24.     }
25. }

注意：此步驟中，需要導入java.util包下的Random類。

步驟四：調用方法

在main方法中，調用generateArray方法，接收方法的返回的數組，並輸出該數組。代碼如下所示：

 

1. import java.util.Arrays;
2. import java.util.Random;
4. public class ArrayUtil {
5.     /**
6.      * 該方法實現生成指定元素數目的數組，該數組的元素為指定范圍內的隨機數，並返回該數組
7.      *
8.      * @param length
9.      * 指定數組的長度
10.      * @param max
11.      * 指定范圍的最大值
12.      * @return 生成的數組
13.      */
14.     public static int[] generateArray(int length, int max) {
15.         // 創建長度為length的數組
16.         int[] arr = new int[length];
18.         // 循環生成length個數值，並賦值給數組的元素
19.         Random ran = new Random();
20.         for (int i = 0; i < length; i++) {
21.             arr[i] = ran.nextInt(max);
22.         }
23.         // 返回生成的數組
24.         return arr;
25.     }
26.     public static void main(String[] args) {
27.         //調用生成數組的方法
28.         int[] arr=generateArray(6,100);
29.         //輸出生成的數組
30.         System.out.println("生成的數組為："+Arrays.toString(arr));
31.     }
32. }

本案例的完整代碼如下所示：

代碼

2 猜字母游戲——實現游戲等級

為猜字母游戲添加游戲等級。游戲等級設為三等：5、7和9，代表所需要猜測的字母個數。游戲開始時，由玩家選擇游戲等級（5，7，9）。如果選擇7，則會隨機產生7個字符，然后玩家輸入一個字符串包含7個字符，看這7個字符和隨機產生的7個字符比較，看是否正確，並統計分數。另外，如果輸入其它，重新提示輸入游戲等級。系統交互情況如圖-1所示：

圖- 1

參考答案

首先，使用循環，判斷玩家輸入的等級。如果玩家輸入的等級不是5，7，9當中的一個，那么循環一直進行下去。

其次，在循環中，使用Scanner類的nextInt方法，接收控制台輸入的游戲等級。

實現此案例需要按照如下步驟進行。

步驟一：判斷玩家輸入的等級

在課上案例的基礎上，首先，在GuessingGame類的main方法中，使用do-while循環，判斷玩家輸入的等級。循環進行的條件為：玩家輸入的等級不是5，7，9當中的一個，即，當用戶輸入非5，7，9當中一個時，循環繼續；然后，更改generate方法的聲明，傳入等級參數，代碼如下所示：

 

1. import java.util.Scanner;
3. public class GuessingGame {
4.     public static void main(String[] args) {
5.         // 表示玩家猜測的次數
6.         int count = 0;
7.         // 用於保存判斷的結果
8.         int[] result = new int[2];
9.         Scanner scanner = new Scanner(System.in);
10.         System.out.println("GuessingGame>歡迎嘗試猜字母游戲！");
12.         // 表示游戲等級，默認為5
13.         int level = 5;
14.         do {
15.         
16.         } while (level != 5 && level != 7 && level != 9);
18.         // 表示猜測的字符串
19.         char[] chs = generate(level);
20.         System.out.println(chs);
21.         System.out.println("GuessingGame>游戲開始，請輸入你所猜的5個字母序列：（exit——退出）");
22.         while (true) {
23.             String inputStr = scanner.next().trim().toUpperCase();
24.             if ("EXIT".equals(inputStr)) {
25.                 System.out.println("GuessingGame>謝謝你的嘗試，再見！");
26.                 break;
27.             }
29.             char[] input = inputStr.toCharArray();
30.             result = check(chs, input);
31.             if (result[0] == chs.length) {// 完全猜對的情況
32.                 int score = 100 * chs.length - count * 10;
33.                 System.out.println("GuessingGame>恭喜你猜對了！你的得分是：" + score);
34.                 break;
35.             } else {
36.                 count++;
37.                 System.out.println("GuessingGame>你猜對" + result[1] + "個字符，其中"
38.                         + result[0] + "個字符的位置正確！（總次數=" + count + "，exit——退出）");
39.             }
40.         }
41.         scanner.close();
42.     }
44.     /**
45.      * 隨機生成需要猜測的字母序列
46.      *
47.      * @return 存儲隨機字符的數組
48.      */
49.     public static char[] generate(int level) {
51.         char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
52.                 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
53.                 'W', 'X', 'Y', 'Z' };
54.         boolean[] flags = new boolean[letters.length];
55.         char[] chs = new char[level];
56.         for (int i = 0; i < chs.length; i++) {
57.             int index;
58.             do {
59.                 index = (int) (Math.random() * (letters.length));
60.             } while (flags[index]);// 判斷生成的字符是否重復
61.             chs[i] = letters[index];
62.             flags[index] = true;
63.         }
64.         return chs;
65.     }
67.     /**
68.      * 比較玩家輸入的字母序列和程序所生成的字母序列，逐一比較字符及其位置，並記載比較結果
69.      *
70.      * @param chs
71.      * 程序生成的字符序列
72.      * @param input
73.      * 玩家輸入的字符序列
74.      * @return 存儲比較的結果。返回值int數組 的長度為2，其中，索引為0的位置
75.      * 用於存放完全猜對的字母個數(字符和位置均正確)，索引為1的位置用於存放猜對的字母個數(字符正確，但是位置不正確)。
76.      */
77.     public static int[] check(char[] chs, char[] input) {
78.         int[] result = new int[2];
79.         for (int i = 0; i < input.length; i++) {
80.             for (int j = 0; j < chs.length; j++) {
81.                 if (input[i] == chs[j]) {// 判斷字符是否正確
82.                     result[1]++;
83.                     if (i == j) {// 判斷位置是否正確
84.                         result[0]++;
85.                     }
86.                     break;
87.                 }
88.             }
89.         }
90.         return result;
91.     }
92. }

步驟二：接收控制台輸入

在循環中，首先提示玩家輸入游戲等級，然后使用Scanner類的nextInt方法，接收玩家輸入的信息。代碼如下所示：

 

1. import java.util.Scanner;
3. public class GuessingGame {
4.     public static void main(String[] args) {
5.         // 表示玩家猜測的次數
6.         int count = 0;
7.         // 用於保存判斷的結果
8.         int[] result = new int[2];
9.         Scanner scanner = new Scanner(System.in);
10.         System.out.println("GuessingGame>歡迎嘗試猜字母游戲！");
12.         // 表示游戲等級，默認為5
13.         int level = 5;
14.         do {
15.             System.out.print("GuessingGame>請輸入游戲級別（5、7、9）？");
16.             level = scanner.nextInt();
17.         } while (level != 5 && level != 7 && level != 9);
19.         // 表示猜測的字符串
20.         char[] chs = generate(level);
21.         System.out.println(chs);
22.         System.out.println("GuessingGame>游戲開始，請輸入你所猜的5個字母序列：（exit——退出）");
23.         while (true) {
24.             String inputStr = scanner.next().trim().toUpperCase();
25.             if ("EXIT".equals(inputStr)) {
26.                 System.out.println("GuessingGame>謝謝你的嘗試，再見！");
27.                 break;
28.             }
30.             char[] input = inputStr.toCharArray();
31.             result = check(chs, input);
32.             if (result[0] == chs.length) {// 完全猜對的情況
33.                 int score = 100 * chs.length - count * 10;
34.                 System.out.println("GuessingGame>恭喜你猜對了！你的得分是：" + score);
35.                 break;
36.             } else {
37.                 count++;
38.                 System.out.println("GuessingGame>你猜對" + result[1] + "個字符，其中"
39.                         + result[0] + "個字符的位置正確！（總次數=" + count + "，exit——退出）");
40.             }
41.         }
42.         scanner.close();
43.     }
45.     /**
46.      * 隨機生成需要猜測的字母序列
47.      *
48.      * @return 存儲隨機字符的數組
49.      */
50.     public static char[] generate(int level) {
52.         char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
53.                 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
54.                 'W', 'X', 'Y', 'Z' };
55.         boolean[] flags = new boolean[letters.length];
56.         char[] chs = new char[level];
57.         for (int i = 0; i < chs.length; i++) {
58.             int index;
59.             do {
60.                 index = (int) (Math.random() * (letters.length));
61.             } while (flags[index]);// 判斷生成的字符是否重復
62.             chs[i] = letters[index];
63.             flags[index] = true;
64.         }
65.         return chs;
66.     }
68.     /**
69.      * 比較玩家輸入的字母序列和程序所生成的字母序列，逐一比較字符及其位置，並記載比較結果
70.      *
71.      * @param chs
72.      * 程序生成的字符序列
73.      * @param input
74.      * 玩家輸入的字符序列
75.      * @return 存儲比較的結果。返回值int數組 的長度為2，其中，索引為0的位置
76.      * 用於存放完全猜對的字母個數(字符和位置均正確)，索引為1的位置用於存放猜對的字母個數(字符正確，但是位置不正確)。
77.      */
78.     public static int[] check(char[] chs, char[] input) {
79.         int[] result = new int[2];
80.         for (int i = 0; i < input.length; i++) {
81.             for (int j = 0; j < chs.length; j++) {
82.                 if (input[i] == chs[j]) {// 判斷字符是否正確
83.                     result[1]++;
84.                     if (i == j) {// 判斷位置是否正確
85.                         result[0]++;
86.                     }
87.                     break;
88.                 }
89.             }
90.         }
91.         return result;
92.     }
93. }

本案例的完整代碼如下所示：

 

1. import java.util.Scanner;
3. public class GuessingGame {
4.     public static void main(String[] args) {
5.         // 表示玩家猜測的次數
6.         int count = 0;
7.         // 用於保存判斷的結果
8.         int[] result = new int[2];
9.         Scanner scanner = new Scanner(System.in);
10.         System.out.println("GuessingGame>歡迎嘗試猜字母游戲！");
12.         // 表示游戲等級，默認為5
13.         int level = 5;
14.         do {
15.             System.out.print("GuessingGame>請輸入游戲級別（5、7、9）？");
16.             level = scanner.nextInt();
17.         } while (level != 5 && level != 7 && level != 9);
19.         // 表示猜測的字符串
20.         char[] chs = generate(level);
21.         System.out.println(chs);
22.         System.out.println("GuessingGame>游戲開始，請輸入你所猜的5個字母序列：（exit——退出）");
23.         while (true) {
24.             String inputStr = scanner.next().trim().toUpperCase();
25.             if ("EXIT".equals(inputStr)) {
26.                 System.out.println("GuessingGame>謝謝你的嘗試，再見！");
27.                 break;
28.             }
30.             char[] input = inputStr.toCharArray();
31.             result = check(chs, input);
32.             if (result[0] == chs.length) {// 完全猜對的情況
33.                 int score = 100 * chs.length - count * 10;
34.                 System.out.println("GuessingGame>恭喜你猜對了！你的得分是：" + score);
35.                 break;
36.             } else {
37.                 count++;
38.                 System.out.println("GuessingGame>你猜對" + result[1] + "個字符，其中"
39.                         + result[0] + "個字符的位置正確！（總次數=" + count + "，exit——退出）");
40.             }
41.         }
42.         scanner.close();
43.     }
45.     /**
46.      * 隨機生成需要猜測的字母序列
47.      *
48.      * @return 存儲隨機字符的數組
49.      */
50.     public static char[] generate(int level) {
52.         char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
53.                 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
54.                 'W', 'X', 'Y', 'Z' };
55.         boolean[] flags = new boolean[letters.length];
56.         char[] chs = new char[level];
57.         for (int i = 0; i < chs.length; i++) {
58.             int index;
59.             do {
60.                 index = (int) (Math.random() * (letters.length));
61.             } while (flags[index]);// 判斷生成的字符是否重復
62.             chs[i] = letters[index];
63.             flags[index] = true;
64.         }
65.         return chs;
66.     }
68.     /**
69.      * 比較玩家輸入的字母序列和程序所生成的字母序列，逐一比較字符及其位置，並記載比較結果
70.      *
71.      * @param chs
72.      * 程序生成的字符序列
73.      * @param input
74.      * 玩家輸入的字符序列
75.      * @return 存儲比較的結果。返回值int數組 的長度為2，其中，索引為0的位置
76.      * 用於存放完全猜對的字母個數(字符和位置均正確)，索引為1的位置用於存放猜對的字母個數(字符正確，但是位置不正確)。
77.      */
78.     public static int[] check(char[] chs, char[] input) {
79.         int[] result = new int[2];
80.         for (int i = 0; i < input.length; i++) {
81.             for (int j = 0; j < chs.length; j++) {
82.                 if (input[i] == chs[j]) {// 判斷字符是否正確
83.                     result[1]++;
84.                     if (i == j) {// 判斷位置是否正確
85.                         result[0]++;
86.                     }
87.                     break;
88.                 }
89.             }
90.         }
91.         return result;
92.     }
93.