精华内容
下载资源
问答
  • asp循环语句总结

    2021-01-02 22:40:15
    循环语句的作用就是重复执行程序代码,循环可分为三类:一类在条件变为“假”之前重复执行语句,一类在条件变为“真”之前重复执行语句,另一类按照指定的次数重复执行语句。在VBScript 中可使用下列循环语句: Do…...
  • 这个时候一个重要的解题思路就很重要,一旦知道这一类型题的思想很多题都迎刃而解。 我会把这些题的源代码放上来供参考。 第一 ' * ' 三角形 class Test{ public static void main(String[] args){...

    很多初入程序员世界的新人小白都和我一样都会遇到

    这样


         

       这样  


          

    还有这样的题目


      

    这个时候有一个重要的解题思路就很重要,一旦知道这一类型题的思想很多题都迎刃而解。

    我会把这些题的源代码放上来供参考。

    第一类  ' * '  三角形

    class Test{
        public static void main(String[] args){
            //嵌套循环
            for(int line=1;line<=4;line++){
                for(int i=1;i<=8;i++){
                    System.out.print("*");
                }
                System.out.println();
            }
            /* 
                *           1
                **          2
                ***         3
                ****        4
                *****       5
                *******     6
                ********    7
            循环体 *
            */
            for(int line=1;line<=7;line++){
                for(int i=1;i<=line;i++){
                    System.out.print("*");
                }
                System.out.println();
            }
            /*              i   j
                *           1   1
                **          2   1 2
                ***         3   1 2 3
                ****        4   1 2 3 4
                *****       5   1 2 3 4 5
                ******      6   1 2 3 4 5 6
                *****       7   1 2 3 4 5 
                ****        8   1 2 3 4
                ***         9   1 2 3
                **          10  1 2
                *           11  1
                j<=i && j<=12-i
            */
            for(int i=1;i<=11;i++){
                for(int j=1;j<=i&&j<=12-i;j++){
                    System.out.print("*");
                }
                System.out.println();
            }
            /*          k=|i-6| |k| 当前行的最大的空格数
                        k    i   j
                     * -5    1   1
                    ** -4    2   1 2
                   *** -3    3   1 2 3
                  **** -2    4   1 2 3 4
                 ***** -1    5   1 2 3 4 5
                ******  0    6   1 2 3 4 5 6
                 *****  1    7   1 2 3 4 5 
                  ****  2    8   1 2 3 4
                   ***  3    9   1 2 3
                    **  4    10  1 2
                     *  5    11  1
            */
            for(int i=1;i<=11;i++){
                for(int k=1;k<=Math.abs(i-6);k++){
                    System.out.print(" ");
                }
                for(int j=1;j<=i&&j<=12-i;j++){
                    System.out.print("*");
                }
                System.out.println();
            }
            /*          k=|i-6| |k| 当前行的最大的空格数
                                k    i   j
                     *         -5    1        1
                    * *        -4    2       1 2
                   * * *       -3    3      1 2 3
                  * * * *      -2    4     1 2 3 4
                 * * * * *     -1    5    1 2 3 4 5
                * * * * * *     0    6   1 2 3 4 5 6
                 * * * * *      1    7    1 2 3 4 5 
                  * * * *       2    8     1 2 3 4
                   * * *        3    9      1 2 3
                    * *         4    10      1 2
                     *          5    11       1
            */
            for(int i=1;i<=11;i++){
                for(int k=1;k<=Math.abs(i-6);k++){
                    System.out.print(" ");
                }
                for(int j=1;j<=i&&j<=12-i;j++){
                    System.out.print("* ");
                }
                System.out.println();
            }
            /*          k=|i-6| |k| 当前行的最大的空格数
                                k    i   j
                     *         -5    1        1
                    * *        -4    2       1 2
                   *   *       -3    3      1 2 3
                  *     *      -2    4     1 2 3 4
                 *       *     -1    5    1 2 3 4 5
                *         *     0    6   1 2 3 4 5 6
                 *       *      1    7    1 2 3 4 5 
                  *     *       2    8     1 2 3 4
                   *   *        3    9      1 2 3
                    * *         4    10      1 2
                     *          5    11       1
                    j==1 j==i j+i==12
            */
            for(int i=1;i<=11;i++){
                for(int k=1;k<=Math.abs(i-6);k++){
                    System.out.print(" ");
                }
                for(int j=1;j<=i&&j<=12-i;j++){
                    if(j==1||j==i||j+i==12){
                        System.out.print("* ");
                    }else{
                        System.out.print("  ");
                    }
                }
                System.out.println();
            }
        }
    }

    第二类数字三角形

    class text{
        public static void main(String[] args){
            for(int i=1;i<7;i++){
                for(int j=1;j<=i;j++){
                    System.out.print(j);
                }
                System.out.println();
            }
            System.out.println("~~~~~~~~~~~~~~~~~~~");
            for(int i=1;i<7;i++){
                for(int j=1;j<8-i;j++){
    
                    System.out.print(j);
                }
                System.out.println();
            }
            System.out.println("~~~~~~~~~~~~~~~~~~~");
             for(int i=1;i<7;i++){
                for(int j=1;j<=7-i;j++){
                    System.out.print(" ");
                    }
                    for(int k=i;k>0;k--){
                        System.out.print(k);
                    }
                System.out.println();
            }
            System.out.println("~~~~~~~~~~~~~~~~~~~");
            for(int i=1;i<7;i++){
                for(int j=1;j<=i;j++){
                    System.out.print(" ");
                }
                for(int k=1;k<8-i;k++){
    
                    System.out.print(k);
                }
                System.out.println();
            }
        }
    }

    第三类数字金字塔

    import java.util.Scanner;
    class text{
    public static void main(String[] args){
          Scanner input=new Scanner(System.in);
            System.out.print("输入金字塔的高度:");
            int n =input.nextInt();
    		for(int i=0;i<=n;i++){
    			for (int j = n; j >i; j--) {
    			    System.out.print(" ");
    			}
    			for (int j = i; j >=1; j--) {
    			    System.out.print(j);
    			}
    			for (int j = 2; j <=i; j++) {
    				    System.out.print(j);
    			}
    			System.out.println();
            }
    	}
    }
    
    import java.util.Scanner;
    public class text{
        public static void main(String[] args){
            int i=0,n=8,m=0,s;
            while(n>0){
                s=1;
                for(i=4*(n-1); i>0; --i)
                    System.out.print(" ");
                System.out.print("   ");
                for(i=0; i<=m; ++i){
                    s*=2;
                    System.out.print(s/2+" ");
                    if(s<10)
                        System.out.print("  ");
                    else if(s>9&&s/2!=64)
                        System.out.print(" ");
                    else if(s/2>99)
                    	 System.out.print("  ");
                }
                for(i=m; i>=m; --i){
                    s/=2;
                    if(m==3||m==4||m==6)
                    	System.out.print(" ");
                    if(s/2!=0){
                         if(s/2<10)
                        System.out.print(s/2+"  ");
                    else if(s/2>9){
                    	System.out.print(s/2+" ");
                    if(s/4<9)
                        System.out.print(" ");
                    }
                    else
                    	System.out.print(s/2);
                    System.out.print(" ");}
                }
                for(i=m-1; i>0; --i){
                    s/=2;
                    if(s/2<10)
                        System.out.print(s/2+"  ");
                    else if(s/2>9){
                    	System.out.print(s/2+" ");
                    if(s/4<9)
                        System.out.print(" ");
                    }
                    else
                    	System.out.print(s/2);
                    System.out.print(" ");
                }
                System.out.println();
                --n;
                ++m;
            }
        }
    }
    

     

    展开全文
  • 如果人告诉你学习 ASP 不需要任何编程知识,那么他错了;如果我告诉你学习 ASP 必须掌握一门编程... 循环语句的作用就是重复执行程序代码,循环可分为三类:一类在条件变为“假”之前重复执行语句,一类在条件变
  • switch语句及循环语句

    千次阅读 多人点赞 2019-07-31 18:21:21
    switch语句 语句格式 switch(表达式){ case 1: 语句1; break; case 2: 语句2; break; .... default: 语句体n+1; break; } 执行流程 首先计算出表达式的值 其次,和case依次比较,...

    switch语句

    语句格式

    switch(表达式){
        case 1:
            语句1;
           break;
        case 2:
            语句2;
            break;
            ....
         default:
            语句体n+1;
            break;
    }
    

    执行流程

    • 首先计算出表达式的值

    • 其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结 束。

    • 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。

      代码案例1:

      /*
         switch 语句
         格式:
         switch(表达式){
      	    case1:  
      			语句体1;
      			break;
              case2  
      			语句体2;
      			break;
              ....		
      		defualt:
      		语句体3;
      		break;   
         }   
        案例:
        输入一个月份确认是哪个季节?
        分析:
        1、涉及键盘输入所以需要导包
        2、创建对象
        3、接受对象
           1、2、12  为冬季
      	 3、4、5   为春季
      	 6、7、8   为夏季
      	 9、10、11 为秋季
      */
      //1、导包
      import java.util.Scanner;
      public class five{
      	public static void main(String[] args){
      		//创建对象
      		Scanner sc = new Scanner(System.in);
      		//接受对象
      		System.out.println("请输入一个月份:");
      		int mouth = sc.nextInt();
      		//因涉及选择所以用switch语句
      		switch(mouth){
      			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;
      			case 7:
      			System.out.println("夏季");
      			break;
      			case 8:
      			System.out.println("夏季");
      			break;
      			case 9:
      			System.out.println("秋季");
      			break;
      			case 10:
      			System.out.println("秋季");
      			break;
      			case 11:
      			System.out.println("秋季");
      			break;
      			case 12:
      			System.out.println("冬季");
      			break;
      			default	:
                  System.out.println("你输入的有误");
      			break;			
      		}
      		
      	
      	}
      }
      

      代码案例2:

      对上面的代码进行优化

      //1、导包
      import java.util.Scanner;
      public class five{
      	public static void main(String[] args){
      		//创建对象
      		Scanner sc = new Scanner(System.in);
      		//接受对象
      		System.out.println("请输入一个月份:");
      		int mouth = sc.nextInt();
      		//因涉及选择所以用switch语句
      		switch(mouth){
      			case 3:
      			case 4:
      			case 5:
      			System.out.println("春季");
      			break;
      			case 6:
      			case 7:
      			case 8:
      			System.out.println("夏季");
      			break;
      			case 9:
      			case 10:
      			case 11:
      			System.out.println("秋季");
      			break;
      			case 12:
      			case 1:
      			case 2:
      			System.out.println("冬季");
      			break;
      			default	:
                  System.out.println("你输入的有误");
      			break;			
      		}
      	}
      }
      

    for循环

    语句格式

    for(初始化语句;条件判断语句;条件控制语句){
        循环语句体;
    }
    

    执行流程

    ①执行初始化语句

    ②执行条件判断语句,看其结果是true还是false

    ​ 如果是false,循环结束

    ​ 如果是true,继续执行

    ③执行循环体语句

    ④执行条件控制语句

    ⑤回到②继续

    代码案例

    1、输出数据

    需求:在控制台输出1-5和5-1的数据

    /*
       for循环语句
        
    	for(初始化语句;条件判断语句;条件控制语句){
    		循环语句;
    	}
    	
    	 需求:在控制台输出1-5和5-1的数据 
    	 分析:
    	 用fou循环语句实现1-5和5-1的数据输出 
    */
    public class five{
    	public static void main(String[]args){
    		
    		for(int i =1;i <= 5; i++){
    			System.out.println(i);
    		}
    	
    		for(int j =5;j >= 1; j--){
    			System.out.println(j);
    		}	
    	}
    }
    

    2、输出数据求和

    需求:求1-5之间的数据和,并把求和结果在控制台输出

    /*
       for循环语句
        
    	for(初始化语句;条件判断语句;条件控制语句){
    		循环语句;
    	}
    	
    	 需求:求1-5之间的数据和,并把求和结果在控制台输出 
    	 分析:
    	 求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0  
    */
    public class five{
    	public static void main(String[]args){
    		//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
    		int num = 0;
    		for(int i = 1;i <= 5; i++){
    			num +=i;	
    		}
    		System.out.println("数据的和为:" + num);
    		}	
    	}
    

    3、求偶数和

    需求:求1-100之间的偶数和,并把求和结果在控制台输出

    /*
       for循环语句
        
    	for(初始化语句;条件判断语句;条件控制语句){
    		循环语句;
    	}
    	
    	 需求:求1-100之间的偶数和,并把求和结果在控制台输出
    	 分析:
    	 //求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0  
    */
    public class five{
    	public static void main(String[]args){
    		int num = 0;
    		for(int i = 1; i <=100; i++){
    			//因为要求1-100之间的偶数和
    			if(i%2==0);{
    				num += i;	
    			}	
    		}
    		System.out.println("数据的偶数和为:" + num);
    		}	
    	}
    

    4、水仙花

    需求:在控制台输出所有的“水仙花数”

    解释:什么是水仙花数?

    水仙花数,指的是一个三位数,个位、十位、百位的数字立方和等于原数

    例如`153 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153‘

    1. 获取所有的三位数,准备进行筛选,最小的三位数为100,最大的三位数为999,使用for循环获取

    2. 获取每一个三位数的个位,十位,百位,做if语句判断是否是水仙花数

      /*
         for循环语句
          
      	for(初始化语句;条件判断语句;条件控制语句){
      		循环语句;
      	}
      	
      	 需求:在控制台输出所有的“水仙花数” 
      	 分析:
      	 1. 获取所有的三位数,准备进行筛选,最小的三位数为100,最大的三位数为999,使用for循环获取
      	 2. 获取每一个三位数的个位,十位,百位,做if语句判断是否是水仙花数 
      */
      public class five{
      	public static void main(String[]args){
      		//输出所有的水仙花数必然要使用到循环,遍历所有的三位数,三位数从100开始,到999结束
      		for(int num = 100; num <=999; num++){
      	   //获取每一个三位数的个位,十位,百位,做if语句判断是否是水仙花数
      	   int ge=num%10;
      	   int shi=num/10%10;
      	   int bai=num/10/10%10;
      	   //判定条件是将三位数中的每个数值取出来,计算立方和后与原始数字比较是否相等
      	   if(ge*ge*ge + shi*shi*shi + bai*bai*bai == num){
      		   //输出满足条件的数字就是水仙花数
      		   System.out.println(num);
      				}	
      			}		
      		}		
      	}	
      

    while循环

    语句格式

    初始化语句;
    while (条件判断语句){
        循环语句;
        条件控制语句;    
    }
    

    执行流程

    ①执行初始化语句

    ②执行条件判断语句,看其结果是true还是false

    ​ 如果是false,循环结束

    ​ 如果是true,继续执行

    ③执行循环体语句

    ④执行条件控制语句

    ⑤回到②继续

    代码案例

    需求:在控制台输出5次"HelloWorld"

       //需求:在控制台输出5次"HelloWorld"
    public class Demo02 {
           public static void main(String[] args) {
               //for循环实现
               for (int i = 1; i <= 5; i++){
                   System.out.println("HelloWorld");
               }
               System.out.println("-------");
               //while循环
               int j = 1;
               while(j <= 5){
                   System.out.println("HelloWorld");
                   j++;
               }
           }
    }
    
    

    while循环练习:纸和珠穆朗玛峰

    需求:
    ​ 世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米。
    ​ 请问,我折叠多少次,可以折成珠穆朗玛峰的高度?

    public class Demo03 {
        public static void main(String[] args) {
            //因为求和要定义一个数值,初始化为0
            int count = 0;
            //定义珠峰的高度
            int zf = 8844430;
            //定义纸的厚度
            double paper = 0.1;
            //因为要反复折叠,所以要使用循环,但是不知道折叠多少次,这种情况下更适合使用while循环
            //折叠的过程中当纸张厚度大于珠峰就停止了,因此继续执行的要求是纸张厚度小于珠峰高度
            while (paper <= zf){
                paper*=2;
                System.out.println(paper);
                count++;
            }
            System.out.println("折叠的次数为:" + count + "次");
        }
    
    }
    
    

    while循环练习:皇帝赏农民

    需求:皇帝赏农民
    ​ 古代有一个农民,救了皇帝的儿子。皇帝大喜,奖赏农民!黄金万两、良田千亩。
    ​ 农民说:第一天给我1块钱,第二天给我2块钱,第三天给我4块钱~~~~ 连续给我一个月!

    /*
    *  需求:皇帝赏农民
    		古代有一个农民,救了皇帝的儿子。皇帝大喜,奖赏农民!黄金万两、良田千亩。
    		农民说:第一天给我1块钱,第二天给我2块钱,第三天给我4块钱~~~~ 连续给我一个月!
    
    * */
    public class Demo04 {
        public static void main(String[] args) {
            //因为要求钱数的总和所以要定义一个数值,初始为0
            int monery = 0;
    
            //定义一个钱的变量,初始为1
            int i = 1;
            //第一天给我1块钱,第二天给我2块钱,第三天给我4块钱;涉及循环,j*=2
            for (int j = 1; j <=30; j++) {
                i *= 2;
                monery += i;
                System.out.println("每天给的钱为:" + j);
            }
             System.out.println("连续给一个月的钱为:" + monery);
        }
    }
    

    do-while循环

    定义格式

    初始化语句
     do{
        循环语句;
        条件控制语句;
       }while(条件判断语句);
        
    

    执行流程

    • ①执行初始化语句
    • ②执行循环体语句
    • ③执行条件控制语句
    • ④执行条件判断语句,如果为true
    • ②->③->④ 直到条件为false结束

    执行特点

    • do-while循环无论条件是否满足,都至少执行一遍循环体

    代码案例

    public class Demo05 {
        public static void main(String[] args) {
            int i = 1;
            do {
                System.out.println("HelloWorld");
                i++;
            }while(i <= 5);
        }
    }
    

    do-while循环和for、while循环的区别

    1、do-while循环需要执行一遍循环体

    2、for、while循环先进行判断,再执行循环

    for循环和while循环的区别

    当循环的次数明确的时候,推荐使用for循环

    代码案例

    需求:打印1~100之间的所有的8的倍数的数字

    //需求:打印1~100之间的所有的8的倍数的数字
    public class Demo06 {
        public static void main(String[] args) {
            for (int i = 1; i <= 100; i++){
                //因为涉及打印1~100之间的所有的8的倍数的数字需要判定是否属于;需要加if语句
               if (i%8==0){
                   System.out.println(i);
               }
            }
        }
    }
    

    当循环的次数不明确的时候,推荐使用while循环

    需求:通过键盘不断的接收数字并打印。直到输入的数字是886则停止

    
    //需求:通过键盘不断的接收数字并打印。直到输入的数字是886则停止
    public class Demo07 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            while(true){
                System.out.println("请输入你想输入的数值:");
                int  num = sc.nextInt();
    
            if (num == 886){
                System.out.println("你输入的值为:" + num);
             break;
            }
                System.out.println("你输入的值为:" + num);
            }
        }
    }
    

    循环嵌套

    跳转控制语句

    • break关键字

      • 作用:可以结束循环和switch语句
      • 使用场景:可以用在循环中,也可以用在switch语句中
    • continue关键字

      • 作用:结束本次循环,继续下一次循环
      • 使用场景:只能用在循环中

      案例代码

      需求:
      ​ 1.我想在控制台输出2次我爱学习Java break
      ​ 2.我想在控制台输出7次我爱学习Java continue
      ​ 3.我想在控制台输出13次我爱学习Java

      /*
      * 需求:
      		1.我想在控制台输出2次我爱学习Java     break
      		2.我想在控制台输出7次我爱学习Java     continue
      		3.我想在控制台输出13次我爱学习Java
      * */
      public class Demo08 {
          public static void main(String[] args) {
              for (int i = 1; i <= 10; i++){
                if (i%3 != 0){
                    System.out.println("我爱学习");
                    //break;
                    //continue;
                }
              }
              System.out.println("我爱学习");
          }
      }
      
      

    循环嵌套

    执行特点:外循环执行一次,内循环执行一圈

    示例代码

    for(int hour=0; hour<24; hour++) {	// hour = 1
    			for(int minute=0; minute<60; minute++) {	// minute = 60
    				System.out.println(hour + "时" + minute + "分");
    				// 0时0分
    				// 0时1分
    				// 0时2分
    				// 0时59分
    			}
    			System.out.println("--------");
    		}
    

    循环嵌套练习:输出指定*型

    /*
    * 需求1:控制台输出:
    	****
    	****
    	****
    	****
    	输出4行4列的*
    
    	外循环控制的是行数,内循环控制的是列数
    
    	需求2:控制台输出:
    	*
    	**
    	***
    	****
    
    	作业题:输出99乘法表
    	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 4*4=16
    	...
    * */
    public class Demo09 {
        public static void main(String[] args) {
            for (int i = 1; i <= 4; i++) {
                for (int j = 1; j <= 4; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
    
            System.out.println("--------------------");
    
            for (int i = 1; i <= 4; i++) {
                for (int j = 1; j <= i; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
        }
    }
    
    

    循环嵌套练习:输出99乘法表

    /*
    * 作业题:输出99乘法表
    	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 4*4=16   内循环为列,外循环为行
    	...
    * */
    public class Demo10 {
        public static void main(String[] args) {
    
    
    
             for (int i = 1; i <= 9; i++){
    
                 for (int j = 1; j <= i; j++){
                     System.out.print(j + "*" + i + "=" + (i*j) + ",");
                 }
                   System.out.println();
            }
        }
    }
    
    

    随机数

    Random类使用步骤

    • 导包:import java.util.Random;
    • 创建对象:Random r = new Random();
    • 生成随机数:r.nextInt(数字); 0 ~ 数字-1

    代码案例

    import java.util.Random;
    
    public class Demo11 {
        public static void main(String[] args) {
            Random r = new Random();
            int i = r.nextInt(10);
            System.out.println(i);
        }
    }
    
    

    猜数字游戏

    //  需求:要完成猜数字的游戏,需要有一个要猜的数字,使用随机数生成该数字,范围1到100
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class Demo11 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            //请输入一个任意数
           // System.out.println("请输入一个任意数:");
            //int j = sc.nextInt(); 这个要放在循环之内,因为每次都要输入数字,参与循环
            Random r = new Random();
            //随机生成一个范围数字
            int i = r.nextInt(100)+1;
    
    
            while(true){
                System.out.println("请输入一个任意数:");
                //请输入一个任意数
                int j = sc.nextInt();
                //比较输入的数字和系统产生的数据,需要使用分支语句。这里使用if..else..if..格式,根据不同情况进行猜测结果显示
                if (j<i){
                    System.out.println("你猜的数小了");
                }else if (j>i){
                    System.out.println("你猜的数大了");
                } else {
                    System.out.println("你猜对了");
                    break;
                }
                }
            }
    }
    
    

    补充的循环的两个思想

    循环标号

    public class Demo01 {
        public static void main(String[] args) {
            //对循环进行标号
           w:
            for (int i = 1; i < 3; i++) {
                n:
                for (int j = 1; j < 5; j++) {
                    System.out.println(j);
                    if (j == 3) {
                        //停止外循环就会输出一次
                        break w;
                    }
                }
            } 
    
    

    循环分析思想

      public class Demo01 {
        public static void main(String[] args) {
      // 需求:判断是有有3这个数字,有这个数字则输出有3这个数字;没有则输出没有3这个数字
           //定义一个布尔类型变量
            boolean  flage = false;
            for (int i = 1; i <= 5;i++){
                if (i==3){
                    flage = true; //r如果有3这个数字,将从新定义为ture
                }
            }//整个循环结束
            //在进行判断输出的是否有3
            if (flage == true){
                System.out.println("有3这个数字");
            }else{
                System.out.println("没有3这个数字");
            }
            System.out.println("----------------");
        }
    }
    
    
    展开全文
  • Java循环语句

    千次阅读 多人点赞 2019-07-09 11:34:09
    Java循环结构 第一节:循环结构 1.1 什么是循环 循环就是在循环条件满足的情况下,反复执行特定代码。 1.2 为什么要使用循环 当我们要打印100次helloworld 或者我们想实现1-10的和 1+2+3+4+5.... int sum = 0; sum ...

    Java循环结构

    第一节:循环结构

    1.1 什么是循环
    循环就是在循环条件满足的情况下,反复执行特定代码。
    
    1.2 为什么要使用循环
    当我们要打印100次helloworld
    或者我们想实现1-10的和
    1+2+3+4+5....
    int sum = 0;
    sum = sum + 1;
    sum = sum + 2;
    sum = sum + 3;
    sum = sum + 4;
    sum = sum + 5; 
    可以发现有一些是相同的内容。这些相同的内容我们就可以采用循环的方式来实现
    
    1.3 循环的分类
    1. while 循环
    2. do/while 循环
    3. for循环
    4.循环的组成部分
    1. 初始化部分:对循环变量赋初值
    2. 循环条件部分:判断循环条是否为true,则执行,否则不执行。
    3. 循环体部分:要循环执行的具体逻辑.
    4. 更新循环变量部分:修改循环变量的值

    第二节 : while循环

    2.1 格式:
     while (boolean表达式) {语句块}
    
    2.2 执行过程
     先判断表达式的值。若为true.则执行循环体,然后再次判断条件并反复执行,直到条件不成立为止。
     特点:先判断再执行。
    
    2.3.1 练习一:需求: 打印输出5次helloworld
    // 初始化部分
    int count = 0;
    // 2循环条件 
    while(count<5){//  1 2 3 
        //3循环体
    	System.out.println("hello world");
        //4更新循环变量
    	count++;
    }
    
    2.3.2 练习二:需求 : 打印输出 1–10
    int i =1;
    while(i<=10){
    	System.out.println(i);
     	i++;
    }
    
    2.3.3练习三:求1-100的和
    //1初始化变量
    int i=1;
    int sum=0;//保存和
    //2循环条件
    while(i<=100){
      sum=sum+i;//sum+=i;	
      i++;
    }
    System.out.println("1-100的和是:"+sum);
    
    2.3.4 练习四:需求 : 求 10 的阶乘
    int sum = 1;
    int j = 1;
    while(j<=10){
       	sum=sum*j;
       	j++;
    }
    System.out.println("10的阶乘"+sum);
    
    2.3.5 练习五:求 100以内的 偶数的和
    int z=2;
    int sum=0;
    while(z<=100){
      sum=sum+z;
      z+=2;
    }
    System.out.println("1-100的偶数的和是:"+sum);int z=1;
    int sum=0;
    while(z<=100){
      if(z%2==0){
        sum=sum+z;
      }
      z++;
    }
    System.out.println("1-100的偶数的和是:"+sum);
    

    第三节: do-while循环

    3.1格式
    do  {语句块}while(表达式) ;
    
    3.2 执行过程
    先执行语句,再判表达式的值,若为true,再执行语句,否则结束循环。
    特点:先执行,再判断。
    
    3.3.1 练习: 打印三次helloworld
    // 1 初始化部分
    int i = 0;
    do{
       // 2 循环体
       System.out.println("Hello World!");
       // 4 循环变量变化部分
    	i++;
    }while(i<3);// 3 循环条件
    
    3.3.2 用do/while实现打印100以内的奇数
    int j = 1;
    do{
    /*if(j%2==1){
    	System.out.println(j);
    }
    j++;*/
    	System.out.println(j);
    	j+=2;
    }while(j<100);
    
    3.3.3 100 以内能够被3整除 但是不能被5整除的数打印输出
    int z = 3;
    do{
    	if(z%3==0 && z%5!=0){
    	    System.out.println(z);
    	}
    	z++;
    }while(z<=100);
    
    3.4 while 和 do-while的区别

    while 和 do/while 的区别:

    while 先执行循环条件,然后在执行循环体,一句话:先判断,再执行

    do/while 先执行循环体 然后在执行循环条件,一句话:先执行,再判断

    当第一次 就不满足循环条件的情况下 while循环不能执行循环体, do while 可以执行一次

    第四节 : for循环

    4.1 格式
    for (表达式1 [循环变量初始化]; 表达式2 [循环条件判断]; 表达式3 [更新循环变量的值]){
             	循环体
    }
    
    4.2 执行过程
    首先计算表达式1,接着计算表达式2,若表达式2的值为true,则执行循环体,接着计算表达式3,再判断表达式2的值.依此重复下去,直到表达式2的值=false。
    特点:先判断,再执行。
    
    4.3.1 练习: 需求: 打印输出3次helloworld
    for(int i = 0;i<3;i++){
    	System.out.println("Hello World!");
    }
    
    4.3.2 练习: 打印100以内 能被4整除,不能被7整除的数据,每行打印6个
    int count = 0;
    for(int i = 1; i<=100; i++){
    	if(i%4==0 && i%7!=0){
    		System.out.print(i+"\t");
    		count++;// 6 
    		if(count%6==0){
    			System.out.print("\n");
    		}		
    	}
    }
    
    4.4 for循环的特殊形式
    1. 表达式2一般不可省略,否则为无限循环(死循环)
     for (i=1; ; i++)   sum=sum+i;
        // 相当于条件永真、永不为false
    2. 表达式3亦可省略,但在循环体中须有语句修改循环变量;以使表达式2在某一时刻为false而正常结束循环。
      for (int sum=0,i=1 ;i<=100; ){ 	
         sum=sum+i;
         i++;
      }
    3. 若同时省略表达式1和表达式3,则相当于while(表达式2)语句
      int i=0;
      for ( ; i<=100; ) {sum+=i; i++;}
    4. 三个表达式均省略 即for(;;)语句,此时相当于while(true)语句.
    
    4.5 三种循环的比较和注意事项
    三种循环的比较:
    1 语法不一样  
    	while(条件){...}
    	do{...}while(条件);
    	for(表达式1;表达式2;表达式3){...}
    2 执行顺序
       whilefor 都是先判断条件 ,然后再执行循环体
       do while 先执行循环体,再判断条件
    
    注意事项
    1. 对于同一问题, 三种循环可相互替代。
    2. 循环次数确定的情况优先选用for循环,循环次数不确定的情况,通常选用whiledo-while循环。
    3. 要防止无限循环––死循环。
    

    第五节 :多重循环:二重循环

    多重循环就是循环中嵌套其他循环。

    特点:外层循环执行一次,内层循环执行一遍。

    5.1 练习一:

    使用*号打印矩形。

    // 外层循环控制行     内层循环 控制列
    //  *******
    //	*******
    //	*******
    //	*******
    
    for (int j = 0;j<4 ; j++){
    	for(int i = 0; i< 7 ; i++){
    		System.out.print("*");
    	}
    	System.out.println();
    }
    
    5.2 练习二:

    打印直角三角形

    /*
     找规律
       *			   1       1
       **			   2	   2
       ***
       ****
       *****		   5        5 
    		
    */
    for (int i = 1;i<=5 ;i++ ){
    	// 1 2 3 4 5 
    	for (int j = 1;j<=i ;j++ ){
    		System.out.print("*");
        }
    	System.out.println();
    }
    
    5.3 练习三:

    输出等腰三角形

    [外链图片转存失败(img-3hlPZbcO-1562643125439)(images/001.png)]

    *                  1    1    1*2-1
    ***                2    3    2*2-1
    *****              3    5	 3*2-1
    *******            4    7    4*2-1
    *********          5    9    5*2-1
    
        *              1    4    5-1=4
       ***             2    3    5-2=3
      *****            3    2    5-3=2
     *******           4    1    5-4=1
    *********          5    0    5-5=0
    
    for (int i = 1;i<=5 ;i++ ){
      	//空格
      	for(int k=1;k<=5-i;k++){
            System.out.print(" ");
        }
    	// 1 2 3 4 5 
    	for (int j = 1;j<=i*2-1 ;j++ ){
    		System.out.print("*");
        }
    	System.out.println();
    }
    
    5.4 练习四:

    输出九九乘法表

    *
    **
    ***
    ****
    *****
    
    1*1=1
    1*2=2 2*2=4
    1*3=3 2*3=6  3*3=9
    
    // 99乘法表
    for (int i = 1;i<=9 ;i++ ){
    	for (int j = 1;j<=i ;j++ ){
    		System.out.print(i+"*"+ j+"="+i*j+"\t");
    	}
    	System.out.println();
    }
    

    第六节: 跳转语句–流程控制语句

    **break:**语句用于终止某个语句块的执行

    **continue:**语句用于跳过某个循环语句块的一次执行,继续下一次执行(结束本次循环,继续下一次循环)

    6.1 break
    • 使用场合

      • switch结构中:跳出(终止)switch语句
      • 循环结构中:跳出(终止)循环
    • 作用:退出switch和循环结构(如果有多重循环,默认跳出离自己最近的循环)。

      for (int i = 1; i <3 ; i++ ){
      	for (int j = 1;j<5 ;j++ ){
      			if(j == 2){
      				break;// 可以指定  跳出的循环 
      			}
      			System.out.println(i+" "+j);
      	}
         
      }
      

    使用Lable标签实现跳出指定的循环。(了解)q

    out : for (int i = 1; i <3 ; i++ ){//定义一个标签out
    		 for (int j = 1;j<3 ;j++ ){
    				if(j == 2){
    					break out;// 可以指定  跳出的循环 
    				}
    				System.out.println(i+" "+j);
    		}
    	}
    

    上机练习1:

    打印1到10个数,遇到4的倍数程序自动退出

    提示:如果i%4==0,则执行break命令

    6.2 continue
    • 使用场合
      • continue只能用在循环结构中
    • 作用: 跳过本次循环,执行下一次循环(如果有多重循环,默认继续执行离自己最近的循环)。)
    	for (int i = 1;i<4 ;i++){
    			for (int j = 1;j<4 ;j++ ){
    				if(j==2){
    					continue;
    				}
    				System.out.println("i="+i + "  j="+j);
    			}
    	}
    	System.out.println("Hello World!");
    

    使用Label标签改变继续执行的循环

    	out: for (int i = 1;i<4 ;i++ ){
    			for (int j = 1;j<4 ;j++ ){
    				if(j==2){
    					continue out ;
    				}
    				System.out.println("i="+i + "  j="+j);
    			}
    		}
    		System.out.println("Hello World!");
    
    展开全文
  • 常见循环语句

    千次阅读 2019-01-25 16:44:29
    switch switch语句的格式: switch(表达式){ case 常量值1: 语句体1; break; case 常量值2: 语句体2; break;...语句体3;...语句体n+1;...表达式:这个地方的表达式是限定的 byte/short/int/char JDK5的...

    选择结构:

    条件语句可根据不同的的条件执行不同的语句。条件语句包括if条件语句与switch多分支语句。本章节将向读者介绍条件语句的用法。
    if / switch

    if语句格式1:
    if(最终值为布尔类型的东西【表达式】){
    语句体;
    }
    

    执行流程:

    先计算你的表达式的值,看其是false还是true,如果是true,就执行语句体,如果是false就不执行语句体

    if注意事项:

    1.你的if里面的表达式,不管是简单还是复杂,里面的最终结果必须是boolean类型

    2.如果你的if里面只有一条语句,原则上是可以省略大括号,但是不建议这样去做

    if语句格式2:
    if(表达式){
    语句体1;
    }else{
    语句体2;
    }
    

    执行流程:
    1.首先计算表达式的值 看其返回的是false还是true

    2.如果是true执行语句体1

    3.如果是false执行语句体2

    if语句的格式3:
    if(表达式1){
    语句体1;
    }else if(表达式2){
    语句体2;
    }else if(表达式3){
    语句体3;
    }else{
    语句体n+1;
    }
    

    执行流程:
    1.先计算表达式1的值,看其返回的结果是true还是false

    2.如果是true,执行语句体1 并且结束整个语句

    3.如果是false,继续计算表达式2,看其返回的是true还是false(依次类推)

    4.如果上面所有的表达式都不成立,那么就执行else的语句体(else可以不写)

    if的第二种格式和三目运算符执行的过程几乎一致,如何区别使用:

    1、三元运算符能够实现的,if语句的第二种格式都能实现反之,if能够实现的,三目并不一定能够实现

    2、三目运算符必须返回一个明确具体数据值。

    3、三目运算符里面,原则不能写任何的语句,包括变量、常量、循环等等等,而if则可以几乎写java出了类和方法的所有语句

    switch

    switch语句的格式:

    switch(表达式){
    case 常量值1:
    语句体1;
    break;
    case 常量值2:
    语句体2;
    break;
    case 常量值3:
    语句体3;
    break;
    ...
    default:
    语句体n+1;
    }
    

    格式的解释:

    switch:表示是一个switch的分支结构

    表达式:这个地方的表达式是有限定的,byte/short/int/char,JDK5的版本以后支持枚举,JDK7的版本以后支持String

    case:后面的常量值需要给表达式的最终结果进行比较

    语句体:就是需要被执行的代码

    break:表示结束的意思,一旦碰到break 整个switch结束

    default:当上面的所有case的值都不匹配的时候,所执行的代码

    switch需要注意的实现:

    1.case后面跟着的值,必须是常量值 不能是变量,而且同一个switch当中不能出现相同case值

    2.break能否省略?可以省略,但是不建议,因为会造成结果的穿透

    3.default可以省略吗?可以,但是不建议 因为你没有办法给用户一个友好的错误提示

    4.default一定要放在最后面吗?default可以放在switch的任意位置,但是建议一般放在最后面,如果放在任意位置 一定要记得加上break。

    那么在平时的开发当中,我们一般是使用if还是switch?

    if和switch的区别:

    if语句:

    a.针对的只能是一个布尔类型的计算

    b.if语句针对的是一个范围内的判断

    switch:

    a.针对的是一个不可变的常量的计算

    b.针对的是多个范围内的判断

    如果说,你的判断和计算的结果是事先就已经明确和固定的,我们使用switch,如果我们的结果是不明确的,而且代码范围较大 一般使用if语句 switch的代码结构要比if清晰。

    while

    循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java中提供了3中常用的循环语句,分别是while循环语句、do···while循环语句和for循环语句,下面分别进行介绍。

    while循环语句格式:

      while(判断条件语句) {
            循环体语句;
      }
    

    while循环语句扩展格式

     初始化语句;
      while(判断条件语句) {
            循环体语句;
            控制条件语句;
       }
    

    通过这个格式,我们是不是发现几乎跟for循环一致,while循环的区别在哪儿?

    使用区别:
    如果你想在循环结束之后,继续使用控制条件的那个变量,那么就使用while循环,否则使用for循环。虽然说,for循环也可以单独将变量提出来,但是不建议 因为涉及到一个使用率的问题 因为for循环结束后,这个变量会及时从内存当中消失。

    场景的区别:

    如果是一个非常明确的范围的数据,我们使用for循环。如果你的数据范围不明确,那么就使用while循环。

    do_while循环:

    do…while循环语句格式:

    基本格式

    do {
            循环体语句;
      }while((判断条件语句);
    

    扩展格式

    初始化语句;

      do {
            循环体语句;
            控制条件语句;
       } while((判断条件语句);
    

    循环语句的区别:

    do…while循环保证最少会执行一次,而for循环和while必须是先判断条件是否成立,然后再去决定是否执行

    一般我们使用哪种循环比较多?

    优先考虑for循环,其次while循环,最后doWhile循环


    for循环

    for循环的格式:

    for(初始化条件;判断条件语句;控制条件语句){
    循环体语句;
    }
    

    执行流程:

    a.执行初始化条件 int a = 5;

    b.执行判断条件语句,看其返回的结果是true还是false,如果是true,就继续执行循环体 a < 50如果是false,就结束循环

    c.执行循环体语句

    d.执行控制条件语句 a++

    e.继续回到b步骤进行执行

    注意事项:

    1.判断条件语句,不管你写出什么样子,是简单还是复杂 你的结果必须是boolean类型

    2.循环体里面的语句如果只有1条,你可以省略大括号 但是不建议

    循环控制:

    1.break : 结束

    2.continue : 中断

    3.return : 返回

    break常见的使用:

    a.swtich

    b.所有循环语句

    注意:离开上面的场景 无效,同一个作用域当中,break后面不能存在任何的代码

    如何使用?

    大家都知道跳出单层循环,但如何跳出多层循环还是需要点操作:

    1.在外面定义一个开关标记,然后使用标记来判断是否结束

    2.使用标签,语法如下:

    标签名:循环体{
    break 标签名;
    }
    如:Loop:for(int i=0;i<3;i++){
    		for(int j=0;j<6;j++){
    			if(j==4){
    				break Loop;
    			}
    		}
    }
    

    流程控制语句的介绍大概说到这里;使用复合语句可为变量定义一个有效区域;通过if或switch,可以基于布尔值类型的测试,将程序分成不同的部分;通过while、do···while以及for循环语句,将部分程序重复执行,直到满足某个终止循环的条件。通过学习和之后的练习,读者应该学会在程序中灵活使用流程控制及语句。

    展开全文
  • JAVA的 循环语句

    千次阅读 2016-11-01 08:15:07
    Java循环语句的基本结构以及容易忽视的地方
  •  循环语句的作用就是重复执行程序代码,循环可分为三类:一类在条件变为“假”之前重复执行语句,一类在条件变为“真”之前重复执行语句,另一类按照指定的次数重复执行语句。在VBScript 中可使用下列循环语句: ...
  • C语言中的循环语句及其使用方法

    千次阅读 多人点赞 2016-05-03 14:26:25
    C语言是C系列编程语言学习的基础,所以很多高校都开设了C语言课程。作为一编程怨言,C语言的学习可谓...汇盈天下:C语言循环语句用法有三种主要形式: for()循环 while()循环 do {} while();循环 for()循环用法: f
  • 循环控制语句 C语言3种循环 for while do while while循环 我们先来看下while循环,流程图如下: 下来看个小示例 do while循环 流程图如下: 下来看个小示例 两个小示例的运行结果相同。 for循环 流程图如下...
  • java中if语句种格式,和例题

    千次阅读 2019-10-31 20:22:48
    if语句种格式: 1. if语句 格式:if(判断语句){ 执行的程序 } 2.if...else语句 格式:if(判断语句){ 执行的程序1 } else{ 执行程序2 } 3.if...elseif...elseif.....语句 格式:if(判断语句1){ 执行语句1 }...
  • JavaScript中循环语句主要包含for循环和while循环两。 for循环 for循环又分为for循环,for…in循环,for…of循环,其中for…of循环是es6中新增的,咱们后面讲es6时再讲,这次主要讲for循环和for…in循环。 1.for...
  • SQL语句分为三类

    千次阅读 2019-06-23 22:41:46
    所以,了解优化器是如何选择(搜索)路径以及索引是如何被使用的,对优化SQL语句有很大的帮助。Explain可以用来迅速方便地查出对于给定SQL语句中的查询数据是如何得到的即搜索路径(我们通常称为Access Path)。从而使...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 文章目录1.HMLT中if/else语句的...简写switch case语句以及注意点5.while循环的使用一.基本用法二.应用案例6.do / while 循环的使用7.for循环的基本应用8.for循环的嵌套使用--长方体的五角星9.for循环嵌套---三角形...
  • Kotlin入门(7)循环语句的操作

    千次阅读 2017-07-17 09:40:58
    上一篇文章介绍了简单分支与多路分支的实现,控制语句除了这两种条件分支之外,还有对循环处理的控制,那么本文接下来继续阐述Kotlin如何对循环语句进行操作。Koltin处理循环语句依旧采纳了for和while关键字,只是在...
  • Linux for循环语句

    万次阅读 多人点赞 2019-03-31 22:12:27
    (1)for循环有三种结构:一种是列表for循环,第二种是不带列表for循环。第种是C风格的for循环。 (2)列表for循环 #!/bin/bash for varible1 in {1..5} #for varible1 in 1 2 3 4 5 do echo "Hello, ...
  • 流程控制 判断语句和循环语句

    千次阅读 2018-06-16 12:07:31
    什么是流程控制呢?流程就是做一件事情的顺序,或者说是次序。...这些控制结构可以归为三类:顺序结构、选择结构和循环结构。实现这些控制结构的语句可分为5类:表达式语句、复合语句、分支语句循环语...
  • 顺序、选择和循环语句(程序的种基本控制结构) 复合语句 1、在了解程序的种基本控制结构之前,我们先了解以下什么是复合语句,即块语句。 2、与C语言及其他语言不同,Java语言的复合语句是以整个块区为单位的...
  • 循环语句概述 反复执行的代码片段,本质就对重复代码的一种简化解决方案。 循环语句四要素 1.初始化语句 2.循环条件语句 3.循环体语句 4.控制条件语句 循环分类 1.while循环语句    格式:    1.初始化语句;  ...
  • Java基础( Java循环语句和各种对象的遍历 可变参数 foreach循环语句 for循环语句加强版 List的种遍历方式 1.可变参数JDK1.5之后,提供了一种参数类型:可变参数类型。一个方法可以接受任意个数的参数(必须是...
  • 选择语句+循环语句作业及答案

    千次阅读 2019-04-24 10:15:41
    1.Java中两种类型的选择结构的控制语句,分别是if语句和________。 2.在Java JDK1.7之前,switch只能支持byte、short、char、int或者其对应的封装以及Enum类型。在JDK1.7中又加入了________类型。 3.for循环的...
  • if语句和循环语句

    千次阅读 2015-10-02 10:28:36
    if语句: 格式一: if(条件表达式){执行语句;} 当满足条件表达式的时候,执行if语句块中的内容。如果不满足,则不执行。 格式二: if(条件表达式){执行语句;} else{执行语句;} if。。。。。else ...
  • C# 循环语句foreach用法

    千次阅读 2015-04-22 17:26:57
    foreach循环用于列举出集合中所有的元素,foreach语句中的表达式由关键字in隔开的两个项组成。in右边的项是集合名,in左边的项是变量名,用来存放该集合中的每个元素。 该循环的运行过程如下:每一次循环时,从集合...
  •  循环语句在程序设计中用来描述规则重复的流程。在实际的程序中,存在很多需要重复执行的流程,为了简化这些重复的执行流程,在程序设计语言中新增了该语句。  在学习循环语句时,最重要的就是发现流程的规律...
  • Python while循环语句详解

    千次阅读 2019-08-14 18:42:38
    Python 中,while 循环和 if 条件分支语句类似,即在条件(表达式)为真的情况下,会执行相应的代码块。不同之处在于,只要条件为真,while 就会一直重复执行那段代码块。 while 语句的语法格式如下: while 条件...
  • go语言的循环语句for

    千次阅读 2018-11-29 13:45:00
    一般来说,每种语言的循环语句种,什么for,foreach,while,do—until之,应有尽有,总一款适合您。但go是一款比较新的语言,语言的作者可能一些自己的想法,循环语句就只提供了for一种。 ...
  • shell 循环语句

    万次阅读 2017-05-03 17:36:09
    循环语句: for 语法结构: 1、列表循环 for variable in {list} do command... done for variable in var1 var2 var3.. do command... done 2、非列表循环 for variable do command.. done 3、C风
  • 详解Python中的循环语句的用法

    千次阅读 2017-10-14 07:25:11
     Python的条件和循环语句,决定了程序的控制流程,体现结构的多样性。须重要理解,if、while、for以及与它们相搭配的 else、 elif、break、continue和pass语句。 二、详解 1、if语句  Python中的if子句由...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 309,398
精华内容 123,759
关键字:

循环语句有三类