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("
");
        }
      }
}

 /*执行结果:
    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("
");
         }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("
");
 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("
");
         }
    }
}

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("
");
         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("
");
         }
     }
}
   /*
    执行结果：
     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("
");
       }
    }
}
   /*
    执行结果:
    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);
        }
}