Java 读书笔记 (十) 循环

while循环

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

 1 public class Test(
 2     public static void main(String args[]){
 3         int x=10;
 4         while(x<20){
 5             System.out.print("value of x: "+x);
 6             x++;
 7             System.out.print("
");
 8         }
 9       }
10 }
11 
12  /*执行结果:
13     value of x:10 
14     value of x:11
15     value of x:12 
16     value of x:13 
17     value of x:14 
18     value of x:15 
19     value of x:16 
20     value of x:17 
21     value of x:18 
22     value of x:19 
23 */

do... while 循环

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

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

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

 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<20);
10      }
11 }
   /*执行结果:
     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  1 public class Test{
 2  2     public static void main(String args[]){
 3  3         int x =10;
 4  4  
 5  5         do{
 6  6              System.out.print("value of x: "+x);
 7  7              x++;
 8  8              System.out.print("
");
 9  9          }while(x<10);
10 10      }
11 11 }
12 
13 
14  // 执行结果： value of x:10

for 循环

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

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

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

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

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

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

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

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

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

 1 public class Test{
 2     public static void main(String args[]{
 3         int [] numbers = {10,20,30,40,50};
 4  
 5         for (int x: numbers){
 6              System.out.print(x);
 7              System.out.print(",");
 8          }
 9          System.out.print("
");
10          String [] names = {"James","Larry","Tom","Lacy"};
11          for (String name: names){
12               System.out.print(name);
13               System.out.print(",");
14          }
15     }
16 }
   /*执行结果:
     10,20,30,40,50,
     James,Larry,Tom,Lacy,
   */

break 关键字

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

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

 1 public class Test{
 2     public static void main(String args[]){
 3         int[] numbers ={10,20,30,40,50};
 4         
 5         for /9int x:numbers){
 6             //x等于30时跳出循环
 7             if (x==30){
 8                break;
 9             }
10             System.out.print(x);
11             System.out.print("
");
12          }
13      }
14 }
   /*
    执行结果：
     10
     20
   */

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

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

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

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

 1 public class Test{
 2     public static void main(String args[]){
 3         int [] numbers={10,20,30,40,50};
 4 
 5         for (int x:numbers){
 6              if(x==30){
 7             continue;
 8             }
 9             System.out.print(x);
10             System.out.print("
");
11        }
12     }
13 }
   /*
    执行结果:
    10
    20   //跳过了30
    40
    50
   */

 1 //九九乘法表
 2 public class Main{
 3     public static void main(String args[]){
 4         for(int i=1;i<=9;i++){
 5             for(int j=1;j<=9;j++){
 6                 System.out.print(j+"*"+i+"="+i*j+"");
 7             }
 8             System.out.println();
 9         }
10     }
11 }
12 
13 /*第一个for 循环:代表行数。定一个整形变量i,它的初始值是1;判断i是否小于等于9; 如果成立，i就自增1.
14   第二个for循环: 代表列数。定一个整形变量j，它的初始值是1;判断j是否小于等于9,如果成立，j就自增1。
15 */

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

 1 switch(expression){
 2     case value:
 3         //语句
 4        break; //可选
 5     case value:
 6        //语句
 7        break; //可选
 8     //可以有任意数量的case语句
 9     default: //可选
10        //语句
11 }

//听起来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语句。

 1 public class Test{
 2     public static void main(String args[]){
 3         // char grade = args[0].charAt(0);
 4         char grade ="C";
 5 
 6         switch(grade)
 7         {
 8               case "A":
 9                   System.out.porintln("优秀");
10                   break;
11                case "B":
12                case "C":
13                     System.out.println("良好"）            
14                     break;
15                 case "D":
16                      System.out.println("及格");
17                 case "F":
18                       System.out.println("你需要再努力努力");
19                       break;
20                  default:
21                        System.out.println("未知等级");
22             }
23 }
24 
25 /*执行结果：
26    良好
27    你的等级是c
28 */

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

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

View Code

 1 //这个打印出来是正确的菱形
 2 public class Main{
 3     int a,b; //a是要生成的菱形行数
 4     int h;   //h是方法中的参数，也是行数
 5     int i,j; //i j是循环结构参数
 6     public void draw(int h) {
 7         for (i = 1; i <= h; i++) {      //逐行打印
 8             for (j = 1; j <= h; j++){//每行打印个数与行数保持一致
 9         //下面语句是菱形四条边的函数，在边上的坐标点，打印*，否则打印空格
10                 if (j == (h + 3) / 2 - i || j == (h - 1) / 2 + i || j == i - (h - 1) / 2 || j == (3 * h + 1) / 2 - i) {
11                      System.out.print("*");
12                 } else {
13                      System.out.print(" ");
14                 }
15              }
16              System.out.println();    //第i行打印完换行
17 
18         }
19     }
20     public static void main(String[]args){
21         Main b=new Main();
22         int a=35;
23         b.draw(a);
24         }
25 }

View Code