JavaSE从零学起8. Java循环结构详解:while循环，do…while循环，for循环及增强for循环

最新推荐文章于 2023-11-30 19:04:21 发布
最新推荐文章于 2023-11-30 19:04:21 发布
阅读量159 收藏 1
点赞数
分类专栏： Java从零学起 文章标签： java intellij idea 面向对象编程 编程语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45161329/article/details/117448520
版权

Java循环结构详解:while循环，do…while循环，for循环及增强for循环

文章目录

while循环

while是最基本的循环，它的结构为：

while(boolean表达式){
    //循环内容
}

注意事项：

  1. 只要boolean表达式为true， 循环就会一直执行下去。
  2. 绝大多数情况下是需要让循环停止的，我们需要一个让表达式失效的方法来结束循环。
  3. 少数情况需要循环一直执行，比如服务器的请求响应监听等。
  4. 循环条件一直为true就会造成无限循环（死循环）。正常的业务编程中应该尽量避免死循环，这会影响程序性能或者造成程序卡死崩溃！、

看一个简单的例子：

输出1-100
public class Demo01 {
    public static void main(String[] args) {
        /*输出1-100*/
        int a = 0;
        while(a<100){ 
            a++;
            System.out.println(a);
        }
    }
}

输出结果
1
2
...
100
输出1+2+3+…+100的和：
public class Demo02 {
    public static void main(String[] args) {
        /*用while计算1+2+...+100=？*/
        int sum= 0;
        int a = 0;
        while(a<100){
            a = a+1;
            sum = sum + a;
        }
        System.out.println("The sum is" + sum);
    }
}

输出结果
The sum is 5050
用for循环输出1-1000之间能被5整除的数，且每行输出20个。
public class Demo03 {
    public static void main(String[] args) {
        /*用while循环输出1-1000之间能被5整除的数，且每行输出20个。*/
        int i=0;
        while(i<=1000){
            i++;

            if(i%5==0){
                System.out.print(i + "\t");
            }
            if(i%(5*20)==0){
                System.out.println();
            }

        }
    }
}

输出结果：
5	10	15	20	25	30	35	40	45	50	55	60	65	70	75	80	85	90	95	100	
105	110	115	120	125	130	135	140	145	150	155	160	165	170	175	180	185	190	195	200	
205	210	215	220	225	230	235	240	245	250	255	260	265	270	275	280	285	290	295	300	
305	310	315	320	325	330	335	340	345	350	355	360	365	370	375	380	385	390	395	400	
405	410	415	420	425	430	435	440	445	450	455	460	465	470	475	480	485	490	495	500	
505	510	515	520	525	530	535	540	545	550	555	560	565	570	575	580	585	590	595	600	
605	610	615	620	625	630	635	640	645	650	655	660	665	670	675	680	685	690	695	700	
705	710	715	720	725	730	735	740	745	750	755	760	765	770	775	780	785	790	795	800	
805	810	815	820	825	830	835	840	845	850	855	860	865	870	875	880	885	890	895	900	
905	910	915	920	925	930	935	940	945	950	955	960	965	970	975	980	985	990	995	1000

do…while循环

对于while语句而言。如果不满足条件则不能进入循环。但有时候我们需要即使不满足条件也至少执行一次。

do…while语法：

do{
    //代码语句
}while(boolean表达式)；

while和do…while的区别：

  1. while先判断后执行。do…while是先执行后判断。
  2. do…while总是保证循环体至少会执行一次！

看一个简单的例子：

输出1+2+3+…+100的和：(与上述while的例子对比)
public class DoWhileDemo01 {
        public static void main(String[] args) {
            /*用while计算1+2+...+100=？*/
            int sum= 0;
            int a = 0;
            do{
                a = a + 1;
                sum = sum + a;

            }while(a<100);

            System.out.println("The sum is" + sum);
        }
    }

输出结果：
The sum is 5050

可见此时输出结果并没有任何差别。

看一个更鲜明的例子：

对比while和do…while第一次的输出
public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while(a<0){
            a = a + 1;
            System.out.println(a);
        }//while先判断a<0，故而直接跳过循环，没有任何输出。
        System.out.println("===============");
        do{
            a = a + 1;
            System.out.println(a);

        }while(a<0) ;
        //do...while先执行了do{}语句后再进行判断。故而只执行了一次。输出1.
    }
}
输出结果：
===============
1

for循环

  • 虽然所有的循环结构都可以用while 或者do…while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。
  • for循环是支持迭代的一种通用结构，是最有效、最灵活的循环结构。>
  • for循环执行的次数是在执行前就确定的。

语法格式：

for(初始化；布尔表达式；更新){
//代码语句
}
看一个while和for循环输出0-100的例子：
public class Demo01 {
    public static void main(String[] args) {
        int a = 0; //初始化条件

        while(a<100){
            System.out.println(a);
            a+=1;//迭代
        }
        System.out.println("While循环结束");

        //(初始化；条件判断；迭代)
        for (int i = 0; i <=100; i++) {//IDEA中可以直接100.for + Tab
            System.out.println(i);

        }
        System.out.println("for循环结束");

    }
}

输出结果：
0
1
...
100
While循环结束
    
0
1
...
100
for循环结束

for循环的运行过程：

  1. 最先执行初始化步骤。可以声明一种类型也可以是空语句。
  2. 然后检测boolean表达式的值。如果为true则循环体被执行。如果为false则循环终止，开始执行循环体后面的语句。
  3. 每执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
  4. 再次检测boolean表达式。
  5. 循环执行以上过程

简单说来就是：

for(a.初始化；b.布尔表达式；c.更新)
d.//代码语句
}

e.//循环体后的语句

a.——b.——c.——b.——c…——e.

死循环：

既没有初始化，也没有判断语句。

for(;;){

}
计算0-100之间所有奇数与偶数的和。
public class Demo02 {
    public static void main(String[] args) {
        /*计算0-100之间所有奇数和偶数的和*/
        //先将0-100间的奇数与偶数都写出来
        int oddSum = 0;//保存奇数的和
        int evenSum = 0;//保存偶数的和

        for (int i = 0; i <=100; i++) {

            if(i%2!=0){
                oddSum = oddSum +i;
            }else {
                evenSum = evenSum +i;
            }
        }
        System.out.println("oddSum is" + oddSum);
        System.out.println("evenSum is" + evenSum);
        //再输出二者的和
        System.out.println("The sum of oddNum and evenNum is" + (oddSum + evenSum));
    }
}

输出结果：
oddSum is2500
evenSum is2550
The sum of oddNum and evenNum is5050
用for循环输出1-1000之间能被5整除的数，且每行输出20个。
public class Demo03 {
    public static void main(String[] args) {
        /*输出1-1000以内能被5整除的数且每行输出20个*/
        for (int i = 1; i <=1000; i++) {

            if(i%5==0){
                System.out.print(i+"\t");//因为我们要求每行输出固定个数所以不能直接用println()
                //= System.out.print(i) + System.out.print(" ");

                /*每行输出20个*/
                if (i%(5*20)==0){
                    System.out.println();
                    //= System.out.print("\n");

                }
            }
            /*println()输出完换行
            * print()输出完不换行
            * */
        }
    }
}

输出结果：
5	10	15	20	25	30	35	40	45	50	55	60	65	70	75	80	85	90	95	100	
105	110	115	120	125	130	135	140	145	150	155	160	165	170	175	180	185	190	195	200	
205	210	215	220	225	230	235	240	245	250	255	260	265	270	275	280	285	290	295	300	
305	310	315	320	325	330	335	340	345	350	355	360	365	370	375	380	385	390	395	400	
405	410	415	420	425	430	435	440	445	450	455	460	465	470	475	480	485	490	495	500	
505	510	515	520	525	530	535	540	545	550	555	560	565	570	575	580	585	590	595	600	
605	610	615	620	625	630	635	640	645	650	655	660	665	670	675	680	685	690	695	700	
705	710	715	720	725	730	735	740	745	750	755	760	765	770	775	780	785	790	795	800	
805	810	815	820	825	830	835	840	845	850	855	860	865	870	875	880	885	890	895	900	
905	910	915	920	925	930	935	940	945	950	955	960	965	970	975	980	985	990	995	1000
打印九九乘法表
样式：
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 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

思考过程：

  1. 打印第一列。发现每个式子其实就是1*行数i。
  2. 我们发现第二列第三列到第九列依次是列数*i 因此想到列数j与行数i可做循环的嵌套。每个式子其实就是j*i.
  3. 又因为格式中列数<=行数，即j<=i 。故而想到
for (int i = 1; i < 10; i++) {
            for(int j = 1; j<=i ;j++){
                System.out.print(j+"*"+i +"=" + (j*i) +" ");
            }       
        }
  1. 最后调整样式：每两个式子中间有空格.另外i每次循环到9后要换行。
 for (int i = 1; i < 10; i++) {
     for(int j = 1; j<=i ;j++){
         System.out.print(j+"*"+i +"=" + (i*j) +" ");
     }
     System.out.println();
 }
  1. 最后实现完整代码：
public class Demo04 {
    public static void main(String[] args) {
        /*打印九九乘法表*/
        for (int i = 1; i < 10; i++) {
            for(int j = 1; j<=i ;j++){
                System.out.print(j+"*"+i +"=" + (j*i) +" ");
            }
            System.out.println();
        }
    }
}

输出结果：
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 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

增强型for循环

Java5引入了一种主要用于数组或集合的增强型for循环。

增强型for循环语法格式如下：

for(声明语句：表达式){
    //代码句
}
  • 声明语句：声明新的局部变量，该变量类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
  • 表达式：表达式是要访问的数组名或是返回值为数组的方法。
看个简单的例子体验一下for和增强for的关联：
public class Demo05 {
    public static void main(String[] args) {
        //定义了一个数组
        int[] num = {1,2,3,4,5};

        //遍历数组的元素
        //for(声明语句与数组元素的类型匹配：表达式是访问的数组名或返回值为数组的方法)
        for(int x:num){
            System.out.println(x);
        }

        System.out.println("=============");

        for (int i = 0; i < 5; i++) {
            System.out.println(num[i]);
        }
    }
}

输出结果：
1
2
3
4
5
=============
1
2
3
4
5

break和continue

  • break用于控制循环的流程，可用于任何循环语句的主体部分。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
  • continue语句用在循环语句体中用于终止某次循环过程。即跳过循环体中尚未执行的语句，直接进入下一次执行循环的判定。

看一个break的例子：

输出0-30之间的数
public class BreakDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
    }
}

输出结果：
1
2
3
...
30

看一个continue的例子：

跳过整十数输出1-100：
public class ContinueDemo {
    public static void main(String[] args) {
        int i = 0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();//每当循环到10的倍数就会换行
                continue;
//continue直接跳过了System.out.print(i)的执行，直接进入下一次循环的判定。
// 故而每次遇到10的倍数就不会输出。每一行最多输出到9
            }
            System.out.print(i + " ");
        }
    }
}

输出结果：
1 2 3 4 5 6 7 8 9 
11 12 13 14 15 16 17 18 19 
21 22 23 24 25 26 27 28 29 
31 32 33 34 35 36 37 38 39 
41 42 43 44 45 46 47 48 49 
51 52 53 54 55 56 57 58 59 
61 62 63 64 65 66 67 68 69 
71 72 73 74 75 76 77 78 79 
81 82 83 84 85 86 87 88 89 
91 92 93 94 95 96 97 98 99
Clap of thunder
关注
专栏目录
javaSE练习题2及答案.docx
11-26
9. **循环结构**：do-while循环无论条件如何，至少会执行一次，选项B正确。 10. **内存管理与类的特性**：与问题8类似，选项A描述错误，而其他选项正确。 11. **for-each循环**：Java 1.5引入了for-each循环，它...
java基础课件.zip
06-10
而循环语句（for、while、do-while）则是控制程序重复执行某些代码的关键。 8. **day09-ArrayList集合&学生管理系统.pdf**： ArrayList是Java集合框架中的动态数组，这部分会介绍如何创建和操作ArrayList，以及在...
Java软件开发实战 Java基础与案例开发详解 1-4 java SE环境安装和配置 共11页.pdf
最新发布
07-07
- **循环结构**：重复执行某段代码直到满足某个条件，如while循环、for循环。 5. **数组** - **一维数组**：只有一组索引的数组。 - **多维数组**：具有多个维度的数组。 - **排序算法**：如冒泡排序、插入排序...
Java领域基础部分JavaSE笔记
04-30
### Java核心知识点详解 #### 一、Java概述 ##### 1.1 转义字符 - **定义**：在字符串中表示特殊字符的一种方式，通常以反斜杠`\`开头。 - **常见转义字符**： - `\n`：换行 - `\t`：水平制表符（Tab键） - `\...
JavaSE知识目录.pdf
07-30
- 流程控制语句用于控制程序的执行顺序，包括选择结构（如`if-else`, `switch`）和循环结构（如`for`, `while`, `do-while`）。 二、Java面向对象 1. 面向对象知识结构及案例 - 面向对象是一种编程思想，强调将...
Java变量与方法的调用：同类操作中与跨类操作中的对比
weixin_45161329的博客
05-27 1075
变量与方法的调用 先上结论 同类操作中 静态方法可以直接调用静态变量、静态方法。 初始化对象后静态方法可以通过Object.name调用非静态变量、非静态方法 非静态方法可以直接调用静态变量、静态方法和非静态变量、非静态方法。 跨类操作中 静态方法可以通过类名.变量名或者类名.方法名调用静态变量、静态方法。 初始化对象后静态方法可以通过对象名.变量名或者对象名.方法名调用非静态变量、非静态方法 非静态方法可以通过类名.变量名或者类名.方法名用静态变量、静态方法。 初始化对象后非静态方法可以通过对象名
MybtisPlus快速开发（从controller到mapper）
weixin_45161329的博客
11-30 553
如果要在Service层注入mapper的话需要在mapper接口上加上。
java基本类型赋值与引用类型赋值的区别以及别名现象
weixin_45161329的博客
11-02 494
由于java中引用对象的赋值操作只是操作其引用，因此此时ref2与ref1的引用指向堆中的同一个对象type2（type1原始对象的引用在type2赋值给它时丢失，它引用的对象会在垃圾回收时被清理）。若b是引用类型，赋值操作将b引用赋予了a，此时两者指向堆中的同一个对象（b指向的对象），而a原先引用的对象会被垃圾回收机制清理。如果a=b,若b是基本类型，则赋值操作将b的值复制一份传给a，此后a的值改变完全不影响b。基本类型的赋值都是直接赋予相同的值，而引用类型的赋值赋予的只是其内存的引用。
面向对象编程03：封装、继承、多态
weixin_45161329的博客
06-15 481
面向对象编程03：封装、继承、多态 文章目录面向对象编程03：封装、继承、多态封装继承object类supersuper注意点：`super` VS `this`:方法重写多态多态的注意事项：instanceof关键字父类与子类之间的类型转换 封装 该露的露、该藏的藏 设计程序要追求“高内聚、低耦合”。 高内聚就是类的内部数据操作细节由自己完成，不允许外部干涉； 低耦合：仅仅暴露少量的方法给外部使用。 封装（数据的隐藏） 通常我们应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，
JavaSE从零学起6. Scanner类：创建Scanner对象的方法 基本使用模板 next()和nextLine() 的区别
weixin_45161329的博客
05-30 324
Scanner类 文章目录Scanner类创建Scanner对象的方法基本使用模板next()和nextLine() 的区别结合hasNext**()使用一个Scanner常见Demo 创建Scanner对象的方法 Scanner scanner = new Scanner(System.in); 基本使用模板 使用Scanner类时需要在代码最上方导入java.util.Scanner import java.util.Scanner; public class Demo03 { public
JavaSE从零学起11. 数组：数组声明与创建、Java内存分析、三种初始化、for -each循环 、求数组元素的总和、找出最大值
weixin_45161329的博客
06-05 289
数组 文章目录数组数组概述数组声明与创建Java内存分析三种初始化数组的四个基本特点数组使用for -each循环for 循环遍历输出求数组元素的总和找出最大值数组作方法入参数组作返回值多维数组 数组概述 数组是相同类型数据的有序集合，是一种数据结构 数组描述的是相同类型的若干个数据按照一定的先后次序排列组合而成。 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。 数组下标从0开始 数组声明与创建 首先必须声明数组变量才能在程序中使用数组。下面是java声明数组变量的语法：
JavaSE从零学起1. 常用快捷键，常用DOS命令及注释、Ping 命令、文件操作
weixin_45161329的博客
05-27 264
常用快捷键，常用DOS命令及注释 文章目录常用快捷键，常用DOS命令及注释常用快捷键常用DOS命令打开应用Ping 命令文件操作注释 常用快捷键 操作 快捷键 全选文本 Ctrl + A 复制文本 Ctrl + C 查找文本 Ctrl + F 保存文件 Ctrl + S 粘贴文本 Ctrl + V 剪切文本 Ctrl + X 撤销文本 Ctrl + Z 关闭窗口 Alt + F4 永久删除 Shift + Delete 打开运行窗口 Win + R 打
面向对象编程02：对象的创建与初始化、构造器（构造方法/构造函数）、创建对象内存分析、类与对象复习提纲
weixin_45161329的博客
06-15 240
从零开始面向对象编程02 文章目录从零开始面向对象编程02对象的创建与初始化构造器（构造方法/构造函数）创建对象内存分析类与对象复习提纲 对象的创建与初始化 使用new关键字创建对象 下面看一个使用new关键字创建对象的实例： this指向本类 //学生类 public class Student { //属性：字段 String name; int age; //方法 public void study( ) { System.out
JavaSE从零学起5. Java运算符：常用算术运算符、常用关系运算符、常用位运算符、常用逻辑运算符、逻辑短路操作、短路逻辑运算符、条件运算符
weixin_45161329的博客
05-28 227
Java运算符 文章目录Java运算符什么是Java运算符？Java运算符分类常用算术运算符常用关系运算符常用位运算符常用逻辑运算符逻辑短路操作短路逻辑运算符条件运算符（？：）（三元运算符） 什么是Java运算符？ 关于运算符，你可以理解为数学符号，就像生活中我们做数学运算用到的富豪一样。 Java运算符分类 常用的Java运算符主要有下列几类： 算术运算符 关系运算符 位运算符 逻辑运算符 赋值运算符 条件运算符（三元运算符） 常用算术运算符 操作符 作用 + “+”左右的数作加法
JavaSE从零学起9. 流程控制——循环结构练习
weixin_45161329的博客
06-02 216
循环结构练习： 文章目录循环结构练习：用for循环输出下列倒三角：分析过程用for循环输出下列正三角：分析过程 下面来做两个练习，通过这两个练习可以让你对流程控制，尤其是for循环掌握的更加牢靠。 用for循环输出下列倒三角： ***** **** *** ** * 先看代码： public class Triangle01 { public static void main(String[] args) { /*有两个量在进行循环，一个是行数i，一个是对应行的星数j*/ for
JavaSE从零学起7. 选择结构、if单选择结构、if双选择结构、if多选择结构、嵌套的If结构、Switch选择结构
weixin_45161329的博客
05-31 212
选择结构 文章目录选择结构if单选择结构if双选择结构if多选择结构嵌套的If结构Switch选择结构 if单选择结构 我们很多时候需要去判断一个东西是否可行，确认可行后才去执行，这样一个过程在程序中用if语句来表示。 语法： if(boolean表达式){ //boolean为ture将执行的语句 } 下面来看一个简单的例子： public class IfDemo01 { public static void main(String[] args) { System.o
JavaSE从零学起3. JAVA数据类型：引用数据类型、内置数据类型、基本数据类型扩展、自动类型转换、强制类型转换
weixin_45161329的博客
05-27 170
JAVA数据类型 文章目录JAVA数据类型强类型语言与弱类型语言数据类型引用数据类型字节与位内置数据类型基本数据类型扩展整型表示方法：浮点数比较：boolean值扩展类型转换自动类型转换强制类型转换注意点 强类型语言与弱类型语言 Java是一门强类型语言。变量的使用要严格符合规定。所有的变量都必须先定义后才能使用。 public class Demo01 { public static void main(String[] args) { System.out.println(a);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clap of thunder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值