补充循环结构

循环结构

while(布尔表达式)
{
    //循环内容
}
/*只要布尔表达式为true，循环就会一直执行下去
我们大多数情况是会让循环停止下来，所以我们需要一个让表达式失效的方式来结束循环
少部分需要循环一直执行下去比如服务器的请求相应监听等
循环条件一直为true就会造成无限循环，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃
*/

package struct;
​
public class WhileDemo01 {
    public static void main(String[] args) {
        int i=0;
​
        while (i<100)
        {
            i++;
            System.out.println(i);
        }
​
    }
}//这个是从1~100顺序排列输出下来
​

//题目是从1+2一直加到+100=来算5050是结果
package struct;
​
public class WhileDemo01 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        while (i<100)
        {
            i++;
            sum=sum+i;
​
​
            System.out.println();
        }
        System.out.println(sum);
​
    }
}
​

do...while循环

对于while语句而言，while是先判断后执行，do...while是先执行一次在判断。

do...while总是保证循环体至少被执行一次这是他们的差别

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

package struct;
​
public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
        do {
            sum=sum+i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
​
}

package struct;
​
public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a=0;
        while (a<0)
        {
            System.out.println(a);
            a++;
        }
        System.out.println("========================");
        do {
            System.out.println(a);
            a++;
        }while (a<0);
    }
}
​

for循环

for循环语句是支持迭代的一种通用结构，是最有效,最灵活的循环结构。

//语法格式
for(初始化;布尔表达式;更新（也可以叫做迭代）)
{
    //代码语句
}

package struct;
​
public class ForDemo01 {
    public static void main(String[] args) {
        int a=1;
        while (a<100)//条件判断
        {
            System.out.println(a);//循环体
            a+=50;//迭代
​
        }
        System.out.println("while循环结束");
        for (int i=1;i<=100;i+=50)
        {
            System.out.println(i);
        }
        System.out.println("for循环结束");
    }
}
​
​

死循环

for( ; ; )
{
    
}

注意以下有几点说明for循环

1. 最先执行初始化步骤，可以声明一种类型但是可以初始化一个或多个循环控制变量，也可以是空语句

2. 然后检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句

3. 执行一次循环后，更新循环控制变量（迭代银子控制循环变量的增减）

4. 再次检测布尔表达式，循环以上过程

//0-100奇数和偶数的和
package LianXi;
​
public class XiTi03 {
    public static void main(String[] args) {
        int JiSum=0;
        int OuSum=0;
        for (int i = 0; i <= 100; i++) {
            if (i%2!=0)
            {
                JiSum=JiSum+i;
            }
            if (i%2==0)
            {
                OuSum=OuSum+i;
            }
​
​
        }
        System.out.println(JiSum);
        System.out.println(OuSum);
    }
}

package LianXi;
​
public class XiTi02 {
    public static void main(String[] args) {
        //用while或者for循环输出1~1000之间可以被5整除的数，并且每行输出三个。
        for (int i = 0; i <=1000; i++)
        {
            if (i%5==0)
            {
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0)
            {
                System.out.println();
            }
​
        }
    }
}
​

//打印9*9乘法表
package LianXi;
​
public class XiTi01 {
    public static void main(String[] args)
    {
        //我们先打印第一列，
        //我们把规定的1再用一个循环包起来
        //去掉重复项
        //调整样式
        for (int j=1;j<=9;j++)
        {
​
            for (int i = 1; i <= j; i++)
            {
                System.out.print(j+ "*" + i + "=" + (j * i)+"\t");
​
            }
            System.out.println();
        }
    }
}
​

增强for循环

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

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

package struct;
​
public class ForDemo03 {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40};
        //遍历数组元素
        for (int i = 0; i < 4; i++)
        {
            System.out.println(numbers[i]);
        }
        System.out.println("===========================");
        for (int x:numbers)
        {
            System.out.print(x+"\t");
        }
​
    }
}
​

break continue

break在任何循环语句的主体部分，均可使用break控制循环的流程。break用于强行退出循环

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次执行循环的判定

package struct;
​
public class BreakDemo01 {
    public static void main(String[] args) {
        int a=0;
        while (a<100)
        {
            a++;
            if (a==30)
            {
                break;
            }
        }
        System.out.println(a);
    }
}
​
​

package struct;
​
public class ContinueDemo01 {
    public static void main(String[] args) {
        int i=0;
        while (i<100)
        {
            i++;
            if (i%10==0)
            {
                System.out.println();
                continue;//跳过一些循环不执行
            }
            System.out.println(i);
        }
    }
}
​

goto关键字

goto关键字是一个保留字不在java中使用

标签是指后面跟一个：这个符号有点像continue直接跳转到标签那边

package struct;
​
public class LabelDemo01 {
    public static void main(String[] args) {
        //打印101~150之间所有的质数
        //质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数
        int count=0;
       outer:for (int i = 101; i < 150; i++)
        {
            for (int j=2;j<i/2;j++)
            {
                if (i%j==0)
                {
                    continue outer;
                }
            }
            System.out.print(i+"\t");
        }
    }
}
​