Java中的循环笔记整理(必看篇)

时间:2022-09-27 11:49:20

一、循环的类型:

1、for循环

?
1
2
3
4
5
6
7
8
9
10
11
12
class for{
  public static void main(string[] args) {
    system.out.println("hello world!");
    system.out.println("hello world!");
    system.out.println("hello world!");
    system.out.println("hello world!");
    system.out.println("我是分隔符~~~~~~~~~~~~~~~~~~~~~~~~");
    for(int i = 0; i < 4; i++){
      system.out.println("hello world!");
    }
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

2、while() {}

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class testwhile {
  public static void main(string[] args) {
    //100以内的偶数的输出
    int i = 1;
    int sum = 0;
    while(i <= 100){
      if(i % 2 == 0){
      system.out.println(i);
      sum += i;
      }
      i++;
    }
    system.out.println(sum);
    //system.out.println(i);
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

3、do{}while()

?
1
2
3
4
5
6
7
8
9
10
11
class dowhile{
  public static void main(string[] args) {
    int i = 1;
    do{
      if(i % 2 == 0){
        system.out.print(i + "\t");
      }
      i++;
    }while(i <= 100);
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

二、格式:

所有的循环结构都必须包含以下4部分:

     1、初始化条件;

    2、循环条件;

    3、迭代条件;

    4、循环体;

1、for循环格式:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 0;
2、循环条件 = i < 4;
3、迭代条件 = i++;
4、循环体 = system.out.println("hello world!"); 
*/
class for{
  public static void main(string[] args) {
    for(int i = 0; i < 4; i++){
      system.out.println("hello world!");
    }
  }
}

2、while循环格式:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 1;int sum = 0;;
2、循环条件 = i <= 100;
3、迭代条件 = i++;
4、循环体 = if语句; 
*/
class testwhile {
  public static void main(string[] args) {
    //100以内的偶数的输出
    int i = 1;
    int sum = 0;
    while(i <= 100){
      if(i % 2 == 0){
      system.out.print(i +"\t");
      sum += i;
      }
      i++;
    }
    system.out.print(sum);
  }
}

3、do{4 3}while(2);

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*
所有的循环结构都必须包含以下4部分:
1、初始化条件;
2、循环条件;
3、迭代条件;
4、循环体;
在这段代码中与格式的对应关系为:
1、初始化条件 = int i = 1;
2、循环条件 = i <= 100;
3、迭代条件 = i++;
4、循环体 = if语句; 
*/
class testdowhile{
  public static void main(string[] args) {
    int i = 1;
    do{
      if(i % 2 == 0){
        system.out.println(i);
      }
      i++;
    }while(i <= 100);
 
    int j = 10;
    do{
      system.out.println(j);
      j++;
    }while(j<10);
 
    while(j < 10){
      system.out.println(j);
      j++;
    }
  }
}

注意:

1、不同的循环结构之间可以相互转换;

2、while和do-while的区别:do-while程序至少会执行一次;

三、嵌套循环:

说明:循环结构中还可以声明循环;让内层循环结构整体充当外层循环的循环体;若外层循环执行m次,内层循环执行n次,整个程序执行m*n次。

可以理解为外层循环控制行数,内层循环控制列数;

例:

?
1
2
3
4
5
6
7
8
9
10
class testfor2 {
  public static void main(string[] args) {
    for(int j = 0;j < 4;j++){//外层循环控制行数
      for(int i = 0;i < 5;i++){//内层循环控制列数
        system.out.print("*");
      }
      system.out.println();
    }
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

练习题

1、九九乘法表

?
1
2
3
4
5
6
7
8
9
10
class testjiujiu {
  public static void main(string[] args) {
    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();
    }
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

2、输出100内的质数(两种方法实现)

第一种:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class testprimenumber {
  public static void main(string[] args) {
      boolean flag = false;
      long start = system.currenttimemillis();
      for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= math.sqrt(i);j++){
        if(i % j == 0){
          flag = true;
          break;
        }
      }
      if(!flag){
        system.out.println(i);
      }
      flag = false;
    }
    long end = system.currenttimemillis();
    system.out.println("所花费的时间为:" + (end - start));
  }
}

运行结果:由于数据过多,这里使用运营时间来表示

Java中的循环笔记整理(必看篇)

第二种:这种方式主要是为了显示运行的效率,这里也是使用运行时间来表示。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class testprimenumber1 {
  public static void main(string[] args) {
      //boolean flag = false;
      long start = system.currenttimemillis();
      l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= math.sqrt(i);j++){
        if(i % j == 0){
          //flag = true;
          //break;
          continue l;
        }
      }
      //if(!flag){
        //system.out.println(i);
      //}
      //flag = false;
    }
    long end = system.currenttimemillis();
    system.out.println("所花费的时间为:" + (end - start));
  }
}

运行结果:

Java中的循环笔记整理(必看篇)

四、无限循环

当需要使用无限循环时,将循环的循环条件修改为true即可(代码格式请参考第二部分),但是需要注意的是,在无限循环结果内部一定要提供循环的终止条件(使用break关键字)否则程序将无限制的执行下去,形成死循环;

五、break和continue:

1、break:

  1、使用在swich-case结构或者循环结构中;

  2、在循环结构中,一旦执行到break,就跳出当前循环。

2、continue:

  1、使用在循环结构中;

  2、在循环结构中,一旦执行到continue就跳出当次循环;

3、在嵌套循环中,可以使用带标签的break和continue。

  例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class testprimenumber1 {
  public static void main(string[] args) {
      //boolean flag = false;
      long start = system.currenttimemillis();
      l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历
      //如何判断i是否为一个质数
      for(int j = 2;j <= math.sqrt(i);j++){
        if(i % j == 0){
          //flag = true;
          //break;
          continue l;
        }
      }
      //if(!flag){
        //system.out.println(i);
      //}
      //flag = false;
    }
    long end = system.currenttimemillis();
    system.out.println("所花费的时间为:" + (end - start));
  }
}

注意:请注意第5行代码(l:for(int i = 2;i <= 100000;i++))以及第11行代码(continue l;),在第五行代码前边写了一个l:的标签,然后在第11行代码处进行调用,如果程序执行到这里会自动跳出此循环,然后从第五行开始执行;

六、数组:

1、定义:相同数据类型的数据的组合。

不使用数组的定义方式: 

?
1
2
3
int i1 = 1;
int i2 = 2;
int i3 = 3;

使用数组的定义方式:

1、静态初始化:在声明并初始化数组与给数组相应的元素赋值操作同时进行;

int[] scores = new int[]{72,90,59};

2、动态初始化:在声明并初始化数组与给数组相应的元素赋值操作分开进行;

int[] scores1 = new int[3];

socres1[0] = 72;

socres1[1] = 90;

socres1[2] = 59;

2、数组的初始化问题(以下的初始化为错误的初始化方式):

string[] names = new string[5]{"aa","bb","cc"}

int i = new int[10];

int i = new int[];

注意:不管是动态初始化还是静态初始化,一定要在创建的时候就指明数组的长度;

3、数组的引用:

1、通过数组下角标的方式来进行引用;下角标从0开始到n-1结束,其中n为数组的长度。

2、数组的长度通过length属性来调用;

代码

3、如何遍历数组:使用循环来进行遍历

for(int i = 0,i < scores1.length;i++){

system.out.println(scores1[i]);

}

代码展示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class testarray {
  public static void main(string[] args){
    int i1;
    i1 = 12;
    boolean b = true;
    //1.如何定义一个数组
    //1.1数组的声明
    string[] names;
    int[] scores;
    //1.2初始化
    //第一种:静态初始化:初始化数组与给数组元素赋值同时进行。
    names = new string[]{"张三","李四","王五"};
    //第二种:动态初始化:初始化数组与给数组元素赋值是分开进行的;
    scores = new int[4];
    //2.如何调用相应的数组元素:通过数组元素的下角标的方式来调用。
    //下角标从0开始,到n-1结束。其中n表示的是数组的长度。
    scores[0] = 87;
    scores[1] = 89;
    scores[3] = 98;
    //3。数组的长度:通过数组的length属性。
    system.out.println(names.length);
    system.out.println(scores.length);
    //4.如何遍历数组元素
//    system.out.println(names[0]);
//    system.out.println(names[1]);
//    system.out.println(names[2]);
    for(int i = 0;i < names.length;i++){
      system.out.println(names[i]);
    }
  }
}

以上这篇java中的循环笔记整理(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。