流程控制即程序代码的执行顺序，所有的程序都是从上而下顺序执行的，这也是所谓的顺序结构，但代码并非是绝对的从上而下执行，因为有的代码可能不会执行，有的代码可能会重复执行，这分别对应着流程控制的分支结构以及循环结构，这篇文章记录了我对循环结构的理解…
◆ 基本使用
1. for 语句
语法格式
for (初始化语句; 条件判断语句; 步进语句)
{
循环体语句;
}
- 初始化语句是用逗号分隔的任意多条 Java 表达式，可默认不写，但它后面的分号不可以省略，仅在最开始执行且只执行一次，通常用于变量初始化赋值
- 条件判断语句是布尔表达式，用于判定循环是否继续执行，若该部分默认不写，则表示条件永远为真，成为死循环，其后的分号同样不可省略
- 步进语句也是用逗号分隔的任意多条 Java 表达式，它通常用于改变与判断语句相关的条件，这部分也可以默认不写
- 循环体语句是需要重复执行的语句，如果该部分只有一条语句，大括号可以省略不写
- for 语句的语义即首先从左至右一次执行初始化语句，其次计算条件判断语句的值，若为 false ，程序继续执行 for 语句之后的语句，否则，程序将依次执行循环体语句，然后依次执行步进语句，最后再次计算条件判断语句的值，依上述规律循环往复，直至条件判断语句的值为 false
使用方式
for 语句通常用于能够确定执行次数的循环
//Demo.java
public class Demo
{
public static void main(String[] args)
{
for (int i = 1, System.out.println("一条初始化语句");
i < 5; i++, System.out.println("步进语句"+i))
{
System.out.println("循环体语句"+i);
}
}
}
- 初始化语句和步进语句不仅可以是变量声明或者赋值语句，它可以是任意的 Java 表达式，这在有些时候会有很神奇的表现
初始化语句也可以写在 for 语句之前，步进语句可以写在循环体语句中
//Demo.java
/*
计算 1+2+3+...+100 的值
*/
public class Demo
{
public static void main(String[] args)
{
int i = 1;
int sum = 0;
for (; i <= 100; )
{
sum += i;
i++;
}
System.out.println("i = " + i);
System.out.println("sum = " + sum);
}
}
- 初始化语句的声明置于 for 语句之前，可以保证在 for 语句结束之后，仍可以被使用
循环语句只有一条时，可以省略大括号
//Demo.java
/*
计算 1+2+3+...+100 的值
*/
public class Demo
{
public static void main(String[] args)
{
int i;
int sum = 0;
for (i = 1; i <= 100; i++)
sum += i;
System.out.println("i = " + i);
System.out.println("sum = " + sum);
}
}
2. while 语句
语法格式
while (条件判断语句)
{
循环体语句
}
- 条件判断语句是布尔表达式，用于判定循环是否继续执行，若该部分默认不写，则表示条件永远为真，成为死循环
- 循环体语句是需要重复执行的语句，如果该部分只有一条语句，大括号可以省略不写
- while 语句的语义即首先计算条件判断语句的值，若为 false ，程序继续执行 while 语句之后的语句，否则，程序将依次执行循环体语句，然后后再次计算条件判断语句的值，依上述规律循环往复，直至条件判断语句的值为 false
使用方式
while 语句常用于难以确定执行次数的循环
//Demo.java
/*
求一个数值得所有计数单位中包含多少个偶数，
假设这个数是6512458
*/
class Demo
{
public static void main(String[] args)
{
int number, digit, sum;
number = 6512458;
sum = 0;
while (number != 0) //如果number！=0，继续执行循环体
{
digit = number % 10; //取当前number的个位数
if (digit % 2 == 0) //如果digit为偶数，sum就加1
sum++;
number = number / 10; //number对10取整
}
System.out.println("sum = " + sum);
}
}
3. do…while 语句
语法格式
do
{
循环体语句
}
while(条件判断语句);
- 循环体语句是需要重复执行的语句，如果该部分只有一条语句，大括号可以省略不写
- 条件判断语句是布尔表达式，用于判定循环是否继续执行，若该部分默认不写，则表示条件永远为真，成为死循环
- do…while 语句的语义即首先依次执行循环体语句，其次计算条件判断语句的值，若为 false ，程序继续执行 do…while 语句之后的语句，否则，程序将再次执行循环体语句，然后后再次计算条件判断语句的值，依上述规律循环往复，直至条件判断语句的值为 false
使用方式
do…while 语句与 while 语句几乎一致，唯一的区别就是它会先执行一次循环体语句，然后再判定循环是否继续
//Demo.java
public class Demo
{
public static void main(String[] args)
{
int key = 1;
do
{
System.out.println("一条循环语句" + key);
key++;
}
while (key < 0);
}
}
◆ 语句嵌套
在日常的程序开发中，即使是一些玩具性的演示代码，也不可能只单独使用某种控制流程，多数情况下，我们都会组合不同的控制流程，其中，不同的语句嵌套更是频繁出现…
循环的嵌套可以帮助我们省略很多不必要操作，使代码更加简洁
//Demo.java
/*
打印如下图形
*****
*****
*****
*****
*****
*/
public class Demo
{
public static void main(String[] args)
{
int i, j;
for (i = 1; i <= 5; i++) //外层循环
{
for (j = 1; j <= 5; j++) //内层循环
{
System.out.print("*");
}
System.out.println(); //内层循环结束后，换行
}
}
}
//Demo.java
/*
打印如下图形
*
* *
* * *
* * * *
* * * * *
*/
public class Demo
{
public static void main(String[] args)
{
int i, j;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= i; j++) //控制每行的输出数量
{
System.out.print("*");
}
System.out.println();
}
}
}
循环与分支的嵌套则可以实现更细节的控制
//Demo.java
/*
打印如下图形
*
* *
* * *
* * * *
* * * * *
*/
public class Demo
{
public static void main(String[] args)
{
int i, j;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= 5; j++)
{
if (j <= 5 - i) //控制输出形状
System.out.print(" ");
else
System.out.print("* ");
}
System.out.println();
}
}
}
//Demo.java
/*
打印如下图形
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
*/
public class Demo
{
public static void main(String[] args)
{
int i, j;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= 5; j++)
{
if (j <= 5 - i)
System.out.print(" ");
else
System.out.print(i+" "); //* 替换为数字
}
System.out.println();
}
}
}
//Demo.java
/*
打印如下图形
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
4 4 4 4
3 3 3
2 2
1
*/
public class Demo
{
public static void main(String[] args)
{
int i, j;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= 5; j++)
{
if (j <= 5 - i)
System.out.print(" ");
else
System.out.print(i+" ");
}
System.out.println();
}
for (i = 4; i >= 1; i--) //反向打印数字金字塔
{
for (j = 1; j <= 5; j++)
{
if (j <= 5 - i)
System.out.print(" ");
else
System.out.print(i+" ");
}
System.out.println();
}
}
}
◆ 跳出语句
有些时候，我们有必要在碰到一些特殊情况时，立刻结束循环，这也就是跳出语句，它涉及到 break 和 continue 两个关键字，跳出语句不仅适用于一般的循环，还常用在嵌套循环以及无限循环中。
1. 无限循环
无限循环，又称死循环，它是指条件判断语句的值始终为真，程序无法正常结束的一种特殊情况，这里就明确一下它的一般语法格式
//for 语句无限循环
for (; ; )
{
循环体语句;
}
//while 语句无限循环
while (true)
{
循环体语句;
}
//do...while 语句无限循环
do
{
循环体语句;
}
while (true)
2. 使用方式
break 语句的作用是跳出该循环，继续执行循环之后的语句
//Demo.java
/*
判断一个数是否是素数
*/
public class Demo
{
public static void main(String[] args)
{
int number = 4;
int i;
for (i = 2; i <= number / 2; i++) //遍历可能的每组因数之一
{
if (number % i == 0) //如果有因数则跳出循环
{
break;
}
}
if (i > number / 2) //如果循环是正常结束
{
System.out.println("i = " + i);
System.out.println(number + " 是一个素数！");
}
else
{
System.out.println("i = " + i);
System.out.println(number + " 不是一个素数！");
}
}
}
Java 还提供了一种带标签的 break 语句，用于跳出多重嵌套的循环语句
//Demo.java
public class Demo
{
public static void main(String[] args)
{
int i;
int number=4;
temp: //while 循环标签
while(true) //无限循环
{
for (i = 2; i <= number / 2; i++)
{
if (number % i == 0)
{
break temp; //跳至标签所在循环结束处
}
}
if (i > number / 2)
{
System.out.println("i = " + i);
System.out.println(number + " 是一个素数！");
}
else
{
System.out.println("i = " + i);
System.out.println(number + " 不是一个素数！");
}
}
System.out.println("程序已结束！");
}
}
continue 语句的作用的跳出本次循环，继续执行下一次循环
//Demo.java
/*
输出自然数中的前 10 个素数
*/
public class Demo
{
public static void main(String[] args)
{
int i, j, sum;
i = 2;
sum = 0;
for (; ; ) //无限循环
{
for (j = 2; j <= i / 2; j++)
{
if (i % j == 0)
break;
}
if (j > i / 2)
{
System.out.print(i + " ");
sum++;
i++;
}
else
{
i++;
continue; //跳出本次循环，从下一次循环继续
}
if (sum == 10)
{
break;
}
}
System.out.println();
}
}
扫一扫
7956
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
