JAVA基础

Java语言基础 Day04

Top

1. 水仙花数问题 2. 猜字母游戏

3. 质数问题（选做）

4. 随机加法运算器（选做） 5. 成绩统计程序 6. 费氏数列问题

1 水仙花数问题

1.1 问题

计算某个范围内所有水仙花数。用户输入0到某个范围的数，系统输出这个范围内的所有水仙花数，水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。(例如:1^3 + 5^3 + 3^3 = 153)。系统交互情况如图-36所示：

图-36

1.2 方案

系统使用双层for循环判断某个数是否为水仙花数，外层循环确保每个用户输入的范围内的数都判断到，里层循环判断某个数是否为水仙花 数，m取到个位数，例如：int m=153，经过int v=m计算后v=3；m /= 10去除各位数，例如：int m=153,经过m /= 10计算后m=15。代码如下所示： 1. 2. 3. 4. 5. 6.

for (int n = 1; n <= max; n++) { // 判断n是否为水仙花数 int sum = 0;

for (int m = n; m > 0; m /= 10) { int v = m % 10; sum += v * v * v;

7. 8. 9. } }

如果n和sum相等，那么说明n是水仙花数。代码如下所示： 1. 2. 3.

if (n == sum) {

System.out.print(n + \}

1.3 实现

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 隐藏

import java.util.Scanner; public class Daffodils {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print(\请输入查找水仙花的范围：0~\ int max = scanner.nextInt(); scanner.close();

for (int n = 1; n <= max; n++) { // 判断n是否为水仙花数 int sum = 0;

for (int m = n; m > 0; m /= 10) { int v = m % 10; sum += v * v * v; }

if (n == sum) {

System.out.print(n + \ } } } }

1.4 扩展(选做)

计算“百钱买百鸡”的问题。

百钱买百鸡：公鸡5文钱一只，母鸡3文钱一只，小鸡1文钱3只，如何用百文钱买百只鸡？

系统交互情况如图-37所示：

图-37

1. public class DaffodilsExt {

2. public static void main(String[] args) { 3. int cock, hen, chick;

4. System.out.println(\百钱买百鸡的方案如下：\5. for (cock = 0; cock <= 20; cock++) { 6. for (hen = 0; hen <= 33; hen++) { 7. chick = 100 - cock - hen; 8. if (chick % 3 == 0) {

9. int total = cock * 5 + hen * 3 + chick / 3; 10. if (total == 100) {

11. System.out.println(\公鸡：\+ cock + \母鸡：\

12. + hen + \小鸡：\13. } 14. } 15. } 16. } 17. } 18. } 隐藏

2 猜字母游戏

2.1 问题

猜字母游戏。系统随机产生5个按照一定顺序排列的字符，然后由用户输入一个5个字符的字符串，由程序判断这五个字符和系统所产生的5个字符 是否相同（字母和位置均相同）。如果相同，则程序结束，并计算得分；如果不相同，则输出比较结果以提示用户继续游戏。系统交互情况如图-48所示：

图-48

由图－48可以看出，程序每次比较用户所录入的字符时，会提示5个字符中正确的字符个数，以及位置正确的个数作为提示，以便于用户判断。

游戏的得分规则为：字符的个数乘以100为总分，即此游戏的总分为 500 分。用户如果第一次就猜对，则得满分（500分）；每多猜测一次，则扣10分。

2.2 方案

定义一个 5 个长度的字符数组用于存储系统所产生的5个字符，并定义变量记载用户所猜测的次数。代码如下： 1. 2. 3.

int level = 5;

char[] chs = new char[level]; int score = 0;

定义一个数组letters存放所有字符，定义一个boolean类型的数组大小和letters数组大小相同，用来标识letters数组中的元素是否被选中，代码如下： 1.

char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',

'J',

2. 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',

3. 'W', 'X', 'Y', 'Z' };

4. boolean[] flags = new boolean[letters.length];

根据所需要产生的字符个数（5个）随机产生字符数组，且字符不能重复。代码如下： 1. 2.

for (int i = 0; i < chs.length; i++) { int index;

3. 4. 5. 6. 7. 8. do {

index = RandomUtils.nextInt(letters.length); } while (flags[index]); chs[i] = letters[index]; flags[index] = true; }

然后，提示用户录入5个字符后，并转换为字符数组，代码如下： 1. 2.

String inputStr = scanner.next().trim().toUpperCase(); char[] input = inputStr.toCharArray();

判断用户的录入的正确性（需要同时判断字符和位置的正确性），代码如下： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14.

int[] result = new int[2];

// result[0]: 存储正确的位置个数 // result[1]: 存储正确的字符个数

for (int i = 0; i < input.length; i++) { for (int j = 0; j < chs.length; j++) { if (input[i] == chs[j]) { result[1]++; if (i == j) { result[0]++; }

break; } } }

判断完毕后，需要输出提示信息到界面，并需要计算分数。如果5个字符的位置均正确，则表示游戏结束，计算并输出用户的得分；否则，将猜测的次数累加1 ，并提示用户所猜对的字符个数以及位置个数，游戏继续。代码如下： 1. 2. 3.

if (result[0] == level) {

score = 100 * level - score * 10;

System.out.println(\恭喜你猜对了！你的得分是：\4. break; 5. } else { 6. score++;

7. System.out.println(\你猜对\个字符，其中\result[0] + \个字符的位置正确！（总次数=\+ score + \，exit——退出）\8. }

2.3 实现

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8.

import java.util.Arrays; import java.util.Scanner;

import org.apache.commons.lang.math.RandomUtils;

public class GuessingGame {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println(\欢迎尝试猜字母游戏！\9.

10. int level = 5; 11. int score = 0;

12. char[] chs = new char[level]; 13. //产生5个长度的字符数组 14. generate(chs);

15. System.out.println(\游戏开始，请输入你所猜的5个字母序列：（exit——退出）\16. while (true) {

17. String inputStr =

scanner.next().trim().toUpperCase();

18. if (\

19. System.out.println(\谢谢你的尝试，再见！\

20. break; 21. }

22. //比较

23. char[] input = inputStr.toCharArray(); 24. int[] result = check(chs, input); 25. if (result[0] == level) {

26. score = 100 * level - score * 10;

27. System.out.println(\恭喜你猜对了！你的得分是：\28. break; 29. } else {

30. System.out.println(\你猜对\result[1] + \个字符，其中\个字符的位置正确！（总次数=\，exit——退出）\31. score++; 32. }

33. } 34.

35. scanner.close(); 36. } 37.

38. public static void generate(char[] chs) { 39. char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };

40. boolean[] flags = new boolean[letters.length]; 41. for (int i = 0; i < chs.length; i++) { 42. int index; 43. do {

44. index = RandomUtils.nextInt(letters.length); 45. } while (flags[index]); 46. chs[i] = letters[index]; 47. flags[index] = true; 48. } 49. } 50.

51. public static int[] check(char[] chs, char[] input) { 52. int[] result = new int[2];

53. // result[0]: 54. // result[1]: 55. for (int i = 0; i < input.length; i++) { 56. for (int j = 0; j < chs.length; j++) { 57. if (input[i] == chs[j]) { 58. result[1]++; 59. if (i == j) { 60. result[0]++; 61. }

62. break; 63. } 64. } 65. }

66. return result; 67. } 68. } 隐藏

2.4 扩展

存储正确的位置个数 存储正确的字符个数

为猜字母游戏添加游戏等级。游戏等级设为3等：5、7和9，代表所需要猜测的字母个数。游戏开始时，由用户选择游戏等级（5，7，9）。如 果选择9，则会随机产生9个字符，然后用户输入一个字符串包含9个字符，看这9个字符和随机产生的9个字符比较，看是否正确，并统计分数。系统交互情况如 图-49所示：

图-49

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8.

import java.util.Arrays; import java.util.Scanner;

import org.apache.commons.lang.math.RandomUtils;

public class GuessingGame {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println(\欢迎尝试猜字母游戏！\

9. String levelStr; 10. do {

11. System.out.print(\请输入游戏级别（5、7、9）？\

12. levelStr = scanner.next().trim();

13. } while (!\&& !\14. && !\15.

16. int level = Integer.parseInt(levelStr); 17.

18. int score = 0; 19.

20. char[] chs = new char[level]; 21. generate(chs);

22. System.out.println(\游戏开始，请输入你所猜的\

23. + \个字母序列：（exit——退出）\

24. while (true) {

25. String inputStr =

scanner.next().trim().toUpperCase();

26. if (\

27. System.out.println(\谢谢你的尝试，再见！\

28. break; 29. } 30.

31. char[] input = inputStr.toCharArray(); 32. int[] result = check(chs, input); 33. if (result[0] == level) {

34. score = 100 * level - score * 10;

35. System.out.println(\恭喜你猜对了！你的得分是：\36. break; 37. } else {

38. System.out.println(\你猜对\result[1] + \个字符，其中\

39. + result[0] + \个字符的位置正确！（总次数=\，exit——退出）\40. score++; 41. } 42. } 43.

44. scanner.close(); 45. } 46.

47. public static void generate(char[] chs) { 48. char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };

49. boolean[] flags = new boolean[letters.length]; 50. for (int i = 0; i < chs.length; i++) { 51. int index; 52. do {

53. index = RandomUtils.nextInt(letters.length); 54. } while (flags[index]); 55. chs[i] = letters[index]; 56. flags[index] = true; 57. } 58. } 59.

60. public static int[] check(char[] chs, char[] input) {

61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 隐藏

int[] result = new int[2];

// result[0]: 存储正确的位置个数 // result[1]: 存储正确的字符个数

for (int i = 0; i < input.length; i++) { for (int j = 0; j < chs.length; j++) { if (input[i] == chs[j]) { result[1]++; if (i == j) { result[0]++; }

break; } } }

return result; } }

3 质数问题（选做）

3.1 问题

求某个范围内所有质数和质数的个数。用户输入2到某个范围的，系统输出这个范围内的所有质数和质数的个数， 质数是指只有1和它本身两个约数的数。控制台输出情况如图-38所示：

图-38

3.2 方案

系统使用双层for循环判断某个数是否为水质数，外层循环确保每个用户输入的范围内的数都判断到，代码如下所示：

1. for (int n = 2; n <= max; n++) {}

里层循环判断某个数是否为质数。判断数n是否为质数，让n除以2到n的平方根之间的每一个数，如果n能被2到n(n大于2)的平方根之间的 某个数整除，则说明n不是素数，否则n一定是素数。如果一个数不是素数，它一定能找到两个数化成乘积，如果其中一个大于平方根，那么必定能找到一个小于平 方根的数和它成对，例如81的平方根是9，那只需要从2试到9就可以了，因为超过平方根的结果会比平方根小。代码如下所示： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.

int m = (int) Math.sqrt(n); int i = 2;

for (; i <= m; i++) { if (n % i == 0) break; }

if (i > m) {

System.out.print(n + \ if (++numOfPrime % 10 == 0) System.out.println(); }

3.3 实现

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.

import java.util.Scanner; public class PrimeNumber {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in); System.out.print(\请输入查找质数的范围：2~\ int max = scanner.nextInt(); scanner.close(); int numOfPrime = 0;

for (int n = 2; n <= max; n++) { // 判断n是否是质数

int m = (int) Math.sqrt(n); int i = 2;

for (; i <= m; i++) { if (n % i == 0) break; }

if (i > m) {

System.out.print(n + \ if (++numOfPrime % 10 == 0)

20. 21. 22. 23. 24. 25. 隐藏

System.out.println(); } }

System.out.println(\共有\个质数\ } }

3.4 扩展

求两个整数的最大公约数。由用户输入2个正整数，系统求出这两个正整数的最大公约数，并输出。

注：最大公约数，指某几个整数共有因子中最大的一个。 如果一个数既是数A的约数，又是数B的约数，称为A,B的公约数；而A,B的公约数中最大的一个（可以包括AB自身）称为AB的最大公约数。 系统交互过程如图-39所示：

图-39

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.

import java.util.Scanner; public class CommonDivisor {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in); System.out.println(\请输入第一个整数：\ int first = scanner.nextInt();

System.out.println(\请输入第二个整数：\ int second = scanner.nextInt(); scanner.close();

// 从两个整数中较小的数开始

int start = first > second ? second : first;

13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 隐藏

int n = 1;

for (n = start; n >= 1; n--) { // 判断n是否是两个整数的约数

if ((first % n == 0) && (second % n == 0)) break; }

System.out.println(first + \和\ + \的最大公约数为：\ } }

4 随机加法运算器（选做）

4.1 问题

随机加法运算器。系统提示用户输入“Y”或是“Q”，输入Y表示开始测试，输入Q表示退出系统；系统随机出题，最多10道题，题目为两个 100以内的随机数的和，用户输入这两个数的和，系统根据用户输入的和值，系统判断用户计算的是否正确，正确输出“Correct!”，错误系统输出 “Error”，最后计算用户做题的得分输出到控制台。系统交互情况如图-40所示：

图-40

4.2 方案

系统使用while（true）使程序一直循环，当遇到break程序规程循环，代码如下： 1.

while (true) {}

系统使用String类的trim（）方法，去除用户输入字符串两端的空白，使用String类的equalsIgnoreCase（）方法，比较两个字符串内容是否相等，忽略大小写。代码如下所示： 1. 2. 3. 4. 5. 6. 7.

String c = scanner.next();

if (\ break; }

if (!\ continue; }

系统使用Random的nextInt（）方法生成100以内的随机数，代码如下所示： 1. 2.

Random ran = new Random(); a = ran.nextInt(100);

系统使用for循环产生10道题目,代码如下所示： 1.

for (int i = 1; i <= numOfQuestion; i++) {}

4.3 实现

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.

import java.util.Scanner; import java.util.Random; public class AdditionTest {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in); while (true) {

System.out.print(\输入Y开始测验，输入Q退出: \ String c = scanner.next();

if (\ break; }

12. if (!\13. continue; 14. }

15. int score = 0;

16. int numOfQuestion = 10; 17. Random ran = new Random(); 18. int a, b, answer, key;

19. for (int i = 1; i <= numOfQuestion; i++) { 20. a = ran.nextInt(100); 21. b = ran.nextInt(100); 22. key = a + b;

23. System.out.print(\b + \

24. answer = scanner.nextInt(); 25. if (answer == key) {

26. score += 100 / numOfQuestion; 27. System.out.println(\28. } else {

29. System.out.println(\30. } 31. }

32. System.out.println(\此次测验结束，你的分数是：\score); 33. }

34. scanner.close(); 35. } 36. } 隐藏

4.4 扩展

猜数字游戏。

用户录入一个大于1 的正整数，然后由系统随机抽取一个从1到此整数范围内的数值作为需要猜测的数字，然后提示用户猜测此数值。用户录入某数值后，系统判断是否猜测正确：如果 录入的数值比答案数值大，则输出“大了”，并提示用户继续猜；如果录入的数值比答案数值小，则输出“小了”，并提示用户继续猜。直到录入的数值等于答案， 则输出所猜中的数字，并结束游戏。 系统交互情况如图-41所示：

图-41

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7. 8.

import java.util.Scanner; import java.util.Random; public class GuessingTest {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in); System.out.println(\请录入所猜数字的上限: \ int max = scanner.nextInt();

System.out.println(\您需要猜测的数字范围是：0～\max);

9.

10. //统计猜测的次数 11. int count = 0; 12. //内置结果

13. Random ran = new Random();

14. int result = ran.nextInt(max + 1); 15.

16. //猜测开始

17. while (true) { 18. count++;

19. System.out.print(\第 \次猜测：\20. int number = scanner.nextInt(); 21. if ( number == result ) {

22. System.out.println(\猜对了，结果为：\

23. + result + \；您共猜了\次\24. } 25.

26. if ( number > result ) {

27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 隐藏

System.out.println( number + \大了!\ continue; }

if ( number < result ) {

System.out.println( number + \小了!\ continue; } }

scanner.close(); } }

5 成绩统计程序

5.1 问题

成绩管理系统。有如下功能共用户选则：录入成绩 ，成绩列表 ，查询成绩，退出。当用户在控制台输入1，用户选择的功能为录入成绩；输入2，用户选择的功能为成绩列表；输入3，用户选择的功能为根据姓名查找成绩；输入4，退出。系统交互情况如图-42所示：

图-42

5.2 方案

系统使用一个整形数组和一个字符串数组分别存放学生成绩信息和姓名。其中 NameUtils.randomNames()方法能获取一个大小为numOfStudents的字符串数组，

且数组的元素为学员的姓名，代码如下所示： 1. 2. 3.

int numOfStudents = 10;

String[] students = NameUtils.randomNames(numOfStudents); int[] scores = new int[numOfStudents];

录入成绩通过循环遍历数组给数组的每个元素初始化。代码如下所示： 1. 2. 3.

System.out.println(\开始录入成绩： \

for (int i = 0; i < students.length; i++) {

System.out.print((i + 1) + \学生姓名：\成绩：?\

4. scores[i] = scanner.nextInt(); 5. }

6. System.out.println(\录入完毕。\

成绩列表功能通过遍历两个数组，打印所有信息，StringUtils.rightPad()方法是一个格式化输出的方法，代码如下所示： 1. 2.

for (int i = 0; i < students.length; i++) {

System.out.println(StringUtils.rightPad(i + 1 + \10, \

3. + StringUtils.rightPad(students[i], 10, \\

4. + StringUtils.rightPad(scores[i] + \\5. }

查询成绩功能，首先根据姓名在姓名数组中查出该姓名所对应的下标，该下标就是成绩数组中该学员成绩所对应的下标，代码如下所示： 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12.

int i = 0;

for (; i < students.length; i++) {

if (student.equalsIgnoreCase(students[i])) { break; } }

if (i < students.length) { System.out.println((i + 1) + \学生姓名：\+ students[i] + \成绩：\} else {

System.out.println(\对不起，找不到学员的信息。\}

5.3 实现

系统代码实现如下： 1. 2.

import java.util.Scanner;

import org.apache.commons.lang.StringUtils;

3. import tts.fundamental.utils.NameUtils; 4. public class ScoreManager {

5. public static void main(String[] args) { 6. int numOfStudents = 10;

7. String[] students = NameUtils.randomNames(numOfStudents); 8. int[] scores = new int[numOfStudents]; 9. Scanner scanner = new Scanner(System.in);

10. System.out.println(\欢迎进入成绩管理系统**********\11. while (true) {

12. System.out.print(\请选择功能：1——成绩录入，2——成绩列表，3——成绩查询，4——退出\

13. String c = scanner.next().trim(); 14. if (\

15. System.out.println(\开始录入成绩： \

16. for (int i = 0; i < students.length; i++) { 17. System.out.print((i + 1) + \学生姓名：\18. + students[i]+ \成绩：?\

19. scores[i] = scanner.nextInt(); 20. }

21. System.out.println(\录入完毕。\22. } else if (\23. int avg = 0;

24. for (int i = 0; i < scores.length; i++) { 25. avg += scores[i]; 26. }

27. avg /= scores.length;

28. System.out.println(StringUtils.rightPad(\编号\29. + StringUtils.rightPad(\姓名\30. + StringUtils.rightPad(\成绩\31. System.out.println(StringUtils.repeat(\32. for (int i = 0; i < students.length; i++) {

33. System.out.println(StringUtils.rightPad(i + 1 + \10, \

34. + StringUtils.rightPad(students[i], 10, \

35. + StringUtils.rightPad(scores[i] + \36. }

37. System.out.println(StringUtils.repeat(\38. System.out.println(\平均成绩: \39. } else if (\

40. System.out.print(\请输入您要查询的学生姓名： \41. String student = scanner.next().trim(); 42. int i = 0;

43. for (; i < students.length; i++) {

44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 隐藏

if (student.equalsIgnoreCase(students[i])) { break; } }

if (i < students.length) { System.out.println((i + 1) + \学生姓名：\+ students[i] + \成绩：\ } else {

System.out.println(\对不起，找不到学员的信息。\ }

} else if (\

System.out.println(\谢谢使用**********\ break; } }

scanner.close(); } }

5.4 扩展

为成绩管理系统添加统计功能，即：1为录入成绩；2为输出成绩列表；3为查找成绩；4为统计成绩；5为退出。

其中，功能1由用户录入成绩；功能2则输出成绩的列表；功能 3 为查询成绩；功能4为统计，即统计分数分别为不及格（0－59）、及格（60－79）、良好（80－89）、优秀（90－99）和满分（100）的人数；功能5为退出。系统交互情况如图-43所示：

图-43

系统代码实现如下： 1. 2. 3. 4. 5. 6. 7.

import java.util.Scanner;

import org.apache.commons.lang.StringUtils; import tts.fundamental.utils.NameUtils; public class ScoreManager {

public static void main(String[] args) { int numOfStudents = 10; String[] students =

NameUtils.randomNames(numOfStudents);

8. int[] scores = new int[numOfStudents]; 9.

10. Scanner scanner = new Scanner(System.in); 11.

12. System.out.println(\欢迎进入成绩管理系统**********\

13. while (true) {

14. System.out.println(\请选择功能：1——成绩录入，2——成绩列表，3——成绩查询，4——成绩统计，5——退出\15.

16. String c = scanner.next().trim(); 17. if (\

18. System.out.println(\开始录入成绩： \

19. for (int i = 0; i < students.length; i++) { 20. System.out.print((i + 1) + \学生姓名：\+ students[i]

21. + \成绩：?\

22. scores[i] = scanner.nextInt(); 23. }

24. System.out.println(\录入完毕。\25. } else if (\26.

27. int avg = 0;

28. for (int i = 0; i < scores.length; i++) { 29. avg += scores[i]; 30. }

31. avg /= scores.length; 32.

33. System.out.println(StringUtils.rightPad(\编号\

34. + StringUtils.rightPad(\姓名\20, \\35. + StringUtils.rightPad(\成绩\\

36. System.out.println(StringUtils.repeat(\30));

37. for (int i = 0; i < students.length; i++) { 38. System.out.println(StringUtils

39. .rightPad(i + 1 + \40. + StringUtils.rightPad(students[i], 10, \

41. + StringUtils.rightPad(scores[i] + \

42. }

43. System.out.println(StringUtils.repeat(\30));

44. System.out.println(\平均成绩: \45.

46. } else if (\

47. System.out.print(\请输入您要查询的学生姓名： \

48. String student = scanner.next().trim(); 49. int i = 0;

50. for (; i < students.length; i++) { 51. if (student.equalsIgnoreCase(students[i])) {

52. break; 53. }

54. }

55. if (i < students.length) {

56. System.out.println((i + 1) + \学生姓名：\

57. + \成绩：\58. } else {

59. System.out.println(\对不起，找不到学员的信息。\

60. }

61. } else if (\

62. // 统计不及格（0－59）、及格（60－79）、良好（80－89）、优秀（90－99）和满分（100）的人数 63. int failed = 0; 64. int pass = 0; 65. int fine = 0;

66. int excellent = 0; 67. int full = 0; 68.

69. for (int i = 0; i < scores.length; i++) { 70. if (scores[i] < 60) 71. failed++;

72. else if (scores[i] >= 60 && scores[i] <= 79) 73. pass++;

74. else if (scores[i] >= 80 && scores[i] <= 89) 75. fine++;

76. else if (scores[i] >= 90 && scores[i] <= 99) 77. excellent++;

78. else if (scores[i] == 100) 79. full++; 80. } 81.

82. // 输出

83. System.out.println(\满分(100)：\人\

84. System.out.println(\优秀(99-90)：\+ \人\

85. System.out.println(\良好(89-80)：\人\

86. System.out.println(\及格(79-60)：\人\

87. System.out.println(\不及格(59-0)：\\人\88.

89. } else if (\

90. System.out.println(\谢谢使用**********\

91. break; 92. } 93. }

94. scanner.close(); 95. } 96. } 隐藏

6 费氏数列问题

6.1 问题

费氏数列的全称为费波那契数列，指的是这样一个数列：1、1、2、3、5、8、13、21、34?? 。这个数列的第一项和第二项均为1，从第三项开始，每一项都等于前两项之和。

现需要程序解决费氏数列的计算问题。即由用户输入需要计算的费氏序列的项数（项数从1开始），然后程序算出费氏序列中该项的数值，并打印到控制台。 系统交互情况如图-46所示：

图-46

6.2 方案

首先找出数列的规律，第一项、第二项值都是1，从第三项开始，每一项的值都等于该项前两项的和。代码如下 1. 2. 3. 4. 5. 6.

public static long fibonacci(int n) { if (n == 1 || n == 2) return 1; long f1 = 1; long f2 = 1;

for (int i = 3; i <= n; i++) {

7. 8. 9. 10. 11. f2 = f1 + f2; f1 = f2 - f1; }

return f2; }

6.3 实现

系统代码实现如下：

1. import java.util.Scanner; 2. public class Fibonacci {

3. public static void main(String[] args) {

4. Scanner scanner = new Scanner(System.in);

5. System.out.print(\请输入Fibonacci数列的项数 n = ？\6. int n = scanner.nextInt(); 7. scanner.close();

8. long result = fibonacci(n); 9. if (result > 0) {

10. System.out.println(\result);

11. } else {

12. System.out.println(\数值太大，溢出！\13. } 14.

15. }

16. public static long fibonacci(int n) { 17. if (n == 1 || n == 2) 18. return 1; 19. long f1 = 1; 20. long f2 = 1;

21. for (int i = 3; i <= n; i++) { 22. f2 = f1 + f2; 23. f1 = f2 - f1; 24. }

25. return f2; 26. } 27. } 隐藏

6.4 扩展

根据勾股定理计算直角三角形的斜边的边长 。勾股定理：在任何一个直角三角形中，两条直角边的平方之和一定等于斜边的平方。程序要求如下：

1.定义方法，该方法需要传入直角三角形的两条直角边的长度，然后计算并返回其斜边的长度；

2.在main 方法中，先由用户在界面上录入两个长度以作为直角三角形两条直角边的长度，然后调用上一步中所定义的方法计算斜边的长度，并保留小数点后2位，在控制台输出结果。 系统交互情况如图-47所示：

图-47

系统代码实现如下： 1. import java.util.Scanner; 2. public class Hypotenuse {

3. public static void main(String[] args) {

4. Scanner scanner = new Scanner(System.in);

5. System.out.println(\请输入第一条直角边的长度：\6. double first = scanner.nextDouble();

7. System.out.println(\请输入第二条直角边的长度：\8. double second = scanner.nextDouble(); 9. scanner.close(); 10.

11. double hypotenuse = getHypotenuse(first, second); 12. hypotenuse = Math.round(hypotenuse * 100) / 100.0; 13. System.out.println(\斜边的长度为：\14. } 15. /**

16. * 计算直角三角形的斜边的长度 17. *

18. * @param a 19. * @param b 20. * @return 21. */

22.

public static double getHypotenuse(double a, double b) {

23. 24. 25. 26.

double sum = Math.pow(a, 2) + Math.pow(b, 2); return Math.sqrt(sum); } }

本文来源：https://www.bwwdw.com/article/db2p.html