Java 读书笔记 (十) 循环

while循环

只要布尔表达式为true,循环就一直执行下去。

 public class Test(
     public static void main(String args[]){
         int x=10;
         while(x<20){
             System.out.print("value of x: "+x);
             x++;
             System.out.print("\n");
         }
       }
 }

  /*执行结果:
     value of x:10
     value of x:11
     value of x:12
     value of x:13
     value of x:14
     value of x:15
     value of x:16
     value of x:17
     value of x:18
     value of x:19
 */

do... while 循环

不满足条件，循环也会至少执行一次。

 do {
     // 代码语句
 }while(布尔表达式);

布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为true,则语句块一直执行，直到布尔表达式的值为false.

 public class Test{
     public static void main(String args[]){
         int x =10;

         do{
              System.out.print("value of x: "+x);
              x++;
              System.out.print("\n");
          }while(x<20);
      }
 }
   /*执行结果:
     value of x:10
     value of x:11
     value of x:12
     value of x:13
     value of x:14
     value of x:15
     value of x:16
     value of x:17
     value of x:18
     value of x:19
    */

下面这个例子可以看出while 和do...while的区别。如果是while句式，不会返回x的值因为条件不满足。

  1 public class Test{
  2     public static void main(String args[]){
  3         int x =10;
  4
  5         do{
  6              System.out.print("value of x: "+x);
  7              x++;
  8              System.out.print("\n");
  9          }while(x<10);
 10      }
 11 }

  // 执行结果： value of x:10

for 循环

循环结构更为简单。 for循环执行的次数是在执行前就确定的。

 for(初始化;布尔表达式；更新){
      //代码语句
 }

关于for循环有以下几点说明:

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为true,循环体被执行。如果为false,循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式，循环执行上面的过程。

 public class Test{
     public static void main(String args[]{

         for(int x=10; x<20; x=x+1){
             System.out.print("value of x: "+x);
             System.out.print("\n");
          }
     }
 }

Java 增强for循环
Java5引入了一种主要用于数组的增强型for循环。格式如下:

 for (声明语句: 表达式)
 {
     //代码句子
 }

声明语句: 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式:表达式是要访问的数组名，或者是返回值为数组的方法。

 public class Test{
     public static void main(String args[]{
         int [] numbers = {10,20,30,40,50};

         for (int x: numbers){
              System.out.print(x);
              System.out.print(",");
          }
          System.out.print("\n");
          String [] names = {"James","Larry","Tom","Lacy"};
          for (String name: names){
               System.out.print(name);
               System.out.print(",");
          }
     }
 }
   /*执行结果:
     10,20,30,40,50,
     James,Larry,Tom,Lacy,
   */

break 关键字

主要用在循环语句或者switch语句中， 用来跳出整个语句块。

break跳出最里层的循环，并且继续执行该 循环下面的语句.

 public class Test{
     public static void main(String args[]){
         int[] numbers ={10,20,30,40,50};

         for /9int x:numbers){
             //x等于30时跳出循环
             if (x==30){
                break;
             }
             System.out.print(x);
             System.out.print("\n");
          }
      }
 }
   /*
    执行结果：
     10
     20
   */

continue 关键字   //continue的作用,到底什么情况下要用到continue,依下例，应该是用来跳过循环中某些值？

continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在for循环中，containue语句使程序立即跳转到更新语句。

在while或者do...while循环中， 程序立即跳转到布尔表达式的判断语句。

 public class Test{
     public static void main(String args[]){
         int [] numbers={10,20,30,40,50};

         for (int x:numbers){
              if(x==30){
             continue;
             }
             System.out.print(x);
             System.out.print("\n");
        }
     }
 }
   /*
    执行结果:
    10
    20   //跳过了30
    40
    50
   */

 //九九乘法表
 public class Main{
     public static void main(String args[]){
         for(int i=1;i<=9;i++){
             for(int j=1;j<=9;j++){
                 System.out.print(j+"*"+i+"="+i*j+"");
             }
             System.out.println();
         }
     }
 }

 /*第一个for 循环:代表行数。定一个整形变量i,它的初始值是1;判断i是否小于等于9; 如果成立，i就自增1.
   第二个for循环: 代表列数。定一个整形变量j，它的初始值是1;判断j是否小于等于9,如果成立，j就自增1。
 */

switch 语句
switch语句判断一个变量与一系列值中某个值是否相等， 每个值称为一个分支。

 switch(expression){
     case value:
         //语句
        break; //可选
     case value:
        //语句
        break; //可选
     //可以有任意数量的case语句
     default: //可选
        //语句
 }

//听起来switch ... default 相当于 if...else

switch 语句规则:

• switch语句中的变量类型可以是: byte、short、int或者char.从Java SE7开始， switch 支持字符串类型了，同时case标签必须为字符串常量或字面量。  //什么是字面量?
• switch 语句可以拥有多个case 语句, 每个case后面跟一个要比较的值和冒号。
• case语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
• 当变量的值与case语句的值相等时，case语句之后的语句开始执行，直到break语句出现才会跳出switch 语句。
• 当遇到break语句时，switch 语句终止。程序跳转到switch语句后面的语句执行。case语句不必须要包含break语句，如果没有break语句出现，程序会继续执行下一条case语句，直到出现break语句 。
• switch 语句可以包含一个default分支，该分支必须是switch语句的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句。

 public class Test{
     public static void main(String args[]){
         // char grade = args[0].charAt(0);
         char grade ="C";

         switch(grade)
         {
               case "A":
                   System.out.porintln("优秀");
                   break;
                case "B":
                case "C":
                     System.out.println("良好"）
                     break;
                 case "D":
                      System.out.println("及格");
                 case "F":
                       System.out.println("你需要再努力努力");
                       break;
                  default:
                        System.out.println("未知等级");
             }
 }

 /*执行结果：
    良好
    你的等级是c
 */     

小程序编制：
在控制台输入由"*"组成的菱形。 //编程思路是如何确定的?

  1   public class Main{
  2     //下面是升序的代码
  3     public void prit1(float c){
  4         float p =c/2;  //升序排序
  5         float d;          //声明行数变量
  6         float e;          //声明打印*号的变量
  7         float f;          //声明打印空格的变量
  8         float r;          //声明升序排序
  9         float s=c%2; //取模
 10         if(s==0){
 11             System.out.println("你输入的数据不能形成菱形结构");
 12         } else{
 13             for (d=1; d<=p;d++){
 14                 for(f=p;f>=d;f--) {
 15                     System.out.print(" ");
 16                 }
 17                     for (e=1;e<=d*2-1;e++){
 18                         if(e==1||e==d*2-1){
 19                             System.out.print("*");  //如果是第一个数和最后一个数，就输入*
 20                         } else{
 21                             System.out.print(" ");  //否则输入空格
 22                         }
 23                     }
 24                     System.out.println();
 25                 }
 26             }
 27         }
 28
 29
 30         //下面是打印倒序的代码
 31         public void prit2(float m){
 32             float i;  //声明行数变量
 33             float j;          //声明打印*号的变量
 34             float k;          //声明打印空格数的变量
 35             float n=m/2+1;          //倒序排序
 36             float o=m%2;          //取模
 37             if(o==0){
 38                 System.out.println("");
 39             } else{
 40                 for (i=1; i<=n;i++){
 41                     for(k=0;k>=i;k++) {
 42                         System.out.print(" ");
 43                     }
 44                     // 下面打印*号个数据循环
 45                     for (j=(n-k)*2-2;j>=1;j--)  //打印*号个数的循环;
 46                     {
 47                         if(j==(n-k)*2-2||j==1){
 48                             System.out.print("*");  //如果是第一个数和最后一个数，就输入*
 49                         } else{
 50                             System.out.print(" ");  //否则输入空格
 51                         }
 52                     }
 53                     //打印完*号换行打印
 54                     System.out.println();
 55                 }
 56             }
 57         }
 58
 59         public static void main(String[] args) {
 60             Main a = new Main();
 61             float b = 11;  //根据行数，判断是否可以组成菱形。如果基数行可以输入对弈的菱形，如果是偶数行则输出"你输入的数据不能形成菱形结构";
 62             a.prit1(b);
 63             a.prit2(b);
 64         }
 65 }
 66
 67 // 这样打出来，前半截是对的，下面是两条平行线。

 //这个打印出来是正确的菱形
 public class Main{
     int a,b; //a是要生成的菱形行数
     int h;   //h是方法中的参数，也是行数
     int i,j; //i j是循环结构参数
     public void draw(int h) {
         for (i = 1; i <= h; i++) {      //逐行打印
             for (j = 1; j <= h; j++){//每行打印个数与行数保持一致
         //下面语句是菱形四条边的函数，在边上的坐标点，打印*，否则打印空格
                 if (j == (h + 3) / 2 - i || j == (h - 1) / 2 + i || j == i - (h - 1) / 2 || j == (3 * h + 1) / 2 - i) {
                      System.out.print("*");
                 } else {
                      System.out.print(" ");
                 }
              }
              System.out.println();    //第i行打印完换行

         }
     }
     public static void main(String[]args){
         Main b=new Main();
         int a=35;
         b.draw(a);
         }
 }