关于java循环结构for

news2025/1/22 15:54:31

关于java循环结构for

在上一篇文章中,我们了解到了while和do…while的结构以及用法,这篇文章我们主要学习一下最常用的循环结构,for结构😀,这个结构理解起来相对while结构会难一些,本篇文章内容会很多,一起了解for的细节和过程,所以要多去思考,反复观看,反复练习。

关于java循环结构while和do…while

for循环

  • 虽然所有循环结构都可以用while和do…while表示,但是java中提供了另一种结构,叫做for结构。
  • for结构使一些循环变的简单。
  • for循环结构是支持迭代的一种通用结构,是最有效,最灵活的循环结构。
  • for循环结构使用方式:
for(初始化;布尔表达式;迭代)//英文分号间隔
{
    //需要执行的循环语句
}
  • for循环结构实例说明:

我们输出1-100,之前使用的是while,现在用for循环来实现😎

public class Demo
{
	public static void main(String[] args)
    {
        // 初始化;布尔表达式;迭代 
        for(int i=0; i<=100; i++)
        {
            System.out.println(i);
        }
    }
}

我们执行上述的代码,可以看到,输出的结果和while是一样的。

0
1
2
3
...
100

进程结束...

我们来对比一下while和for,可以更好的理解for和什么是迭代。

迭代

public class Demo
{
	public static void main(String[] args)
    {
        int a=0;//初始化
        
        while(a<=100)//布尔条件
        {
            System.out.println(a);
            
            a++;//迭代  a=a+1         
        }
        
        System.out.println("=============")
        
        //初始化;布尔表达式;迭代   
        for(int i=0; i<=100; i++)
        {
            System.out.println(i);
        }
    }
}

我们运行上面的代码,结果是一样的,所以迭代就是更新,像a++一样递增或者递减等。

0
1
2
3
...
100
=======
0
1
2
3
...
100
    
进程结束....

理解for循环执行步骤

  • 第一步,执行初始化,可以声明一种类型,可以初始化一个或者多个循环控制变量,也可以是空白的。

    空白的就是我们for循环中的死循环

public class Demo
{
	public static void main(String[] args)
    {
        //空白的
        for(;;)
        {
        
        }
    }
}
  • 第二步,去检测布尔表达式的值,如果为true,执行循环,如果为false,循环终止,开始执行循环后边的语句。

  • 第三步,执行一次循环以后,更新循环控制变量(迭代控制变量是增还是减)。

  • 最后,重复执行,检测布尔值,循环上面的过程。

实战练习

  • 题目一:用while或for循环输出1-300之间能被5整除的数,并且每行输出3个。
    首先我们把题目分解:

1、利用while循环,第一步初始化一个int类型的变量,值为0。

2、被5整除,就是除以5余数是0,要对数字进行判断,所以我们要用到之前学习过的%运算符和if选择结构。

3、我们打印用的是println(),这里正好了解print(),println是自动换行,print是将结果都输出在一行。

4、如果都输出在一行,需要用到我们之前学习过的转义符\t,来产生间隔,然后用\n换行。

5、每行输出三个,其实理解过来就是,一行输出三个数字,到三个数字的时候需要换行输出。

6、我们在使用开发工具Idea的时候,有很多快捷方式,比如写出300.for,回车直接可以自动生成结构,下面用for,我们这里先用while循环来实现题目。

 public class Demo {
     public static void main(String[] args) {
         int a=0;//初始化
 
         while (a<=300)//布尔表达式判断
         {
             a++;//迭代
             if (a%5==0)//除以5余数是0
             {
                 System.out.print(a+"\t");//输出所有符合条件的数写在一行,并用\t(tab键)间隔开
                 
                 //完成这步的时候,将所有符合除以5等于0的数,都输出在一行并间隔开。
             }
             if (a%(5*3)==0)//这里稍微绕一些,所以要反复理解
             {
                 System.out.print("\n");//换行
             }
         }
     }
 }

我们在上面看到了a%(5*3)==0,其实转变思维一下,题目的要求是输出三个换行,也就是说,当这个数字,除以15余数为0的时候,需要换行,大家看一下输出的结果就可以理解上去了,如果这个数是15,15除以15余数是0,所以到15的时候,满足一行是三个。

 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	
 
 进程结束......

我们上面用的是while循环来实现的需求,我们下面来看一下for循环的实现。

 public class Test {
     public static void main(String[] args) {
         
         for (int i = 1; i <= 300; i++)
         {
             if (i%5==0)
             {
                 System.out.print(i+"\t");
             }
             if (i%(5*3)==0)
             {
                 System.out.print("\n");
             }
         }
     }
 }

我们执行一下,发现输出的是一样的,但是这里注意,因为是每行输出三个,所以要抛出0,因为0输出的是一行一个。

 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	
 
 进程结束......
  • 用for循环输出九九乘法表。

    首先拿到需求,我们还是要讲需求分解。

1、九九乘法表是一个直角形状的。

在这里插入图片描述

2、我们要按照这个样式去实现,首先应该想办法输出第一列。

3、然后将固定的东西,经过循环的嵌套来实现,循环的嵌套就是可以在循环里面再循环😀。

4、我们用代码一步一步去分析,光看文字的话可能对于理解来说是比较困难的。

第一步:输出第一列
public class Demo {
    public static void main(String[] args) 
    {
        //输出第一列从1-9,所以要用条件<=9
        //i=1初始化为1
        //第一步:i=1的时候,输出的是1*1=1 执行迭代
        //第二步:i=i+1=2,输出的是1*2=2 执行迭代
		for (int i = 1; i <= 9; i++)
        {
            System.out.println(1+"*"+i+"="+(1*i));//拼出要输出的样式
        }
    }
}

这样,我们完成了第一列的打印,输出的结果为

1*1=1
1*2=2
1*3=3
1*4=4
1*5=5
1*6=6
1*7=7
1*8=8
1*9=9

进程结束......
第二步:嵌套循环

我们可以看到,刚刚输出的字符串里面,我们只是输出了第一列,所以直接写的固定值1。

System.out.println(1+"*"+i+"="+(1*i));

这里面第一个1,我们后边就用不到了,所以要把这个1,变成一个变量,让它去循环变化,所以,我们要在这个for循环的外层,再套一层for循环,用于将1这个固定值,变成一个根据循环变化的量。

public class Demo {
    public static void main(String[] args)
    {
        for (int j = 1; j <= 9; j++) 
        {
            
            for (int i = 1; i <= 9; i++)
            {
                System.out.println(j+"*"+i+"="+(j*i));
            }
            
        }
    }
}

我们在外层嵌套了一层,变量名字设置为j(可任意),然后我们将这个变量j,把刚刚输出语句的1进行替换,这样就把1 * 1 = 1第一个数字,变成了一个变量,但是这样运行呢,我们会发现一个问题,就是有重的,比如1 * 9 =9 和 9 * 1 = 1。

1*1=1
1*2=2
1*3=3
1*4=4
1*5=5
1*6=6
1*7=7
1*8=8
1*9=9
2*1=2
2*2=4
2*3=6
2*4=8
2*5=10
2*6=12
2*7=14
2*8=16
2*9=18
3*1=3
3*2=6
3*3=9
3*4=12
3*5=15
3*6=18
3*7=21
3*8=24
3*9=27
4*1=4
4*2=8
4*3=12
4*4=16
4*5=20
4*6=24
4*7=28
4*8=32
4*9=36
5*1=5
5*2=10
5*3=15
5*4=20
5*5=25
5*6=30
5*7=35
5*8=40
5*9=45
6*1=6
6*2=12
6*3=18
6*4=24
6*5=30
6*6=36
6*7=42
6*8=48
6*9=54
7*1=7
7*2=14
7*3=21
7*4=28
7*5=35
7*6=42
7*7=49
7*8=56
7*9=63
8*1=8
8*2=16
8*3=24
8*4=32
8*5=40
8*6=48
8*7=56
8*8=64
8*9=72
9*1=9
9*2=18
9*3=27
9*4=36
9*5=45
9*6=54
9*7=63
9*8=72
9*9=81

进程结束......

我们执行完以后,仔细观察一下,就会发现有很多重复项,所以我们要进行去重。

第三步:去重

我们为什么会出现刚刚的那种问题,是因为我们在第二个循环中,也把一个值,写死了,这个值就是里面循环中的9🤔

public class Demo {
    public static void main(String[] args)
    {
        for (int j = 1; j <= 9; j++) 
        {
            
            for (int i = 1; i <= 9; i++)//i<=9,因为这个9没有根据外部循环中的变量进行变化,所以一直在增加。
            {
                System.out.println(j+"*"+i+"="+(j*i));
            }
            
        }
    }
}

​ 上述的九九乘法表中,我们可以发现,是一个直角形状的,外部循环中的 j 是不断在变大的,从1一直循环到9,但是如果我们内部的 循环 i 也是在一直变大,也是从1一直循环到9,所以导致了有重复的项。

解决办法:这里,我们只需要,让 j 变大的同时 i 减小,就可以实现去重了。

public class Demo {
    public static void main(String[] args)
    {
        for (int j = 1; j <= 9; j++) 
        {
            
            for (int i = 1; i <= j; i++)//把9换成j
            {
                System.out.println(j+"*"+i+"="+(j*i));
            }
            
        }
    }
}
过程分析

我们可以在输出语句System前面打一个断点

​ 我用的工具是Idea,断点的作用就是可以卡在当前位置,不要点击运行,要点击编译,然后按F8,去看一步一步的走向😀,对于修补 程序bug,数据分析都是非常有意义的。

​ 我们打好断点以后,就可以看到如下提示,当 j =1 的时候,i = 1 ,输出的结果是1 * 1=1。

在这里插入图片描述

我们按F8向下运行,就可以看到,

j 通过迭代,变成了2,

i 还是初始化的1,1<=2,

所以先执行2 * 1=2,

然后 i 进行迭代 i=i+1=1+1=2,

i 的值,目前是2,2<=2,所以输出2 * 2=4,

然后 i 再次进行迭代,i=i+1=2+1=3,

i 的值,目前是3,3<=2是不成立的,所以退出循环,j 进行迭代…

在这里插入图片描述

依次类推,这回我们可以发现,运行以后没有重复的项了,最后一步,我们就是调整样式,让他变为一个直角形状😊。

第四步:样式调整
public class Test {
    public static void main(String[] args)
    {
        for (int j = 1; j <= 9; j++)
        {

            for (int i = 1; i <= j; i++)
            {
                System.out.print(j+"*"+i+"="+(j*i)+"\t");//先将所有的都输出在一行,用\t隔开
            }
            System.out.print("\n");//循环结束,换行

        }
    }
}

这样就可以实现我们的九九乘法表了,在里面循环不满足条件的时候,比如刚刚的3<=2是不成立的,所以退出循环,退出循环后,换行,就是 1 * 2 =2 2 * 2 = 4 输出结束,进行换行,就跳到了下一行,我们运行一下,看看输出的结果😀。

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

进程结束......

增强for循环

  • 在这里我们先介绍一下增强for循环,多用于集合和数组,我们以后的文章会说到。
  • Java5引入了一种主要用于数组或集合的增强型for循环。
  • 增强for循环使用方法:
for(声明语句:表达式)
{
	//执行循环的代码
}
  • 声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
  • 表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
  • 增强for循环实例说明:
public class Demo {
    public static void main(String[] args)
    {
        int[] numbers={10,20,30,40,50};//定义数组
		
        //遍历数组中的元素
        for (int x:numbers)
        {
            System.out.println(x);
        }
    }
}

  • 我们用for循环来实现一下上述的代码。
public class Demo {
    public static void main(String[] args)
    {
        int[] numbers={10,20,30,40,50};

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

我们运行以后,可以发现,通过循环,将数组里面的元素都按顺序取了出来。

10
20
30
40
50

进程结束.....

以上就是for循环的内容,内容非常的多,大家可以点赞收藏反复的观看理解,多去写代码去操作,只有多写才能理解透彻😀。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1344285.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

深入Mybatis数据源

数据源是持久层框架中最核心的组件之一&#xff0c;在实际工作中比较常见的数据源有 C3P0、Apache Common DBCP、Proxool 等。作为一款成熟的持久化框架&#xff0c;MyBatis 不仅自己提供了一套数据源实现&#xff0c;而且还能够方便地集成第三方数据源。 javax.sql.DataSourc…

Linux之缓冲区的理解

目录 一、问题引入 二、缓冲区 1、什么是缓冲区 2、刷新策略 3、缓冲区由谁提供 4、重看问题 三、缓冲区的简单实现 一、问题引入 我们先来看看下面的代码&#xff1a;我们使用了C语言接口和系统调用接口来进行文件操作。在代码的最后&#xff0c;我们还使用fork函数创建…

单纯形的几何意义 Simplex

单纯形是 n 维空间 n1 个仿射无关的点的集合的凸包。在几何意义上&#xff1a; 1维单纯形是一个线段2维单纯形是一个三角形3维单纯形是一个四面体&#xff08;tetrahedron&#xff09;

MySQL线上慢SQL问题分析处理小记

相同数据量表结构&#xff0c;线上执行12s 本地执行0.1s过程分析 1. 慢SQL信息 SELECT t1.id,t2.idFROM t_platform_target_standard_target_index t1LEFT JOIN t_platform_target_standard t2 ON t1.target_number t2.target_numberWHERE t1.delete_flag 0 AND t2.user_num …

Linux上管理不同版本的 JDK

当在 Linux 上管理不同版本的 JDK 时&#xff0c;使用 yum 和 dnf 可以方便地安装和切换不同的 JDK 版本。本文将介绍如何通过这两个包管理工具安装 JDK 1.8 和 JDK 11&#xff0c;并利用软连接动态关联这些版本。 安装 JDK 1.8 和 JDK 11 使用 yum 安装 JDK 1.8 打开终端并…

如何在 Linux 中配置 firewalld 规则

什么是FirewallD “firewalld”是firewall daemon。它提供了一个动态管理的防火墙&#xff0c;带有一个非常强大的过滤系统&#xff0c;称为 Netfilter&#xff0c;由 Linux 内核提供。 FirewallD 使用zones和services的概念&#xff0c;而 iptables 使用chain和rules。与 ip…

22款奔驰S450L升级主动式氛围灯 浪漫婉转的氛围感

主动式氛围灯有263个可多色渐变的LED光源&#xff0c;营造出全情沉浸的动态光影氛围。结合智能驾驶辅助系统&#xff0c;可在转向或检测到危险时&#xff0c;予以红色环境光提示&#xff0c;令光影艺术彰显智能魅力。配件有6个氛围灯&#xff0c;1个电脑模块。 1、气候&#xf…

Spring系列学习四、Spring数据访问

Spring数据访问 一、Spring中的JDBC模板介绍1、新建SpringBoot应用2、引入依赖&#xff1a;3、配置数据库连接&#xff0c;注入dbcTemplate对象&#xff0c;执行查询&#xff1a;4&#xff0c;测试验证&#xff1a; 二、整合MyBatis Plus1&#xff0c;在你的项目中添加MyBatis …

IP地址的四大类型:动态IP、固定IP、实体IP、虚拟IP的区别与应用

在网络通信中&#xff0c;IP地址是设备在互联网上唯一标识的关键元素。动态IP、固定IP、实体IP和虚拟IP是四种不同类型的IP地址&#xff0c;它们各自具有独特的特点和应用场景。 1. 动态IP地址&#xff1a; 动态IP地址是由Internet Service Provider&#xff08;ISP&#xff…

【嵌入式开发学习必备专栏】

文章目录 嵌入式开发学习必备专栏1.1 ARM Coresight SoC-400/SoC-600 专栏导读目录1.1.1 Performance Profiling1.1.2 ARM Coresight Debug 工具系列1.1.2.1 ARM DS5 系列1.1.2.2 劳特巴赫 Trace32 系列1.1.2.3 JTAG OpenOCD 系列 1.2 ARM Cache 专栏1.3 ARM AMBA Bus 专栏1.3.…

vue3 组件之间传值

vue3 组件之间传值 非常好&#xff0c;为啥突然开这样一篇博文&#xff0c;首先是因为 vue3 是未来发展的趋势。其次&#xff0c;vue 官方已经确认&#xff0c;将于2023年最后一天停止对 vue2 项目的维护&#xff0c;这个是官方发出的通知&#xff0c;并且呢&#xff0c;尤雨溪…

FPGA设计时序约束十四、Set_External_Delay

一、序言 在时序约束中对clock的约束还存在一种特殊的延时约束set external delay。set external delay如字面含义&#xff0c;设置外部的时延值&#xff0c;但这个外部时延主要是指反馈时延&#xff0c;即信号从FPGA的output端口输出后经过外部电路回到输入端口的时延值。 二…

JavaSE语法之十二:Object类

文章目录 一、概念二、获取对象信息三、对象比较equals方法四、hashcode方法 一、概念 Object是Java默认提供的一个类。Java里面除了Object类&#xff0c;所有的类都是存在继承关系的&#xff0c;默认会继承Object父类&#xff0c;即所有的类的对象都可以使用Object的引用进行…

前端基础(三十七):属性结构数据进行关键字筛选

效果 核心源码 type MenuItem {label: string;key: string | number;icon?: React.ReactNode;children?: MenuItem[];type?: group; }function filterTreeData(tree: MenuItem[], keyword: string): MenuItem[] {return tree.filter((node: MenuItem) > {if (node.labe…

macOS系统打开Linux的方法

第一步 按下[command空格键]调出搜索框&#xff0c;输入“终端”&#xff0c;打开图上第一个 第二步 如图先输入"sudo -i"&#xff0c;敲回车键&#xff0c;再输入开机密码&#xff0c;再敲回车键就可以打开。注意&#xff1a;这里的密码输入不会显示在页面。 如果要…

西城微科|打气泵芯片方案SIC8833

SIC8833作为一款高性能的打气泵方案芯片&#xff0c;这款芯片是一个带24bitADC的8位RISC MCU&#xff0c;内置8k16位OTP程序存储器。具体24位双向I/O口的特性&#xff0c;广泛应用于气压检测和精密测量及控制系统&#xff0c;能满足用户的不同需求和应用场景。 以下是打气泵方案…

Observer观察者模式(组件协作)

观察者模式&#xff08;组件协作&#xff09; 链接&#xff1a;观察者模式实例代码 解析 目的 在软件构建过程中&#xff0c;我们需要为某些对象建立一种“通知依赖关系” ——一个对象&#xff08;目标对象&#xff09;的状态发生改变&#xff0c;所有的依赖对象&#xff0…

关于Sql数据库中去掉字段的所有空格

这篇文章主要介绍了Sql数据库中去掉字段的所有空格小结篇,本文通过示例代码给大家介绍的非常详细&#xff0c;对大家的学习或工作具有一定的参考借鉴价值&#xff0c;需要的朋友可以参考下 − Sql数据库中去掉字段的所有空格 字符前的空格&#xff0c;用ltrim(string) 字符…

关于“Python”的核心知识点整理大全51

目录 17.2.2 添加自定义工具提示 bar_descriptions.py 17.2.3 根据数据绘图 python_repos.py 17.2.4 在图表中添加可单击的链接 python_repos.py 17.3 Hacker News API hn_submissions.py 17.4 小结 往期快速传送门&#x1f446;&#xff08;在文章最后&#xff09;&a…

ES6语法特性(二)迭代器 生成器 Promise介绍

迭代器 生成器 Promise介绍 1. 迭代器 迭代器就是为实现对不同集合进行统一遍历操作的一种机制&#xff0c;只要给需要遍历的数据结构部署Iterator接口&#xff0c;通过调用该接口&#xff0c;或者使用消耗该接口的API实现遍历操作。   ES6为迭代器引入了一个隐式的标准化接…