随机生成数组游戏

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.