在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句

  1. 顺序控制
  2. 分支控制
  3. 循环控制

一、顺序控制

  1. 顺序控制介绍：程序从上到下逐行地执行，中间没有任何判断和跳转。
  2. 顺序控制举例和注意事项
    • Java中定义变量时从用合法的前向引用

二、分支控制if-else

1. 分值控制if-else介绍

让程序有选择的执行，分值控制有三种

  1. 单分支
  2. 双分支
  3. 多分支

2. 单分支

  • 基本语法 
    1. if (条件表达式) {
    2.  指定代码块; // 可以有多条语句
    3. }
  • 说明：当条件表达式为ture时，就会执行{}代码。如果{}中只有一条语句，则可以省略{}，建议写上{}
  • 单分支流程图
  • 案例演示 
    1. // 输入一个数字，判断是否满18岁
    2. Scanner input = new Scanner(System.in);
    3. System.out.print("输入年龄：");
    4. int age = input.nextInt();
    5. if (age >= 18) {
    6.  System.out.println("年龄已满18岁！");
    7. }

3. 双分支

  • 基本语法 
    1. if (条件表达式) {
    2.  执行代码块1;
    3. } else {
    4.  执行代码块2;
    5. }
  • 说明：当条件表达式为ture时，就会执行代码块1，否则执行代码块2。如果{}中只有一条语句，则可以省略{}，建议写上{}
  • 双分支流程图
  • 案例演示 1 
    1. // 输入一个数字，判断是否满18岁
    2. Scanner input = new Scanner(System.in);
    3. System.out.print("输入年龄：");
    4. int age = input.nextInt();
    5. if (age >= 18) {
    6.  System.out.println("年龄已满18岁！");
    7. } else {
    8.  System.out.println("年龄不满18岁！");
    9. }
  • 案例演示 2 
    1. // 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
    2. // 1. 年份能被4整除，但不能被100整除；
    3. // 2. 能被400整除
    4. int year = 2028;
    5. if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
    6.  System.out.println(year + "年是闰年");
    7. } else {
    8.  System.out.println(year + "年不是闰年");
    9. }

4. 多分支

  • 基本语法 
    1. if (条件表达式) {
    2.  执行代码块1;
    3. } else if {
    4.  执行代码块2;
    5. } 
    6. ...
    7. else {
    8.  执行代码块n;
    9. }
  • 多分支流程图

5. 嵌套分支

  • 在一个分支结构中有完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外层分支。不建议嵌套超过3层
  • 案例演示 1 ```java // 参加歌手比赛，如果成绩大于8.0，及格 // 并根据性别提示进入男子组或女子组 // 输入分数和性别，进行判断和输出信息 Scanner scanner = new Scanner(System.in); System.out.println(“请输入分数：”); double score = scanner.nextDouble(); // 接收输入

if (score >= 8.0) { System.out.println(“请输入性别：”); char gender = scanner.next().charAt(0); // 接收字符串的第一个字符

  1. if (gender == '男') {
  2.     System.out.println("及格，进入男组");
  3. } else if (gender == '女') {
  4.     System.out.println("及格，进入女组");
  5. } else {
  6.     System.out.println("请输入正确信息！");
  7. }

} else if (score < 8.0) { System.out.println(“不及格，你已被淘汰！”); }

  3. -  案例演示 2 
  4. ```java
  5. /* 出票系统：根据淡旺季的月份和年龄，打印票价
  6.    4月到10月 旺季：
  7.               成人（18-60）：60
  8.               儿童（<18）：30
  9.               老人（>60）：20
  10.             淡季：
  11.               成人：40
  12.               其他：20
  13. */
  14. int price; // 定义变量 价格
  15. int season; // 定义变量 季节
  16. int age; // 定义变量 年龄
  18. Scanner scanner = new Scanner(System.in);
  19. System.out.print("请输入季节：");
  20. season = scanner.nextInt();
  21. System.out.print("请输入年龄：");
  22. age = scanner.nextInt();
  24. if (season >= 4 && season <= 10) { // 旺季
  25.     if (age >= 18 && age <= 60) { // 成人
  26.         price = 60;
  27.     } else if (age < 18) { // 儿童
  28.         price = 30;
  29.     } else { // 老人
  30.         price = 20;
  31.     }
  32.     System.out.printf("现在是旺季，价格为：%d元%n", price);
  33. } else if (season > 0 && season < 13) { // 淡季
  34.     if (age >= 18 && age <= 60) { // 成人
  35.         price = 40;
  36.     } else { // 其他
  37.         price = 20;
  38.     }
  39.     System.out.printf("现在是淡季，价格为：%d元%n", price);
  40. } else {
  41.     System.out.println("月份输入错误！");
  42. }

6. switch分支结构

  • 基本语法 
    1. switch (表达式) { // switch分支，表达式对应一个值
    2.  case 常量1: // 当表达式的值等于[常量1]，执行[语句块1]
    3.      语句块1;
    4.      break; // 退出switch
    5.  case 常量2: // 如果没有匹配[常量1]，继续匹配[常量2]
    6.      语句块2;
    7.      break; // 退出switch
    8.  ...
    9.  case 常量n:
    10.      语句块n;
    11.      break; // 退出switch
    12.  default: // 如果都没有匹配上，执行default
    13.      default 语句块;
    14.      break;
    15. }
  • switch流程图
  • 案例演示 1 
    1. /*
    2. * 请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d...
    3. * a表示星期一，b表示星期二...
    4. * 根据用户输入显示相应的信息，要求使用 switch 语句完成
    5. * 思路分析：
    6. * 1. 接收用户输入
    7. * 2. 使用switch来完成匹配，并输出对应信息
    8. */
    9. Scanner scanner = new Scanner(System.in);
    10. System.out.print("请输入一个字符(a-d)：");
    11. char input = scanner.next().charAt(0);
    12. switch (input) {
    13.  case 'a':
    14.      System.out.println("星期一");
    15.      break;
    16.  case 'b':
    17.      System.out.println("星期二");
    18.      break;
    19.  case 'c':
    20.      System.out.println("星期三");
    21.      break;
    22.  case 'd':
    23.      System.out.println("星期四");
    24.      break;
    25.  default:
    26.      System.out.println("输入错误");
    27.      break;
    28. }
  • 案例演示 2 
    1. /*
    2. * 使用switch完成
    3. * 对学生成绩大于60分的，输出"及格"。
    4. * 低于60分的，输出"不及格"
    5. * 注：输入的成绩不能大于100 (提示：成绩/60)
    6. * 思路分析：
    7. * 1. 创建Scanner对象，使用double变量接收
    8. * 2. 成绩/60的结果，等于1说明及格，等于0说明不及格
    9. * 如果成绩在 [60,100]，(int)(成绩/60) = 1
    10. * 如果成绩在 [0,60]，(int)(成绩/60) = 0
    11. * 3. 使用if-else保证输入的成绩是有效的(0-100)
    12. */
    13. private static void grade() {
    14.  Scanner scanner = new Scanner(System.in);
    15.  System.out.print("输入成绩(大于等于0，小于等于100)：");
    16.  double input = scanner.nextDouble();
    17.  if (input >= 0 && input <= 100) {
    18.      switch ((int) (input / 60)) {
    19.          case 1:
    20.              System.out.println("及格");
    21.              break;
    22.          case 0:
    23.              System.out.println("不及格");
    24.              break;
    25.      }
    26.  } else {
    27.      System.out.println("成绩输入错误");
    28.  }
  • switch注意事项
    1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以互相比较的类型，比如输入的是字符，而常量是int
    2. switch中表达式的返回值必须是：(byte, short, int, char, enum[枚举], String)
    3. case子句中的值必须是常量(或常量表达式)，而不能是变量
    4. default子句是可选的，当没有匹配的case时，执行default
    5. break语句用来在执行完一个csse分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾，除非遇到break（穿透现象）
  • switch和if比较
  1. 如果判断的具体数值不多，而且符合byte, shrot, int, char, enum(枚举), String这六种类型。建议使用switch语句
  2. 其他情况：对区间判断、对结果为boolean类型判断，使用if，if的适用范围更广

三、循环

1. for循环控制

  • 基本语法： 
    1. for (循环变量初始化; 循环条件; 循环变量迭代) {
    2.  循环操作(语句);
    3. }
  • 使用说明：
    1. for关键字，表示循环控制
    2. for有四要素：(1)循环变量初始化 (2)循环条件 (3)循环操作 (4)循环变量迭代
    3. 循环操作，这里可以有多条语句，也就是要循环执行的代码
    4. 如果循环操作(语句)只有一条语句，可以省略{}，建议不省略
  • 案例演示： 
    1. // 使用for循环打印10次 hello, world
    2. for (int i = 0; i < 10; i++) {
    3.  System.out.println(i + ". hello, world");
    4. }
  • for循环流程图
  • 注意事项
    1. 循环条件是返回一个布尔值的表达式
    2. for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略 
      1. // 上例可改为
      2. int i = 1; // 循环变量初始化
      3. for (; i <= 10;) { // 循环条件
      4. System.out.println(i + ". hello, world"); // 循环操作
      5. i++; // 循环变量迭代
      6. }
  1. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开 
    1. int count = 3;
    2. for (int i = 0, j = 0; i < count; i++, j += 2) {
    3. System.out.println("i = " + i + "; j = " + j); // i = 0, 1, 2; j = 0, 2, 4
    4. }
  • 课堂练习 
    1. // 打印1-100之间所有是9的倍数的整数，统计个数及总和
    2. int start = 1; // 开始
    3. int end = 100; // 结束
    4. int count = 0; // 计数
    5. int sum = 0; // 总和
    6. int t = 9; // 倍数
    7. for (int i = start; i <= end; i++) {
    8.  if (i % t == 0) {
    9.      System.out.println("i = " + i);
    10.      count++;
    11.      sum += i;
    12.  }
    13. }
    14. System.out.println("个数：" + count + "; 总和：" + sum);

2. while循环控制

  • 基本语法 
    1. // while循环也有循环四要素，只是位置不一样
    2. while (循环条件) {
    3.  循环体(语句);
    4.  循环变量迭代;
    5. }
  • 流程分析
  • 案例演示 
    1. // 输入10次 hello, world
    2. int i = 1;
    3. while (i <= 10) {
    4.  System.out.println("hello, world" + i);
    5.  i++;
    6. }

3. do..while循环控制

  • 基本语法 
    1. // do while 关键字
    2. // 也有循环四要素，只是位置不一样
    3. // 先执行，再判断，也就是说，一定会至少执行一次
    4. // 最后有一个分号 ;
    5. 循环变量初始化;
    6. do {
    7.  循环体(语句);
    8.  循环变量迭代;
    9. } while (循环条件);
  • 流程分析
  • 案例演示 
    1. // 输入10次 hello, world
    2. int i = 1;
    3. do {
    4.  System.out.println("hello, world" + i);
    5.  i++;
    6. } while (i <= 10);
  • 注意事项
    1. 循环条件是返回一个布尔值的表达式
    2. do..while循环是先执行，再判断，因此它至少执行一次
  • 课堂练习 
    1. /* 统计1-200之间能被5整除但不能被3整除的个数
    2. * 思路分析：
    3. * 1. 化繁为简：遍历1-200之间所有的数
    4. * 2. 判断是否满足条件
    5. * 3. 统计满足条件的个数
    6. * 4. 先死后活：把能做成变量的都做成变量
    7. */
    8. int i = 1;
    9. int start = i;
    10. int end = 200;
    11. int count = 0; // 计数
    12. do {
    13.  if (i % 5 == 0 && i % 3 != 0) {
    14.      System.out.println(i);
    15.      count++;
    16.  }
    17.  i++;
    18. } while (i <= end);
    19. System.out.printf("%d-%d之间能被5整除但不能被3整除的个数为：%d", start, end, count);

4. 多重循环控制 (重点难点)

  • 基本介绍
    1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for, while, do-while均可作为外层循环和内层循环。【建议一般使用两层，最多不超过三层，否则影响代码的可读性】
    2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环
    3. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次 ```java /* 使用内存分析法分析下面的多重循环执行步骤
      1. i = 0
      1. 判断 i < 2
      1. j = 0
      1. 判断 j < 3
      1. 打印
      1. j++
      1. 循环第二层循环体，当j < 3为false时，回到第一层循环，i++，再次判断 i < 2 */ for (int i = 0; i < 2; i++) { // 第一层循环 2次 for (int j = 0; j < 3; j++) { // 第二层循环 3次 System.out.println(“i = “ + i + “j = “ + j); } } ```
  • 案例演示 
    1. /*
    2. * 统计3个班的成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分
    3. * 统计三个班的及格人数
    4. * 思路分析：
    5. * 1. 创建Scanner对象
    6. * 2. for嵌套循环，用户输入每个同学的成绩
    7. * 3. 计算总成绩和平均分
    8. * 3. if计算及格人数
    9. */
    10. Scanner scanner = new Scanner(System.in);
    11. double score;
    12. double stuScoreSum = 0;
    13. double claScoreSum = 0;
    14. int classNums = 3;
    15. int studentsNums = 5;
    16. int passNum = 0;
    17. for (int i = 1; i <= classNums; i++) {
    18.  for (int j = 1; j <= studentsNums; j++) {
    19.      System.out.printf("请输入%d班%d号同学的成绩：", i, j);
    20.      score = scanner.nextDouble();
    21.      stuScoreSum += score;
    22.      if (score >= 60) {
    23.          passNum++;
    24.      }
    25.  }
    26.  System.out.printf("%d班的平均分为：%.2f%n", i, stuScoreSum / studentsNums);
    27.  claScoreSum += stuScoreSum;
    28.  stuScoreSum = 0;
    29. }
    30. System.out.printf("总平均分为：%.2f，共有%d人及格", claScoreSum / (classNums * studentsNums), passNum);
  • 金字塔案例 ```java /* 打印空心金字塔
    • *
    • 化繁为简：
      1. 打印半个金字塔
      • // 第1层 有 1个*
    • * // 第2层 有 2个
    • ** // 第3层 有 3个
    • ** // 第4层 有 4个*
    • * // 第5层 有 5个 / for (int i = 1; i <= 5; i++) { // 层数 for (int j = 1; j <= i; j++) { // 的个数 System.out.print(““); } System.out.println(); // 换行 }

/* 2. 打印实心金字塔

    • // 第1层 有 1个 21-1 有4(总层数-当前层数)个空格
  • ** // 第2层 有 3个 2*2-1 有3个空格
  • * // 第3层 有 5个 23-1 有2个空格
  • * // 第4层 有 7个 24-1 有1个空格
  • * // 第5层 有 9个 25-1 有0个空格 */ for (int i = 1; i <= 5; i++) { for (int k = 1; k <= 5 - i; k++) {
    1.    System.out.print(" "); // 输出空格
    } for (int j = 1; j <= 2 * i - 1; j++) {
    1.    System.out.print("*");
    } System.out.println(); } /* 3. 打印空心金字塔
    • // 第1层 有 1个 当前行的第一个位置和最后一个位置是
      • // 第2层 有 2个 当前行的第一个位置和最后一个位置是
      • // 第3层 有 2个 当前行的第一个位置和最后一个位置是
      • // 第4层 有 2个 当前行的第一个位置和最后一个位置是
  • * // 第5层 有 9个 全部都是 / for (int i = 1; i <= 5; i++) { for (int k = 1; k <= 5 - i; k++) { System.out.print(“ “); } for (int j = 1; j <= 2 i - 1; j++) { // 当前行的第一个位置和最后一个位置是，最后一层全部 if (j == 1 || j == 2 * i -1 || i == 5) {
    1.    System.out.print("*");
    } else { // 其他情况输出空格
    1.    System.out.print(" ");
    } } System.out.println(); // 每打印完一行*，就换行 }

/* 先死后活

  • 5 层数做成变量 */ int totalLevel = 10; // 层数 for (int i = 1; i <= totalLevel; i++) { for (int k = 1; k <= totalLevel - i; k++) {
    1.  System.out.print(" ");
    } for (int j = 1; j <= 2 * i - 1; j++) {
    1.  // 当前行的第一个位置和最后一个位置是*，最后一层全部*
    2.  if (j == 1 || j == 2 * i -1 || i == totalLevel) {
    3.      System.out.print("*");
    4.  } else { // 其他情况输出空格
    5.      System.out.print(" ");
    6.  }
    } System.out.println(); // 每打印完一行*，就换行 } ```
  • 扩展：空心菱形 
    1. /* 
    2. * 扩展 打印空心菱形
    3. *       *          
    4. *     *   *        
    5. *   *       *      
    6. *     *   *        
    7. *       *
    8. * 化繁为简：
    9. * 1. 同上，先打印半个实心菱形
    10. * 2. 打印实心菱形
    11. * 3. 打印空心菱形
    12. */
    13. // 菱形上半部分
    14. int totalLevel = 5; // 层数
    15. // 菱形上半部分
    16. for (int i = 1; i <= totalLevel; i++) {
    17.  for (int k = 1; k <= totalLevel - i; k++) {
    18.      System.out.print(" ");
    19.  }
    20.  for (int j = 1; j <= 2 * i - 1; j++) {
    21.      // 当前行的第一个位置和最后一个位置是*，最后一层全部*
    22.      if (j == 1 || j == 2 * i -1) {
    23.          System.out.print("*");
    24.      } else { // 其他情况输出空格
    25.          System.out.print(" ");
    26.      }
    27.  }
    28.  System.out.println(); // 每打印完一行*，就换行
    29. }
    30. // 菱形下半部分
    31. for (int i = 1; i <= totalLevel - 1; i++) {
    32.  for (int k = 1; k <= i; k++) {
    33.      System.out.print(" ");
    34.  }
    35.  for (int j = 1; j <= 2 * (totalLevel - 1 - i) + 1; j++) {
    36.      // 当前行的第一个位置和最后一个位置是*，最后一层全部*
    37.      if (j == 1 || j == 2 * (totalLevel - 1 - i) + 1) {
    38.          System.out.print("*");
    39.      } else { // 其他情况输出空格
    40.          System.out.print(" ");
    41.      }
    42.  }
    43.  System.out.println(); // 每打印完一行*，就换行
    44. }

四、控制语句

1. break

  • 基本介绍
    • 用于终止某个语句块的执行
    • 一般使用在switch或者各种循环中
  • 基本语法 
    1. {   ...
    2.  break;
    3. }
  • 流程分析(以while循环为例)
  • 案例演示 
    1. for (int i = 0; i < 10; i++) {
    2.  if (i == 3) {
    3.      break; // 跳出for循环
    4.  }
    5.  System.out.println("ok" + i); // ok0, ok1, ok2
    6.  }
    7. System.out.println("退出for循环，继续运行")

  • 注意事项

    1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的语句块
    2. 标签的基本使用 
      1. label1: for (int i = 0; i < 10; i++) {
      2. label2: for (int j = 0; j < 5; j++) {
      3.  if (j == 3) {
      4.      break label1; // 跳出label1 for循环
      5.  }
      6.  System.out.println("ok" + i);
      7. }
      8. }

      1). break语句可以指定退出哪层
      2). label1是标签，标识符，由程序员指定
      3). break后指定到哪个label就退出到哪里
      4). 在实际的开发中，建议尽量不要使用标签
      5). 如果没有指定break，默认退出最近的循环体

  • 课后练习 

    1. // 1-100以内的数求和，求出当和第一次大于20的当前数(for+break)
    2. // 1. 循环1-100，求和sum
    3. // 2. 当 sum > 20 时，记录当前数，然后break
    4. int sum = 0;
    5. for (int i = 1; i <= 100; i++) {
    6.  sum += i;
    7.  if (sum > 20) {
    8.      System.out.println("当和大于20时，当前数为：" + i);
    9.      break;
    10.  }
    11. }
    12. /*
    13. * 实现登陆验证，有3次机会，如果用户名为"丁真"，密码为"666"提示登陆成功
    14. * 否则提示还有几次机会，请使用for+break完成
    15. * 
    16. * 思路分析：
    17. * 1. 创建Scanner对象接收用户输入
    18. * 2. 定义 String name; String password;
    19. * 3. 最多循环3次，如果满足条件就提前退出
    20. * 4. 变量 int chance 记录还有几次机会
    21. * 5. 使用 String.equals("anObject") 进行字符串比较，判断是否满足条件
    22. * 也可以 "anObject".equals(String) 推荐使用这种方法，避免空指针
    23. */
    24. Scanner scanner = new Scanner(System.in);
    25. String name = "";
    26. String password = "";
    27. int chance = 3;
    28. for (int i = 1; i <= chance; i++) {
    29.  System.out.print("请输入用户名：");
    30.  name = scanner.next();
    31.  System.out.print("请输入密码：");
    32.  password = scanner.next();
    33.  // 比较输入的是否正确
    34.  if ("丁真".equals(name) && "666".equals(password)) {
    35.      System.out.println("登陆成功！");
    36.      break;
    37.  }
    38.  System.out.println("用户名或密码错误");
    39.  System.out.printf("还剩%d次机会！%n", chance - i);
    40. }

2. continue

  • 基本介绍
    1. continue语句用于结束本次循环，继续执行下一次循环
    2. continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则相同
  • 基本语法 
    1. {
    2.  ...
    3.  continue;
    4. }
  • 流程分析(以while循环为例)
  • 案例演示 
    1. int i = 1;
    2. while (i <= 4) {
    3.  i++;
    4.  if (i == 2) {
    5.      continue;
    6.  }
    7.  System.out.println("i = " + i); // 3, 4, 5
    8. }

3. return

  • 基本介绍
    • return使用在方法上，表示跳出所在的方法
    • 如果return写在main()方法，将退出程序
  • 案例演示 
    1. public static void main(String[] args) {
    2.  for (int i = 1; i <= 5; i++) {
    3.      if (i == 3) { // 满足条件时，直接退出程序
    4.          System.out.println("i = " + i); // i = 3
    5.          return; // 使用在main方法，跳出程序
    6.      }
    7.      System.out.println("Hello World!"); // 打印两次
    8.  }
    9.  System.out.println("go on.."); // return跳出方法后，这句代码不再执行
    10. }

五、控制结构课后练习

  1. 编程实现如下功能
    某人有100,000元，每经过一次路口，需要交费，规则如下：
    1). 当现金>50000时，每次交5%
    2). 当现金<=50000时，每次交1000
    编程计算该人可以经过多少次路口，要求：使用while break方式完成 
    1. /* 
    2. * 思路分析：
    3. * 1. int money 用来计算金钱
    4. * 2. int count 用来计数
    5. * 3. while 循环
    6. * 4. if判断条件，当 money < 1000 时，break
    7. */
    8. public static void main(String[] args) {
    9. double money = 100000; // 初始现金
    10. int count = 0; // 计数
    11. while (true) {
    12.     if (money > 50000) {
    13.         money *= 0.95;
    14.         count++;
    15.     } else if (money >= 1000) { // money > 1000 && money <= 50000
    16.         money -= 1000;
    17.         count++;
    18.     } else { // money < 1000
    19.         break;
    20.     }
    21. }
    22. System.out.printf("100000元可以过%d个路口，还剩%.2f元", count, money);
    23. }

  1. 判断一个3位整数是否是水仙花数

    1. 水仙花数是指一个n位数(n>=3)，它的每个位上的数字的n次幂之和等于它本身
    2. 例如：153 = 1*1*1 + 3*3*3 + 5*5*5 ```java /*
    • 思路分析：
      1. 创建Scanner对象接收3位数字，比如153
      1. n的百位 = n / 100
      1. n的十位 = n % 100 / 10
      1. n的个位 = n % 10
      1. 判断
      1. 扩展，求出所有3位的水仙花数 / public static void main(String[] args) { // 判断一个整数是否是水仙花数 Scanner scanner = new Scanner(System.in); // 输入 System.out.print(“请输入一个3位整数：”); int input = scanner.nextInt(); int a = input / 100; // 百位 int b = input % 100 / 10; // 十位 int c = input % 10; // 个位 if (a a a + b b b + c c * c == input) { // 计算并判断 System.out.println(input + “是水仙花数”); } else { System.out.println(input + “不是水仙花数”); }

    // 打印所有3位水仙花数 int count = 0; for (int i = 100; i < 1000; i++) {

    1. int a = i / 100; // 百位
    2. int b = i % 100 / 10; // 十位
    3. int c = i % 10; // 个位
    4. if (a * a * a + b * b * b + c * c * c == i) {
    5.     count++;
    6.     System.out.println(i);
    7. }

    } System.out.printf(“3位数中共有%d个水仙花数”, count); } ```

  2. 输出1-100之间不能被5整除的数，每5个一行 

    1. /* 
    2. * 思路分析
    3. * 1. for遍历1-100之间的所有数
    4. * 2. 判断是否能被5整数
    5. * 3. 每5行一个，使用int count统计输出的个数，当count%5==0时说明
    6. *    输出了5个，这时，输出一个换行即可
    7. * 4. 或者，当count等于5时打印一个换行，并初始化count
    8. */
    9. public static void main(String[] args) {
    10. // 第一种方法
    11. int count = 0; // 统计输出的个数
    12. for (int i = 1; i <= 100; i++) {
    13.     if (i % 5 != 0) {
    14.         count++;
    15.         System.out.print(i + "\t");
    17.         // 判断，每满5个，就输出一个换行
    18.         if (count % 5 == 0) {
    19.             System.out.println();
    20.         }
    21.     }
    22. }
    24. // 第二种方法
    25. count = 0;
    26. for (int i = 1; i <= 100; i++) {
    27.     if (i % 5 != 0) {
    28.         count++;
    29.         System.out.print(i + "\t");
    31.         if (count == 5) { // 当count == 5时，换行
    32.             System.out.println();
    33.             count = 0;
    34.         }
    35.     }
    36. }
    37. }

  1. 输出小写的a-z以及大写的Z-A

    1. char类型是可以进行运算的，相当于一个整数，每一个都有对应的unicode编码
    2. 遍历字母，相当于遍历字母对应的unicode编码
      1. public static void main(String[] args) {
      2. /* 
      3. * 输出小写的a-z以及大写的Z-A
      4. * a-z对应的unicode编码为：97-122
      5. * A-Z对应的unicode编码为：65-90
      6. * 思路分析：
      7. * 1. 'a' + 1 = 'b', 'b' + 1 = 'c'...,
      8. * 2. char类型是可以进行运算的，相当于一个整数
      9. * 3. 遍历字母，相当于遍历字母对应的unicode编码
      10. * 4. for循环
      11. */
      12. for (char c = 'a'; c <= 'z'; c++) {
      13.  System.out.print(c + " ");
      14. }
      15. System.out.println();
      16. for (char c = 'Z'; c >= 'A'; c--) {
      17.  System.out.print(c + " ");
      18. }
      19. }

  2. 求出1 - 1/2 + 1/3 - 1/4...1/100的和 

    1. public static void main(String[] args) {
    2. /*
    3.  * 求出1 - 1/2 + 1/3 - 1/4...1/100的和
    4.  * 思路分析
    5.  * 1. (1/1) - (1/2) + (1/3) - (1/4)...(1/100)
    6.  * 2. 一共有100个数，分子为1，分母从1-100
    7.  * 3. 当分母为奇数时，相加，当分母为偶数时，相减
    8.  * 4. for + 判断即可完成
    9.  * 5. 把结果存放到double sum
    10.  * 6. 有一个隐藏的陷阱，要把公式分子1写出1.0才能精确到小数
    11.  */
    12. double sum = 0;
    13. for (int i = 1; i <= 100; i++) {
    14.     if (i % 2 != 0) { // 分母为奇数
    15.         sum += 1.0 / i; // 1.0转换为double类型
    16.     } else { // 分母为偶数
    17.         sum -= 1.0 / i;
    18.     }
    19. }
    20. System.out.println(sum);
    21. }
  1. 求1 + (1+2) + (1+2+3) + (1+2+3+4) +...+ (1+2+3+...+100)的结果 
    1. public static void main(String[] args) {
    2. /*
    3.  * 求1 + (1+2) + (1+2+3) + (1+2+3+4) +...+ (1+2+3+...+100)的结果
    4.  * 思路分析
    5.  * 1. 每一项的数字在逐渐增加，共100项
    6.  * 2. 两层for循环
    7.  * 3. 使用sum进行累计即可
    8.  */
    9. int sum = 0;
    10. // i可以表示是第几项，同时也是当前项的最后一个数
    11. for (int i = 1; i <= 100; i++) {
    12.     for (int j = 1; j <= i; j++) { // 内层对1-i进行循环
    13.         sum += j;
    14.     }
    15. }
    16. System.out.println(sum);
    17. }