关于java循环结构for

关于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循环的内容，内容非常的多，大家可以点赞收藏反复的观看理解，多去写代码去操作，只有多写才能理解透彻😀。