• JavaSE - 逻辑控制语句

    目录

    1. 分支结构

    1.1 if 语句

    1.2 switch 语句

    2. 循环语句 

    练习一：分别计算1-100的和，1-100的奇数和，1-100的偶数和

    练习二（1）：计算 5 的阶乘

    练习二（2）：计算 1-5 的阶乘的和

    方法一：在上面代码基础上进行修改

    方法二：

    练习三（1）：求一个整数，在内存当中存储时，二进制1的个数。 

    方法一：（nice）

    方法二：（算法层次的优化）

    方法三：

    方法四：

    练习三（2）：求一个整数，在内存当中存储时，二进制0的个数。 

    练习四： 计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。

    练习五：寻找自幂数

    练习六：输出X图形

    练习七：乘法口诀表

    练习八：模拟登录

    练习九：获取一个数二进制序列中所有的偶数位和奇数位， 分别输出二进制序列

    练习十：输出1-100之间的所有素数

    练习十一（1）：求两个正整数的最大公约数 

    练习十一（2）:求两个正整数的最小公倍数

    3. 输入输出

    3.1 输出到控制台

    3.2 从键盘输入

    3.2.1 使用 Scanner 读取字符串/整数/浮点数

     3.2.2 使用 Scanner 循环读取 N 个数字

    4. 猜数字游戏

    1. 分支结构

    1.1 if 语句

    括号中的表达式必须是布尔表达式

    1.2 switch 语句

    • switch语句括号内支持的类型：byte  short  int  char  String  enum  不支持类型：long，float，double，boolean
    • case后 跟常量表达式，且多个case后的常量值不可以重复

    2. 循环语句 

    while    for    do……while

    学会做提前先想好思路，再动手敲代码。

    代码对齐快捷键：Ctrl+Alt+L

    练习一：分别计算1-100的和，1-100的奇数和，1-100的偶数和

    1. public class TestDemo {
    2.     //像这种计算数字和的，一边产生数字一边判断
    3.     public static void main(String[] args) {
    4.         //计算1-100的和，奇数和，偶数和
    5.         /*首先产生1-100的数字
    6.          一边产生一边计算和
    7.         判断是偶数还是奇数，偶数的，奇数的分别相加。
    8.         */
    9.         int sum = 0;
    10.         int oldSum = 0;
    11.         int evenSum = 0;
    12.         for (int i = 1; i <= 100; i++) {
    13.             sum += i;
    14.             if (i % 2 == 0) {
    15.                 evenSum += i;
    16.             } else {
    17.                 oldSum += i;
    18.             }
    19.         }
    20.         System.out.println("1-100的和为：" + sum);//5050
    21.         System.out.println("1-100的偶数和为：" + evenSum);//2550
    22.         System.out.println("1-100的奇数和为：" + oldSum);//2500
    23.     }
    24. }

    练习二（1）：计算 5 的阶乘

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //计算 5 的阶乘
    4.         /*产生1-5的数
    5.         * 每产生一个数，乘起来*/
    6.         int ret = 1;
    7.         for (int i = 1; i <= 5; i++) {
    8.             ret *= i;
    9.         }
    10.         System.out.println(ret);
    11.     }
    12. }

    练习二（2）：计算 1-5 的阶乘的和

    方法一：在上面代码基础上进行修改

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         
    4.         /*先产生1-5的数，产生一个数，就计算这个数的阶乘
    5.         * 这个数的阶乘求法：产生1-这个数的数字，乘起来。
    6.         * 计算好的阶乘加起来*/
    7.  
    8.         /**
    9.          * 内循环：计算每个数的阶乘
    10.          * 外循环，产生每个数，计算阶乘的和。
    11.          */
    12.  
    13.         int sum = 0;
    14.         for (int n = 1; n <= 5; n++) {
    15.             //计算每个数的阶乘
    16.             int ret = 1;
    17.             for (int i = 1; i <= n; i++) {
    18.                 ret *= i;
    19.             }
    20.             sum += ret;
    21.         }
    22.         System.out.println(sum);
    23.  
    24.     }
    25. }

    方法二：

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //计算1-5的阶乘的和
    4.         // 1!+2!+3!+4!+5!
    5.         /*
    6.         1！*2=2！
    7.         2！*3=3！
    8.         产生1-5的数，计算完一个阶乘就加起来然后再乘下个数再加上来
    9.          */
    10.         int ret = 1;
    11.         int sum = 0;
    12.         for (int i = 1; i <= 5; i++) {
    13.             ret *= i;
    14.             sum += ret;
    15.         }
    16.         System.out.println(sum);
    17.     }
    18. }

    练习三（1）：求一个整数，在内存当中存储时，二进制1的个数。 

    方法一：（nice）

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求一个整数，在内存当中存储时，二进制1的个数。
    4.         /*
    5.         * 不需知到要循环多少次
    6.         * 直到(通过 >>>1)整数变为0循环停止，因为为0则说明其中不在有二进制1了
    7.         * 循环内部：（通过 &1 是否等于0）判断最后一个二进制位是否为1
    8.         * */
    9.         int n = 7;
    10.         int count = 0;
    11.         while (n != 0) {
    12.  
    13.             if ((n & 1) == 1) {
    14.                 count++;
    15.             }
    16.             n >>>= 1;
    17.         }
    18.         System.out.println(count);
    19.     }
    20. }

    方法二：（算法层次的优化）

     

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         /*只要整数n不为0.就进行 n&(n-1)
    4.         * */
    5.         int n = 7;
    6.         int count = 0;
    7.         while(n!=0){
    8.             n = n&(n-1);
    9.             count++;
    10.         }
    11.         System.out.println(count);
    12.     }
    13. }

    方法三：

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求一个整数，在内存当中存储时，二进制1的个数。
    4.         /*
    5.           整数 & 1,结果是1，则最后一个二进制位就是1；结果是0，则最后一个二进制位就不是1
    6.           然后 >>
    7.           共需 >> 31次 
    8.          */
    9.         int n = 7;
    10.         int count = 0;
    11.         for (int i = 0; i < 32; i++) {
    12.             if(((n>>i) & 1) == 1){
    13.                 count++;
    14.             }
    15.         }
    16.         System.out.println(count);
    17.     }
    18. }

    方法四：

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求一个整数，在内存当中存储时，二进制1的个数。
    4.         /*
    5.         * n >> 后结果变为0时，就无需再进行比较找二进制1了*/
    6.         int n = 7;
    7.         int count = 0;
    8.         for (int i = 0; i < 32; i++) {
    9.             if(n != 0){
    10.                 if(((n>>i) & 1) == 1){
    11.                     count++;
    12.                 }
    13.             }
    14.         }
    15.         System.out.println(count);
    16.     }

    练习三（2）：求一个整数，在内存当中存储时，二进制0的个数。 

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求一个整数，在内存当中存储时，二进制0的个数.
    4.         /*1. 求出二进制1的个数，再用32减去二进制1的个数
    5.         * 2.直接求
    6.         *  >>31次（&1，结果是0则是二级制0；结果是1不是二进制0）
    7.         *
    8.         * 综合考虑：最方便的做法是求出二进制1的个数，然后用32减。
    9.         */
    10.  
    11.        /* 1. //求出二进制1的个数，再用32减去二进制1的个数
    12.         //其他求二进制1的做法见上面
    13.         int n = 7;
    14.         int count = 0;
    15.         while(n != 0){
    16.             n = n&(n-1);
    17.             count++;
    18.         }
    19.         count = 32 - count;
    20.         System.out.println(count);*/
    21.         //2. 直接求
    22.         int n = 7;
    23.         int count = 0;
    24.         for (int i = 0; i < 32; i++) {
    25.             if(((n>>i) & 1) == 0){
    26.                 count++;
    27.             }
    28.         }
    29.         System.out.println(count);
    30.  
    31.     }
    32. }

    练习四： 计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值 。
    4.         /*分母是1-100，所以首先产生1-100的数
    5.         * 分母是偶数时，分子是-1；分母是奇数时，分子是1
    6.         * 所以，产生一个分母，判断一个*/
    7.         double sum = 0.0;
    8.         for (int i = 1; i <= 100; i++) {
    9.             if((i%2)==0){
    10.                 sum +=(-1.0)/i;
    11.             }else{
    12.                 sum += 1.0/i;
    13.             }
    14.         }
    15.         System.out.println(sum);
    16.  
    17.     }
    18. }

    练习五：寻找自幂数

    一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为自幂数。

    0的0次幂没有意义

    独身数共有9个: 1，2，3，4，5，6，7，8，9；

    三位的水仙花数共有4个：153，370，371，407；

    四位的四叶玫瑰数共有3个：1634，8208，9474；

    五位的五角星数共有3个：54748，92727，93084；

    六位的六合数只有1个：548834；

    七位的北斗七星数共有4个：1741725，4210818，9800817，9926315；

    八位的八仙数共有3个：24678050，24678051，88593477；

    九位的九九重阳数共有4个： 146511208，472335975，534494836，912985153；

    十位的自幂数只有1个：4679307774

    1. import java.util.Scanner;
    2.  
    3. public class TestDemo {
    4.     public static void main(String[] args) {
    5.         //计算自幂数
    6.         //*1、计算是几位数：/10,不等于0，位数就加一
    7.         // 2、得出每一位，并且乘次幂，再加起来：先 % 再 /
    8.         // 3. 判断是否相等*/
    9.         Scanner scan = new Scanner(System.in);
    10.         while(scan.hasNextInt()){
    11.             int n = scan.nextInt();
    12.             for (int i = 1; i <= n; i++) {
    13.                 int count = 0;
    14.                 int j = i;
    15.                 while(j!=0){
    16.                     j /= 10;
    17.                     count++;
    18.                 }
    19.                 j = i;
    20.                 int sum = 0;
    21.                 while(j!=0){
    22.                     sum += Math.pow((j%10),count);
    23.                     j /= 10;
    24.                 }
    25.                 if(sum == i){
    26.                     System.out.println(i);
    27.                 }
    28.                 
    29.             }
    30.         }
    31.         scan.close();
    32.     }
    33. }

    总结：得到数字的每一位可以通过 %10，/10 来得到。

    练习六：输出X图形

    1. public class TestDemo {
    2.  public static void main(String[] args) {
    3.         /*输入 n ,坐标从0 开始
    4.         找规律发现：只有横竖坐标相同 和 横竖坐标相加 = n-1时，才是‘*’
    5.          其余都是空格*/
    6.         Scanner scanner = new Scanner(System.in);
    7.         while(scanner.hasNextInt()){
    8.             int n = scanner.nextInt();
    9.             for (int i = 0; i < n; i++) {
    10.                 for (int j = 0; j < n; j++) {
    11.                     if((i == j)||(i+j==n-1)){
    12.                         System.out.print("*");
    13.                        /* System.out.print('*');//System.out.println 会自动检索（）内是什么格式，然后以该格式输出
    14.                                                //相当于 System.out.printf("%c",'*');*/
    15.                     }else{
    16.                        /* System.out.print(' ');*/
    17.                         System.out.print(" ");
    18.                     }
    19.                 }
    20.                 System.out.println();//换行
    21.  
    22.             }
    23.         }
    24.         scan.close();
    25.  
    26.     }
    27.  
    28. }

    练习七：乘法口诀表

     

    练习八：模拟登录

     

    练习九：获取一个数二进制序列中所有的偶数位和奇数位， 分别输出二进制序列

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //获取一个数二进制序列中所有的偶数位和奇数位， 分别输出二进制序列
    4.         /*1.每次>>2：分成2个循环来做，一个循环求偶数位，一个循环求奇数位
    5.         */
    6.  
    7.         int n = 7;
    8.         for (int i = 0; i <= 30; i += 2) {//奇数位
    9.  
    10.             System.out.print(((n>>i)&1)+" ");
    11.         }
    12.         System.out.println();
    13.         for (int j = 1; j <= 31; j += 2) {//偶数位
    14.  
    15.             System.out.print(((n>>j)&1)+" ");
    16.         }
    17.  
    18.     }
    19. }

    练习十：输出1-100之间的所有素数

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //输出1-100之间的所有素数
    4.         /*素数：在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
    5.         *首先产生1-100之间的数，然后判断是不是素数：与2-开平方(n)之间的数除 */
    6.  
    7.         for (int i = 2; i <= 100; i++) {
    8.             int flag = 1;
    9.             for (int j = 2; j <= Math.sqrt(i) ; j++) {
    10.                 if(i%j == 0){
    11.                     flag = 0;
    12.                     break;
    13.                 }
    14.             }
    15.             if(flag == 1){
    16.                 System.out.print(i+" ");
    17.             }
    18.         }
    19.     }
    20. }

    练习十一（1）：求两个正整数的最大公约数 

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求两个正整数的最大公约数
    4.         /*辗转相除法：两个整数相除，余数不等于0时，除数变为原来的被除数，余数变为除数；接着相除
    5.         * 直到余数等于0，循环停止，最终最大公约数就是最新的除数*/
    6.         int a = 18;
    7.         int b = 24;
    8.         int tmp = 0;
    9.         while((a%b) != 0){
    10.             tmp = a % b;
    11.             a = b;
    12.             b = tmp;
    13.         }
    14.         System.out.println(b);
    15.  
    16.     }
    17. }

    练习十一（2）:求两个正整数的最小公倍数

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         //求两个正整数的最小公倍数
    4.         /*两个数的乘积等于这两个数的最大公约数与最小公倍数的积。
    5.         * 所以，求最小公倍数=两数的乘积/最大公约数*/
    6.         int a = 18;
    7.         int b = 24;
    8.         int ret = a*b;
    9.         int c = a % b;
    10.         while(c != 0){
    11.             a = b;
    12.             b = c;
    13.             c = a % b;
    14.         }
    15.         System.out.println(ret/b);
    16.     }
    17. }

    3. 输入输出

    3.1 输出到控制台

    • println 输出且换行, print 输出且不换行
    • printf 的格式化输出方式和 C 语言的 printf 基本一致

    3.2 从键盘输入

    3.2.1 使用 Scanner 读取字符串/整数/浮点数

    Scanner scan = new Scanner(System.in);
scan.close();用完要记得关闭
    • 导入包：Alt + 回车
    • 看Java的某个方法的源码：1. 鼠标点到这个方法上   2.按住ctrl+鼠标左键 跳转
    nextInt() 读入一个整数  
nextLine() 读入一行字符串 遇到空格也会读取 但会从缓冲区中读取字符串，当缓冲区中有字符串时，nextLine 就失效了。
next() 读入字符串 遇到空格就不会再读取了就读取结束了 正因为如此，它不会读取缓冲区里的字符串

     根据nextLine和next的特点，我们一般使用nextLine来读取字符串，并将其放在最前面防止它失效

     3.2.2 使用 Scanner 循环读取 N 个数字

    scan.hasNextInt()
scan.hasNextLine()

    当循环输入多个数据的时候, 在cmd命令行窗口使用 ctrl + z 来结束输入，在IDEA上使用ctrl+d

    4. 猜数字游戏

    1. public class TestDemo {
    2.     public static void main(String[] args) {
    3.         /*Java当中如何生成一个随机数*/
    4.        /* Random random = new Random();
    5.         int n = random.nextInt(100);//生成的随机数的范围是 [0-100)
    6.         int n2 = random.nextInt(100)+1;//生成的随机数的范围是 [1-101)
    7.         int n3 = random.nextInt(10);//生成的随机数的范围是 [0-10)
    8.         System.out.println(n3);*/
    9.         //猜数字游戏
    10.         Random random = new Random();
    11.         int n = random.nextInt(100);
    12.         Scanner scan = new Scanner(System.in);
    13.         System.out.println(n);
    14.         int tmp = 0;
    15.         int ret = 3;
    16.         while(ret != 0){
    17.             System.out.println("请猜数字，您有"+ret+"次机会");
    18.             tmp = scan.nextInt();
    19.             if(tmp > n){
    20.                 System.out.println("猜大了");
    21.                 ret--;
    22.             }else if(tmp < n){
    23.                 System.out.println("猜小了");
    24.                 ret--;
    25.             }else{
    26.                 System.out.println("恭喜您，猜对啦");
    27.                 break;
    28.             }
    29.             if(ret == 0){
    30.                 System.out.println("三次机会已用光，很遗憾您没有猜对");
    31.             }
    32.         }
    33.       scan.close();
    34.     }
    35. }

  • 相关阅读:
    VMware虚拟机以及centos7入门安装教程
    【23真题】师范强者，均分135，复试难！
    第十五天实验
    React(精读官方文档) - 高级指引 -高阶组件
    element-ui的el-table属性修改，如内边框，斑马纹，列宽度...
    模型推理详细步骤以及如何排查模型和参数字典对不上的问题：Missing key(s) in state_dict: xxxx
    13.1.X:ByteScout PDF Extractor SDK
    LeetCode844-比较含退格的字符串
    C语言文件操作 | 文件分类、文件打开与关闭、文件的读写、文件状态、文件删除与重命名、文件缓冲区
    【无标题】
  • 原文地址：https://blog.csdn.net/m0_61731585/article/details/126019405