java程序流程控制之三：
Ⅰ、循环结构：while 循环
1、while 循环结构：
其一、描述：
While 循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.写while循环千万小心不要丢了迭代条件; 一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环;
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同(即：作用域不同);
算法：有限性(因为我们写的程序都可以称为算法，因此要遵循算法的有限性要求);
其二、代码为：
class WhileTest{
public static void main(String[] args) {
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用。
System.out.println(i);//101
}
}
其三、截图为：
Ⅱ、循环结构：do-while 循环
1、do-while 循环结构：
其一、描述：
do-while循环的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件
二、do-while循环结构：
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些; 较少使用do-while;
其二、代码为：
class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("总和为：" + sum);//2550
System.out.println("个数为：" + count);//50
//*************体会do-while至少执行一次循环体***************
int number1 = 10;
while(number1 > 10){
System.out.println("hello:while");
number1--;
}
int number2 = 10;
do{
System.out.println("hello:do-while");//hello:do-while
number2--;
}while(number2 > 10);
}
}
其三、截图为：
2、do-while 循环结构的案例1：输出正数或负数的个数
其一、描述：
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为 0 时结束程序。
说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
方式一：循环条件部分返回 false
方式二：在循环体中，执行 break
其二、代码为：
import java.util.Scanner;
class ForWhileTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
for(;;){//while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break，跳出循环
break;
}
}
System.out.println("输入的正数个数为：" + positiveNumber);
System.out.println("输入的负数个数为：" + negativeNumber);
}
}
其三、截图为：
Ⅲ、嵌套循环的使用：
1、嵌套循环结构：
其一、描述：
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次; 此时内层循环的循环体一共执行了m * n次
4. 技巧：
外层循环控制行数，内层循环控制列数
其二、代码为：
class ForForTest {
public static void main(String[] args) {
//******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println("\n");
/*
******
******
******
******
*/
for(int j = 1;j <= 4;j++ ){
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println();
}
/* i(行号) j(*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for(int i = 1;i <= 5;i++){//控制行数
for(int j = 1;j <= i;j++){//控制列数
System.out.print("*");
}
System.out.println();
}
/* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i;
**** 1 4
*** 2 3
** 3 2
* 4 1
*/
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*****
****
***
**
*
*/
}
}
其三、截图为：
2、for for 嵌套循环结构的案例1：九九乘法表
其一、描述：
嵌套循环的应用1：
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
其二、代码为：
class NineNineTable {
public static void main(String[] args) {
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + " * " + j + " = " + (i * j) + " ");
}
System.out.println();
}
}
}
其三、截图为：
3、for for 嵌套循环结构的案例2：100内的所有质数
其一、描述：
100 以内的所有质数的输出。
质数：素数，只能被 1 和它本身整除的自然数。--> 从 2 开始，到这个数 -1 结束为止，都不能被这个数本身整除。
最小的质数是：2
其二、代码为：
class PrimeNumberTest {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
for(int i = 2;i <= 100;i++){//遍历100以内的自然数
for(int j = 2;j < i;j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
}
}
//
if(isFlag == true){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
}
}
其三、截图为：
4、for for 嵌套循环结构的案例3：100000内的所有质数
其一、描述：
100000 以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从 2 开始，到这个数 -1 结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
其二、代码为：
class PrimeNumberTest1 {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
//优化一：具体实施的方案;
//for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//
// for(int j = 2;j < i;j++){//j:被i去除
//
// if(i % j == 0){ //i被j除尽
// isFlag = false;
// break;//优化一：只对本身非质数的自然数是有效的。
// }
//
// }
// //
// if(isFlag == true){
// System.out.println(i);
// }
// //重置isFlag
// isFlag = true;
//
//}
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二：对本身是质数的自然数是有效的;
//Math.sqrt(i) 是指：求 i 的根号值,最多到根号 i 就能将排查合数的工作做完了;
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的。
}
}
if(isFlag == true){
//System.out.println(i);
//取消直接输出 i 的操作，因为是在大量的输出数据下，会拖慢算法的时间;
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110(6770) - 优化一：break:1546(638) - 优化二：13(6)
}
}
其三、截图为：
5、for for 嵌套循环结构的案例4：100000内的所有质数(优化)
其一、描述：
100000 以内的所有质数的输出。实现方式二
质数：素数，只能被 1 和它本身整除的自然数。-->从 2 开始，到这个数 -1 结束为止，都不能被这个数本身整除。
对 PrimeNumberTest.java 文件中质数输出问题的优化
其二、代码为：
class PrimeNumberTest2 {
public static void main(String[] args) {
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
continue label;
}
}
//能执行到此步骤的,都是质数;
count++;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110(6770) - 优化一：break:1546(638) - 优化二：13(6) - 新方法: 13(11);
}
}
其三、截图为：
Ⅳ、关键字：break 与 continue
1、break 与 continue 关键字：
其一、描述：
break 和 continue 关键字的使用：
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
其二、代码为：
class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
break;//输出:1,2,3;
//continue;//输出:1,2,3,5,6,7,9,10;
//System.out.println("今晚迪丽热巴要约我！！！");//会报错，因为该语句永远不会被执行;
}
System.out.print(i);
}
System.out.println("\n");
//******************************
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环;
//输出结果:123,123,123,123;
//continue;
//输出结果为:123567910,123567910,123567910,123567910;
//break label;//结束指定标识的一层循环结构(注意：此时的 label 是标签而不是关键字)
//输出结果为:123;
continue label;//结束指定标识的一层循环结构当次循环
//输出结果为：123123123123;
}
System.out.print(j);
}
System.out.println();
}
}
其三、截图为：
Ⅴ、小结：
其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！