1.循环结构
1.1 定义:在某些条件满足的情况下，反复执行特定代码的功能
1.2 分类:
for循环
while循环
do - while循环
1.3 循环语句的四个组成部分(要素)：
(1)初始化部分
(2)循环条件部分 --->是boolean类型得条件表达式
(3)循环体部分
(4)迭代部分
1.4 执行顺序：
(1)初始化部分(只执行一次，进入循环条件,对变量的初始值进行定义)
(2)循环条件部分(可多次进行判断，直到条件不再满足的情况下就跳出循环,接着执行接下来的顺序执行语句)
(3)循环体部分(进行循环体内部多次反复执行的语句)
(4)迭代部分(对初始化的部分进行迭代，可以理解为为初始化条件多次进行改变，改变之后判断循环条件是否满足，满足则继续执行，不满足就跳出循环，接着循序执行之后的代码)
2.for循环
2.1 格式:
for((1)初始化条件；(2)循环条件；(3)迭代条件){
(4)循环体;
}
2.2 执行顺序：
[ (1)-(2)-(4)-(3) ]、[ (2-(4)-(3) ]、[ (2)-(4)-(3) ] (2、4、3不断重复执行)、(2)，直到最后累加的迭代条件不在满足循环条件的时候则跳出循环
for循环得测试用例:
public class For_Test {
public static void main(String[] args) {
//输出6遍Hello World;
/*需要执行重复功能的代码块的时候，这样显然搞得代码很冗余，所以再java中引入了循环结构
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
System.out.println("Hello World!");
*/
for(int i = 0;i <= 5;i++) { //此处的初始化条件定义一个int整型变量i,是局部变量，在主函数中只能定义一个同名变量
System.out.println("Hello World!"); //功能性重复，反复要执行的代码
}
//System.out.println(i); 编译出错，局部变量i只在for循环内有效，出了for循环就不能调用了
//练习1
int num = 1;
for(System.out.println('a');num <= 3;System.out.println('c'),num++) {
System.out.println('b');
}
//输出结果:abcbcbc
//初始化条件为:int num = 1,输出'a',只执行一次
//判断循环继续条件num <= 3;
//执行语句:输出'b'，输出3次
//迭代条件:输出'c'，并进行初始化变量的迭代,执行3次
//例题：遍历100以内的偶数，输出所有偶数的和,输出偶数的个数
int sum = 0; //记录累加和
int count = 0; //记录偶数的个数
for(int i = 1;i <= 100;i++) {
if(i % 2 == 0) {
sum += i;
count++;
System.out.println(i);
}
}
System.out.println("总和为："+sum);
System.out.println("偶数的个数为:"+count);
}
}
例:12和20的最大公约数是4，最小公倍数是60
最大公约数:(1)首先找一个数能被两数都整除，那么这个数就是两数的公约数
(2)思路一：最大肯定可以找到最小数的范围之内，定义一个循环，从1开始最大到两数中的最小数去寻找，找到一个就将这个数赋值给gys，找到下一个大的公约数，则覆盖较小公约数，直到跳出循环，最终赋值的公约数就是最大公约数
思路二：从两数中的最小数开始向下遍历，一旦两数都能同时把这个数除尽，那么毫无疑问，那么肯定就是最大的公约数，因为是从大到小开始遍历的
最小公倍数:(1)首先找一个数能把两个数都整除，那么这个数肯定就是两数的公倍数
(2)最小公倍数肯定最小也得大于两数中得最大数，我们这样想，从两数中得较大数来开始遍历，遍历最大大不到两者得乘积,一直递增进行操作，一旦找到一个数可以直接将两数都整除，肯定就可以确定该数就是最小得公倍数了，就可以跳出循环，否则继续进行迭代
求两数最大公约数和最小公倍数得测试用例:
public class XunHuan1_Test {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int num1 = scan.nextInt();
System.out.println("请输入第二个正整数：");
int num2 = scan.nextInt();
int gys = 0;
int min = num1 < num2?num1 : num2; //获取两数的较小数
int max = num1 > num2?num1 : num2; //获取两数的较大数
/*for(int i = 1;i <= min;i++) {
if(num1 % i ==0 && num2 % i == 0) {
gys = i;
}
}
System.out.println("两数的最大公约数为: "+gys);
*/
for(int i = min;i >= 1;i--) {
if(num1 % i ==0 && num2 % i == 0) {
System.out.println("最大公约数为: "+i); //输出最大公约数
break; //跳出当前循环语句，不在执行循环结构，若无break语句，那么每个公约数都会进行输出
}
}
int j = max;
for(;j <= max * min;j++) {
if(j % num1 ==0 && j % num2 == 0) {
System.out.println("两数的最小公倍数为"+j);
break;
}
}
}
}
说明:break关键字的使用：
一旦在循环执行break语句，那么就直接跳出当前循环，循环语句不在进行执行
3.while结构
3.1循环语句的四个组成部分(要素)：
(1)初始化部分
(2)循环条件部分 --->是boolean类型
(3)循环体部分
(4)迭代部分
3.2while循环得结构：
(1)
while( (2) ){
(3);
(4);
}
注意：执行顺序和for循环相同:[ (1)-(2)-(4)-(3) ]、[ (2)-(4)-(3) ]、[ (2)-(4)-(3) ] (2、4、3不断重复执行)、(2)，直到最后累加的迭代条件不再满足循环条件的时候则跳出循环
3.3说明:
1.写while循环千万不能忘记写迭代得条件，否则会一个变量值无法进行迭代，反复执行执行条件，没有跳出条件，造成死循环!
2.我们写程序，要避免死循环。
3.for循环和while循环是可以相互转换得！
4.for循环和while循环得初始化条件不同
注意:for循环条件内定义得变量i只能在for循环之内有效调用，while循环初始化条件定义在外部，初始化条件变量也可以进行调用，在一整个函数之内有效调用。
while循环的测试用例:
public class While_Test {
public static void main(String[] args) {
//遍历100以内得所有偶数
int i = 1;
while(i <= 100) {
if(i % 2 == 0) {
System.out.println(i);
}
i++;
}
//最后输出得一个偶数为100，执行语句执行完之后，继续进行迭代操作，此时i值已经变成了101，不满足循环继续条件，跳出循环
System.out.println(i); //101
}
}
4.do - while循环
4.1循环语句的四个组成部分(要素)：
(1)初始化部分
(2)循环条件部分 --->是boolean类型
(3)循环体部分
(4)迭代部分
4.2结构：
(1)
do{
(3)
(4)
}while( (2) );
执行过程:(1) - (3) - (4) - (2) - (3) - (4) - ... - (2)
4.3说明：
(1)do - while循环至少会执行一次循环体!（不管三七二十一，进去先执行一次循环体，之后在进行判断条件是否满足循环条件）
(2)开发中，大多使用for循环和while循环进行循环语句的执行，较少使用do - while语句
do - while循环的测试用例:
public class DoWhIle_Test {
public static void main(String[] args) {
//输出100以内的偶数
int num = 1;
do {
if(num % 2 == 0) {
System.out.println(num);
}
num++;
}while(num <= 100);
//-----------------------do - while循环语句至少执行一次-----------------------------------
int num2 = 18;
do {
System.out.println(num2); //18，会进行一次输出
num2++;
}while(num2 > 20); //判断条件不满足，无法继续执行循环语句
}
}
while(true)无限循环，用户自定义判出条件的测试用例：
/*题目:*
* 从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时，程序结束
*
**/
import java.util.Scanner;
public class ForWhile_Test {
public static void main(String[] args) {
int positiveNumber = 0; //记录正数的个数
int negativeNumber = 0; //记录负数的个数
Scanner scan = new Scanner(System.in);
while(true) { //等价于for(;;) {,意味着没有任何初始化条件，循环条件直接进入，无限循环执行，判出条件为用户自定义
System.out.print("请输入你想输入的数据: ");
int number = scan.nextInt();
//判断正负数情况
if(number > 0) {
positiveNumber++;
}else if(number < 0) {
negativeNumber++;
}else {
break; //一旦执行break，那么就跳出循环
}
}
System.out.println("负数个数为 " + negativeNumber +"个\n" + "正数个数为 "+ positiveNumber +"个");
}
}说明:
1.不在循环条件部分限制次数的结构:for(;;)或while(true)
2.结束循环有几种方式?
(1)方式一:循环部分返回false
(2)方式二:在循环体中，执行break
5.嵌套循环
5.1使用：
1.嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中
2.外层循环:循环结构B，控制内部整体循环结构执行的次数(轮数)，内层整体的循环结构相当于外层循环的一次循环体的执行语句
内层循环:循环结构A，内层循环控制个数，控制内部循环执行语句的执行次数
5.2说明：
(1)内存循环结构遍历一次，只相当于外层循环执行了一次
(2)假设外层循环需要执行m次，内存循环需要执行n次。此时内层循环的循环体一种执行了:m * n次
5.3使用技巧:
外层循环控制行数，内层循环控制列数
嵌套循环的测试用例:
public class QianTao_Test {
public static void main(String[] args) {
//输出******
for(int i = 1;i <= 6;i++) {
System.out.print('*');
}
System.out.println();
/*输出：
* ******
* ******
* ******
* ******
* ******
* */
for(int i = 0;i <= 4;i++) { //外层循环控制行数，控制内部整体循环结构执行的次数，内层整体的循环结构相当于外层循环的一次循环体的执行语句
for(int j = 1;j <= 6;j++) { //内层循环控制个数，控制内部循环执行语句的执行次数
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++) { //控制列数，因为每列的*个数都是变化的，所以也就需要找变化的变量来和它进行匹配，那么外层循环变量i是最好的选择
System.out.print('*');
}
System.out.println();
}
/*输出: i(打印的行号) j(*的个数)
规律:i + j = 6,那么*的个数j = 6 - i
* ***** 1 5
* **** 2 4
* *** 3 3
* ** 4 2
* * 5 1
* */
for(int i = 1;i <= 5;i++) {
for(int j = 1;j <= 6 -i;j++) {
System.out.print("*");
}
System.out.println();
}
}
}嵌套循环的测试用例一:九九乘法表
//嵌套循环应用一:九九乘法表
public class NineNine_Test {
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 + "\t");
}
//打印完一整行，进行换行操作
System.out.println();
}
}
}
嵌套循环的测试用例二:100以内的质数
/*
输出100以内的所有的质数(只能被1和它本身整除的自然数就是质数，素数)
质数(素数):只能被1和它本身整除的自然数。--->从2开始到这个数-1结束为止，都不能被这个数整除为止
最小的质数:2
*/
public class PrimeNumber_Test {
public static void main(String[] args) {
//方式一：
long start = System.currentTimeMillis();
//计算当前时间距1970年01月01日00时00分00秒的毫秒数，返回的是一个long类型的数值，程序开始执行时得毫秒数
for(int i = 2;i <= 100;i++) { //除数
int sumNum = 1; //统计该数的约数，计数器
for(int j = 2;j < i;j++) { //被除数,不计算1和它本身
if(i % j == 0) {
sumNum++;
}
}
if(sumNum == 1) { //计数器不变，代表没有其它的约数了
System.out.println(i); //输出该质数
}
}
long end = System.currentTimeMillis(); //程序执行结束之后返回得毫秒数
System.out.println("所花费得时间为: "+ (end - start)); //计算整体找质数程序得运行时长
嵌套循环的测试用例二得优化:100以内的质数
//优化方式二：
long start1 = System.currentTimeMillis();
boolean isFlag = true; //将表征符号定义在外部节省空间，不要每次都创建一个新变量(内存空间)
for(int i = 2;i <= 100;i++) { //除数
//优化二:对本身是非质数得自然数是有效得
for(int j = 2;j <= Math.sqrt(i);j++) { //被除数,不计算1和它本身，
if(i % j == 0) {
isFlag = false;
break; //优化一:只对本身是非质数的自然数是有效的，因为只有非质数自然数才能进入此判断条件
//只要有一个新的约数，那它必然就不是一个质数了，之后的被除数的情况也不需要考虑了，直接break跳出内层循环，开启外层新一个自然数的循环
}
}
if(isFlag == true) { //表征符号不变，没有其它的约数了
System.out.println(i); //输出该质数
}
isFlag = true; //每一个自然数(除数)，内层判断完之后，要对外部自然数表征符号isFlag进行重置，否则会出现输出不足的情况
}
long end1 = System.currentTimeMillis();
System.out.println("所花费得时间为: "+ (end1 - start1));
}
}说明:由于过小得数据量无法体现两执行程序得具体执行效率差距，所以我们将其中得数据量从100改成了100000，未优化得方法寻找质数总时长为12906ms，优化之后得方法寻找质数总时长为91ms，可以看出两算法之间明显得差距，未优化代码和优化之后得代码得执行效率几乎是几何倍增长，所以代码不在于代码量得大小，而在于其执行效率
6.循环语句中得关键字break和continue解析
- break关键字得适用范围: 循环中使用得作用(不同点) 相同点
switch - case语句
循环结构中 结束当前循环 关键字后面不能声明执行语句
- continue关键字得适用范围：
循环结构中 结束当次循环 关键字后面不能声明执行语句
break - continue测试用例:
public class BreakContinue_Test {
public static void main(String[] args) {
for(int i = 1;i <= 10;i++) {
if(i % 4 == 0) {
//break; //一旦循环语句中执行到break语句，那么立即跳出当前循环体结构
continue; //一旦执行到continue语句，那么就跳过这次循环体得执行，continue后面得语句也不执行了，开启下次循环
//System.out.println("我是最强得！"); 编译出错，无法访问得语句，在同一个作用范围内，两关键字后面都不能带执行语句
}
System.out.println(i); //break输出:1 2 3
//continue输出:1 2 3 5 6 7 9 10
}
System.out.println("\n ");
//-----------------------------------------
label:for (int i = 1; i <= 4; i++) { //对外层循环指定标签
for(int j = 1;j <= 10;j++) {
if(j % 4 == 0) {
//break label; //跳出指定标签结构得循环
continue label; //跳出指定标识得当次循环结构，开启其下一次循环结构
//break; //默认跳出包裹此关键字最近得一层循环，
//continue; //跳出包裹此关键字内层得此次循环，开启内层下次循环
}
System.out.print(j);
}
System.out.println();
}
}
}
614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
