循环结构：
在某些条件满足的情况下，反复执行特定代码的功能
循环语句的四个组成部分：
初始化部分
循环条件部分
循环体部分
迭代部分
while循环：
do……while循环
for循环
在java5中引入了一种主要用于数组的增强型for循环
while是最基本的循环，它的结构为：
while(布尔表达式）{
//循环内容
}
只要布尔表达式为true,循环就会一直执行下去。
我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等
循环条件一直为true就会造成无限循环（死循环),我们正常的业务编程中应该尽量避免死循环，会影响程序性能或者造成程序卡死崩溃。
我们的基本示例如下所示：
package com.hy;
/*
一、循环条件的4个要素
初始化条件
循环条件 --->是boolean类型
循环体
迭代条件
二、while循环的结构
初始化条件
while(循环条件 ){
循环体；
迭代条件；
说明：
1.写while循环千万小心不要丢了迭代条件，一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
}
*/
public class Array6_ {
public static void main(String[] args) {
//遍历100以内的所有偶数
int i=1;
while (i<=100){
if(i%2==0){
System.out.println(i);
}
i++;
}
System.out.println(i); //这个i出了循环之后仍然可以调用。
}
}
运行之后如下所示：
输出1-100的代码如下：
package com.rgf.structure;
public class H {
public static void main(String[] args) {
int i=0;
while (i<100){
i++;
System.out.println(i);
}
}
}
运行界面如下：
死循环的伪代码示例如下：
package com.rgf.structure;
public class Q {
public static void main(String[] args) {
//死循环
while (true){
//等待客户端连接
//定时检查
//
}
}
}
求1-100的和的while实现的代码示例如下：
package com.rgf.structure;
public class W {
public static void main(String[] args) {
int i=0;
int sum=0;
while(i<=100){
sum=sum+i;
i++;
}
System.out.println(sum);
}
}
运行界面如下：
do ……while循环：
对于while语句而言，如果不满足条件，则不能进入循环，但有时候我们需要即使不满足条件，也至少执行一次。
do……while循环和while循环相似，不同的是，do……while循环至少会执行一次。
语法格式如下：
do{
//代码语句
}while(布尔表达式）；
Whlie和do-while的区别：
while先判断后执行，do-while是先执行后判断
Do-while总是保证循环体会被至少执行一次，这是他们的主要差别。
do-while的循环示例：
package com.hy;
/*
一、循环条件的4个要素
初始化条件
循环条件 --->是boolean类型
循环体
迭代条件
二、do-while循环的结构
初始化条件
do{
循环体；
迭代条件；
}while(循环条件){
算法：有限性。
}
*/
public class Array6_ {
public static void main(String[] args) {
}
}
我们查看do-while循环遍历100以内的偶数及do-while和while的区别：
package com.ypl.exercise;
/*
一、循环条件的4个要素
初始化条件
循环条件 --->是boolean类型
循环体
迭代条件
二、do-while循环的结构
初始化条件
do{
循环体；
迭代条件；
}while(循环条件){
}
算法：有限性。
执行过程：初始化条件-->循环体--->迭代条件--->循环条件
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while循环的更多一些。较少使用do-while。
*/
public class B {
public static void main(String[] args) {
//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
int i=1;
int count=0; //记录个数
int sum=0; //记录总和
do{
if(i%2==0){
System.out.println(i);
sum+=i;
count++;
}
i++;
}while (i<=100);
System.out.println("100以内所有偶数的和为："+sum);
System.out.println("100以内所有偶数的个数为："+count);
System.out.println("****************体会do-while至少执行一次循环体****************************");
int number=10;
while (number>10){
System.out.println("hello:while");
number--;
}
int number1=10;
do{
System.out.println("hello:do while");
number1--;
}while (number1>10);
}
}
我们运行之后如下所示：
do-while代码如下所示：
package com.rgf.structure;
public class Y {
public static void main(String[] args) {
int i=0;
int sum=0;
do{
sum=sum+i;
i++;
}while (i<=100);
System.out.println(sum);
}
}
运行结果如下：
更加直观的体现出while和do-while循环的不同的代码如下：
package com.rgf.structure;
public class R {
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);
}
}
运行界面如下：
由运行界面可知，while循环，当判断结果不符合的时候，就直接结束程序了，不执行下面的语句，而do-while循环，先执行语句，再进行判断结果，当结果不符合的时候，仍会输出第一次所执行后的结果。
For循环：
虽然所有循环结构都可以用while或者do……while表示，但java提供了另一种语句--for循环，使一些循环结构变得更加简单
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
for循环执行的次数是在执行前就确定的
语法格式如下：
for(初始化表达式；循环条件；操作表达式）{
//执行语句
}
for循环的基本展示代码如下:
package com.rgf.structure; public class O { public static void main(String[] args) { int a=1; //初始化表达式 while (a<=100){ //判断条件 System.out.println(a);//循环体 a+=2; //a=a+2,迭代 } System.out.println("while循环结束"); //初始化表达式；判断条件；迭代 for (int i = 1; i <=100; i++) { System.out.println(i); } System.out.println("for循环结束"); //死循环 /* for(;;){ } */ } } /* 关于for循环有以下几点说明： 最先执行初始化表达式，可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。 然后，检测判断条件的值。如果为true,循环体被执行。如果为false，循环终止，开始执行循环体后面的语句 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减） 再次检测布尔表达式，循环执行上面的过程。 */ } }运行界面如下：
初识示例如下： 1.
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; //for循环结构的使用 /*一、 循环结构的四个要素： 初始化条件 循环条件 --->是boolean类型 循环体 迭代条件 二、for循环的结构 for(初始化条件;循环条件;迭代条件)｛ 循环体 ｝ 执行过程：先是初始化条件，然后循环条件如果满足的话，执行循环体，然后进入迭代条件。循环往复，直到不再满足循环条件。 */ public class Array8_ { public static void main(String[] args) { int a=0; for(a=0;a<5;a++){ System.out.println("Hello World!"); } } }运行如下所示：
2.
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { //练习： int num=1; for (System.out.println('a');num<=3; System.out.println("c"),num++){ System.out.println("b"); } //输出结果：abcbcbc } }运行之后如下所示：
3.遍历100以内的偶数：
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { //i:在for循环内有效，出了for循环就失效了 //例题：遍历100以内的偶数 for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { System.out.println(i); } } } }运行之后如下所示：
4.遍历100以内的偶数，输出所有偶数的和。
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { //i:在for循环内有效，出了for循环就失效了 //例题：遍历100以内的偶数,输出所有偶数的和 int sum=0; //记录所以偶数的和 for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { sum=sum+i; } } System.out.println("总和为："+sum); } }运行之后如下所示：
5。偶数的个数
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { //i:在for循环内有效，出了for循环就失效了 //例题：遍历100以内的偶数,输出偶数的个数 int count=0; //记录偶数的个数 for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { count=count+1;//count++; } } System.out.println("个数为："+count); } }运行之后如下所示：
for循环示例1：计算0到100之间的奇数和偶数的和
1.以下为for循环实现的代码：
package com.rgf.structure; public class For1 { public static void main(String[] args) { //练习1：计算0到100之间的奇数和偶数的和 int oddSum=0;//奇数和 int evenSum=0;//偶数和 for (int i = 0; i <= 100; i++) { if (i%2!=0){ //奇数 oddSum+=i; //oddSum=oddSun+i } else { //偶数 evenSum+=i;//evenSum=evenSum+i } } System.out.println("奇数和为"+oddSum); System.out.println("偶数和为"+evenSum); } }运行界面如下：
2.以下为while循环实现的代码：
package com.rgf.structure; public class For2 { public static void main(String[] args) { int oddSum=0;//奇数和 int evenSum=0;//偶数和 int i=0; while (i<=100){ if (i%2!=0){ oddSum+=i; } else { evenSum+=i; } i++; } System.out.println("奇数和为"+oddSum); System.out.println("偶数和为"+evenSum); } }运行界面如下：
测试题如下所示：
1..编写程序：从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出"foo",在每个5的倍数行上打印"biz",在每个7的倍数行上打印输出“baz".（巧妙运用print和println的区别，同时考虑到else-if，是取值其一的原理，从而采用多个if）
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { //编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出"foo",在每个5的倍数行上打印"biz",在每个7的倍数行上打印输出“baz". int count=0; //记录偶数的个数 for (int i = 1; i <= 150; i++) { System.out.print(i+" "); if(i%3==0){ System.out.print("foo "); } if(i%5==0){ System.out.print("biz "); } if (i%7==0){ System.out.print("baz "); } //换行 System.out.println(); } } }运行之后如下所示：
2.题目：输入两个正整数m和n,求其最大公约数和最小公倍数。
比如：12和20的最大公倍数是4,最小公倍数是60,。
说明：break关键字的使用。
package com.hy; import java.lang.Math; import java.util.Scanner; import java.lang.String; public class Array8_ { public static void main(String[] args) { // 题目：输入两个正整数m和n,求其最大公约数和最小公倍数。 //比如：12和20的最大公约数是4,最小公倍数是60。 //说明：break关键字的使用。 Scanner scanner = new Scanner(System.in); System.out.println("请输入正整数m:"); int m = scanner.nextInt(); System.out.println("请输入正整数n:"); int n = scanner.nextInt(); //1.获取两个数中的较小值 int min=(m<=n)?m:n; //2.遍历 for (int i=min;i>=1;i--){ if(m%i==0&&n%i==0){ System.out.println("最大公约数为："+i); break;//一旦在循环中执行到break,就跳出循环。 } } //获取最小公倍数 //1.获取两个数中的较大值 int max=(m>=n)?m:n; //2.遍历 for (int i=max;i>=1;i++){ if(i%m==0&&i%n==0){ System.out.println("最小公倍数："+i); break; } } } }运行之后如下所示：
3.打印1~100之间所有奇数的和：
package com.hy; import java.util.Scanner; import static java.lang.System.*; public class Array7_ { public static void main(String[] args) { // 打印1~100之间所有奇数的和 int sum=0; for(int i=0;i<=100;i++){ if(i%2!=0){ sum+=i; } } out.println("1~100之间所有奇数的和为"+sum); } }运行之后如下所示：
4.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计算器的思想）。
package com.hy; import java.util.Scanner; import static java.lang.System.*; public class Array7_ { public static void main(String[] args) { //.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计算器的思想）。 int sum=0; int count=0; for(int i=0;i<=100;i++){ if(i%7==0){ sum+=i; count++; } } out.println("1~100之间所有是7的倍数的整数的个数为："+count); out.println("1~100之间所有是7的倍数的整数的总和为："+sum); } }运行之后如下所示：
5. 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153=1*1*1+3*3*3+5*5*5
嵌套循环：
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do......while均可以作为外层循环或内层循环。实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环实际上需要执行m*n次。
package com.hy;
import java.util.Scanner;
/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中。就构成了嵌套循环。
2.
外层循环：循环结构B
内层循环：循环结构A
}
*/
public class Array6_ {
public static void main(String[] args) {
// 输出******
for (int i=1;i<=6;i++){
System.out.print("*");
}
System.out.println("\n");
/*
输出：
******
******
******
******
*/
for(int i=1;i<=4;i++){
for (int j=1;j<=6;j++){
System.out.print("*");
}
System.out.println(); //起到一个换行的效果。
}
}
}
运行之后如下所示：
我们查看输出其他的情况如下所示：
package com.hy;
import java.util.Scanner;
/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中。就构成了嵌套循环。
2.
外层循环：循环结构B
内层循环：循环结构A
3.技巧：
外层循环控制行数，内层循环控制列数
}
*/
public class Array6_ {
public static void main(String[] args) {
/*输出：
*
**
***
****
*****
*/
for(int i=1;i<=5;i++){ //控制行数
for (int j=1;j<=i;j++){ //控制列数
System.out.print("*");
}
System.out.println();
}
}
}
运行之后如下所示：
我们在编写过程中可以发现i为行号，j为*的个数。（i为1时，*为1；i为2时，*为2；i为3时，*为3，可以根据此规律进行代码的编写。
我们尝试倒着输出，如下所示：
package com.hy;
import java.util.Scanner;
/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中。就构成了嵌套循环。
2.
外层循环：循环结构B
内层循环：循环结构A
}
*/
public class Array6_ {
public static void main(String[] args) {
/*输出：
*****
****
***
**
*
*/
for(int i=1;i<=5;i++){
for (int j=5;j>=i;j--){
System.out.print("*");
}
System.out.println();
}
}
}
运行之后如下所示：
我们也可以采用另一种思路如下所示：
i为行号，j为*的个数。（i为1时，*为5；i为2时，*为4；i为3时，*为3，i为4时，*为2，i为5时，*为1. 即*的个数为6-i,我们可以根据此规律进行代码的编写。
package com.ypl.exercise;
public class A {
public static void main(String[] args) {
/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中。就构成了嵌套循环。
2.
外层循环：循环结构B
内层循环：循环结构A
3.内层循环结构遍历一遍，只相当于外层循环循环体执行了一次。
4.假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了：m*n次。
}
*/
for(int i=1;i<=6;i++){
for (int j=1;j<=6-i;j++){
System.out.print("*");
}
System.out.println(); //起到一个换行的效果。
}
}
}
运行之后如下所示：
我们查看合起来的情况：
package com.ypl.exercise;
public class A {
public static void main(String[] args) {
/*
嵌套循环的使用：
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中。就构成了嵌套循环。
2.
外层循环：循环结构B
内层循环：循环结构A
3.内层循环结构遍历一遍，只相当于外层循环循环体执行了一次。
4.假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了：m*n次。
}
*/
for(int i=1;i<=6;i++){
for (int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
for(int i=1;i<=6;i++){
for (int j=1;j<=6-i;j++){
System.out.print("*");
}
System.out.println(); //起到一个换行的效果。
}
}
}
运行之后如下所示：
正序九九乘法表为：
package com.hy;
public class Array5_ {
public static void main(String[] args) {
for(int i=1;i<=99;i++){
for (int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+(i*j)+" ");
}
System.out.println();
}
}
}
运行之后如下所示：
倒序九九乘法表为：
package com.hy;
public class Array5_ {
public static void main(String[] args) {
for(int i=9;i>=0;i--){
for (int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+(i*j)+" ");
}
System.out.println();
}
}
}
运行之后为：
我们要运行出来如下所示：
我们进行设计代码：
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
