java 循环若子级有数据一直循环查询

转载

架构领航博主 2024-10-29 09:11:21

一、流程控制

1、定义

在一个java程序中，各条语句的执行对程序的结果有直接影响，也就是说 各个语句的执行顺序对程序的结果有直接影响。
在程序中，可能出现不同的执行顺序，必须自上而下顺序执行，或者条件判断的顺序或者循环执行的顺序。

2、分类

顺序执行
条件分支
循环执行

3、顺序执行

//顺序执行， 从上而下执行 
public static void main(String [] args){
      System.out.println(1);
       System.out.println(2);
        System.out.println(3);
 }

4、条件分支

1、if条件分支

语法：

if(条件){
    语句块
}
其他代码

解释：如果条件成立，则执行语句块，如果条件不成立，则不执行语句块

java 循环若子级有数据一直循环查询_整除

// 生成一个100以内的随机数   判断它是否为偶数
     int n = (int)( Math.random()*100);
     if(n%2 == 0){
         System.out.println("这是数是偶数");
     }
     System.out.println("程序结束");

2、if...else条件分支

语法：

if(条件){
       语句块1
  }else{
      语句块2
  }

解释：如果条件成立，则执行语句块1，如果条件不成立，则执行语句块2

java 循环若子级有数据一直循环查询_i++_02

int n = (int)(Math.random()*100);
        // n<50 需要买西瓜   >50 需要买葡萄
        if(n<50){
            System.out.println("买了一个大西瓜");
        }else{
            System.out.println("买了一串葡萄");
        }
        System.out.println("n->"+n);
        System.out.println(" 嗯，程序猿的女朋友很高兴，至少买了水果");

3、if...else if...else多条件分支

语法：

if(条件1){
     语句块1
 }else if（条件2）{
     语句块2
 }else if(条件3){
     语句块3
 }
 ...
 else{
     语句块4
 }

解释：从条件1开始以此判断，如果条件1成立，则执行语句块1，其他条件不再执行，如果条件2成立，则执行语句块2......以此类推如果条件都不成立，则执行else语句块，最终只执行其中一个语句块

java 循环若子级有数据一直循环查询_System_03

// 随机生成90以内的年龄  整数
        int n = (int)(Math.random()*90);
        if(n<18){
            System.out.println("未成年");
        }else if( n<30){
            System.out.println("青年");
        }else if( n<50){
            System.out.println("中年");
        }else if( n<70){
            System.out.println("老年");
        }else{
            System.out.println("晚年");
        }
        System.out.println("n->"+n);

嵌套条件判断
语法：以上3种格式，可以同时使用，在一个if语句再次嵌套if语句

接收控制台输入 ，  判断 输入的数 是否能被3整除
          // 如果能被3整除，输出这个数除以3的结果，并判断结果能被7整除
           // 如果不能被3整除，判断是否为偶数                                                                                                                                                                                                                                                                                                                                                                                                                               

        Scanner sc = new Scanner(System.in);
        // 接收控制台输入的整数
        int n = sc.nextInt();
        if(n%3 == 0 ){
            System.out.println("这个数能被3整除");
            // 在if语句中继续判断， 就是嵌套条件判断 ，需要往后缩进
            int result= n/3;
         	if(result%7 == 0){
                System.out.println("这个结果能被7整除");
            }else{
                System.out.println("这个结果不能被7整除");
            }
        }else{
            System.out.println("这个数不能被3整除");
            if(n%2 ==0){
                System.out.println("这个数能2整除");
            }else{
                System.out.println("这个数不能被2整除");
            }
        }

注意：嵌套条件时为了增强代码的可读性，将条件语句块的分支往后缩进，{}作为一个整体
条件语句块中如果只有一个输出语句，可以省略{}

5、选择条件判断

语法：

switch（表达式）{
    case 常量值1：
       语句块1;
      break;    // 语句块接收的标记
    case 常量值2:
       语句块2；
       break;
      ...
    default: 
       语句块3；
       break；
}

注意：switch的表达式判断，只能等值比较，其中case的常量值类型为：整数型(byte short int long)，字符型，字符串型，枚举型

byte n = (byte)(Math.random()*7+1);
        switch (n){
            case 1 :
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6 :
                System.out.println("星期六");
                break;
            default :
                System.out.println("星期天");
                break;
        }

case穿透问题
在switch中，如果case后面不写break，将会出现穿透现象，也就是说不会执行下一个case的判断条件直接往后运行，知道遇到break，或整体switch结束
练习

* 1、使用switch制作一个简单的计算器：
* 让用户输入计算数字1和运算符 及计算数字2，然后程序帮他计算出结果。
*

二、循环

1、循环定义

在java程序中，重复的执行某一段代码 这个过程称之为循环，为了避免出现死循环，循环分为四部分
**1、初始条件**
**2、循环的判断条件，条件为true，则进入循环体**
**3、循环体**
**4、迭代变量**

while循环

语法：

初始条件
  while(判断条件){
      循环体
      迭代部分 （为了改变循环的判断条件）
  }

java 循环若子级有数据一直循环查询_整除_04

计算1到100的累计之和 1+2+3+4+...+100=?

初始值 n=  1
条件：  100以内的 数可以一直累加（一直循环）
迭代： n++

//计算 1到100的累加之和
        int sum=0;
        int  n=1;
        while(n<=100){
            sum+=n;
            n++;
        }
        System.out.println("n:"+n);
        System.out.println("sum:"+sum);

do...while循环

语法：

初始值1
 do{
     循环体2
     迭代部分3
 }while(返回boolean类型的表达式4)；

执行顺序：123->423->423->423...->4知道条件4为false则退出循环。
先执行初始值 1，循环体2 ，迭代3

再判断条件4是否成立，成立，继续执行2，3

...

判断条件4是否成立，不成立，退出

int i=0;
          do{
              System.out.println("i--"+i);
              i++;
          }while(i<10);

        System.out.println("i===="+i);
        /**
         * 第一遍： 输出 0   i=1
         * 第二遍： 判断 1<10  成立  输出1   i=2
         * 第三遍： 判断 2<10  成立  输出2   i=3
         * .。。
         * 第九遍： 判断8<10  成立  输出8   i=9
         * 第十遍：判断 9<10  成立 输出9    i=10
         * 第十一遍: 判断 10<10 不成立。退出
         *
         *
         */

问题 while和do while的区别？
while循环先判断条件是否成立，再执行循环体，do while循环先执行一遍循环体再判断条件。

break：退出循环

for循环

for循环的升级版就是 foreach循环
for循环通常在明确循环次数的情况下使用，它也分为四部分
语法：

for(初始值1 ; 循环判断条件2 ; 迭代部分3 ){
     循环体4
 }
 或者
  
 初始值
 for( ; 循环判断条件 ; ){
     
     循环体
     
     迭代部分
 }
 // 他们的区别是 初始值定义在for的外边，就可以在循环外边使用

循环执行流程：
1243->243->243->243->...>2 为false 循环退出
例如：循环输出hello world

// i 表示计数器，从1开始 到5结束
 for(int i=1 ;i<=5 ; i++){
      System.out.println("hello world");
  }

循环的执行顺序：

第一遍： i=1 1<5 成立输出“hello world ” i++ i=2

第二遍：2<=5 成立输出“hello world” i=3

第三遍： 3<=5 成立输出”hello world“ i=4

第四遍： 4<=5成立输出”hello world“ i=5

第五遍： 5<=5 成立输出”hello world“ i=6

第六遍： 6<=5 不成立，退出

i=6

使用for循环计算1-的阶乘

// 使用for循环 计算 10的阶乘
        for(int i=1;i<=10;i++){
            sum*=i;
        }

for 循环部分可以省略

// 死循环
        for(;;){
            System.out.println("hello");
        }

for(;true;){
           System.out.println("hello world");
        }

// 迭代部分的代码 可以 放入循环体中
  int i=0;
  for( ; i<10; ){
  System.out.println("第"+i+"次输出");
  i++;
  }

三、关键字 break、continue 、return的区别

1、break ：用于在switch。。case中放置语句块穿透，

用于跳出循环

// 从1-100  遇到7的倍数 break
         for(int i=1;i<100;i++){
             // i==7 跳出循环
             if(i%7 == 0 ){
                 break;
             }
             System.out.println(i);
         }

2、continue：跳出本次循环，继续下一次循环

for(int i=0;i<100;i++){
              if(i%7 == 0 ){
                  continue;  // 跳出本次循环，继续下一次循环
              }
              System.out.println("i---"+i);
    }

3、return ：返回本次方法

用法1 ： 如果return放在循环中， 会跳出循环，且不会只想循环外面的语句 ，

 用法2： 作为方法的返回值   

 用法3 ： 无论方法是否有返回值 ，可以在条件判断的位置 直接 return ，

return和break在循环语句块是，break只是结束循环语句块，对于循环外面的代码会执行，而return是结束当前所在方法的剩下的语句块。

public static void main(String[] args) {
          for(int i = 1;i<100;i++) {
              if (i == 50) {
                  return;
              }
              System.out.println("i----"+i);
          }

         System.out.println("程序结束");

   }

  public void method1(){
        // return 还可以在条件判断的位置 直接返回方法
       int n = (int)(Math.random()*10);
       if(n%2 ==0){
           return  ; // 方法的后面就不再运行
       }
       System.out.println("方法的其他代码块");
       
   }

结论：只要执行return，那么它后面的代码都不执行。

public int add(){
     return 0;
    
 }

return作为方法返回值的关键字，

四、嵌套循环以及案例

嵌套循环：在一个循环语句中，还包含了另一个循环。例如在一个for循环中还有一个for循环，

它的总的循环次数 = 外循环的次数* 内循环的次数

语法：

for(){    // 外层循环

      for(){   // 内层循环

      }

  }

执行顺序：外层循环循环一次，内层循环循环完整的一遍

打印直角三角形

* 
* * 
* * * 
* * * * 
* * * * *

外循环控制打印几行，内循环控制打印即可*

*
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

思路 : 考虑一行打多少个空格多少个*
一共5 行空格的个数（5-i） *的个数（2 * i - 1）
i=1 4 1

i=2 3 3

i=3 2 5

i=4 1 7

i=5 0 9

System.out.println("打印正三角形");
            for(int i=1;i<=5;i++){
                // 先打印空格
                for(int k=0;k<5-i;k++){
                    System.out.print("  ");
                }
                // 再打印*
                for(int j=0;j<2*i-1;j++){
                    System.out.print("* ");
                }
                // 换行
                System.out.println();
            }

九九乘法表
1 *1=1
1 *2=2 2 *2=4
1 *3=3 2 *3=6 3 *3=9
1 *4=4 2 *4=8 3 4=12 44=16
....
1 *9=9 2 9=18 ...... 99=81

public static void main(String[] args) {
        int s=1;
        for (int row=1;row<=9;row++){
            for (int column=1;column<row+1;column++){
                    s=row*column;
                System.out.print(row+"*"+column+"="+s+"\t");
            }
            System.out.println();
        }
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。