java中循环语句_Java语法基础之循环结构语句详解
一、循環結構
循環語句可以在滿足循環條件的情況下，反復執行某一段代碼，這段被重復執行的代碼被稱為循環體語句，當反復執行這個循環體時，需要在合適的時候把循環判斷條件修改為false，從而結束循環，否則循環將一直執行下去，形成死循環。
循環語句的組成：
初始化語句：一條或者多條語句，這些語句完成一些初始化操作。
判斷條件語句：這是一個boolean 表達式，這個表達式能決定是否執行循環體。
循環體語句：這個部分是循環體語句，也就是我們要多次做的事情。
控制條件語句：這個部分在一次循環體結束后，下一次循環判斷條件執行前執行。通過用于控制循環條件中的變量，使得循環在合適的時候結束。
eg：在控制臺輸出10次"HelloWorld"時，
初始化語句：定義初始化為第一次。
判斷條件語句：次數不能超過10次。
循環體語句：輸出”HelloWorld”語句。
控制條件語句：次數變化為下一次。
二、循環結構(for循環語句)
for循環語句格式：
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
執行流程：
A:執行初始化語句
B:執行判斷條件語句，看其結果是true還是false：如果是false，循環結束；如果是true，繼續執行。
C:執行循環體語句
D:執行控制條件語句
E:回到B繼續
流程圖：
注意事項：
(1)判斷條件語句的結果是一個boolean類型
(2)循環體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。
(3)一般來說：有左大括號就沒有分號，有分號就沒有左大括號
代碼舉例：
1、求出1-100之間偶數和：
/*
需求：
A:求1-100之和。
B:求出1-100之間偶數和
*/
class ForTest1 {
public static void main(String[] args) {
//求1-100之和。
int sum1 = 0;
for(int x=1; x<=100; x++) {
sum1 +=x;
}
System.out.println("1-100之和是："+sum1);
System.out.println("------------------");
//求出1-100之間偶數和
//方式1
int sum2 = 0;
for(int x=1; x<=100; x++) {
if(x%2 == 0) {
sum2 += x;
}
}
System.out.println("1-100偶數之和是："+sum2);
System.out.println("------------------");
//方式2
int sum3 = 0;
for(int x=0; x<=100; x+=2) {
sum3 += x;
}
System.out.println("1-100偶數之和是："+sum3);
System.out.println("------------------");
}
}
2、求5的階乘：
/*
需求：求5的階乘。
什么是階乘呢?
n! = n*(n-1)! 規則
n! = n*(n-1)*(n-2)*...*3*2*1
求和思想。
求階乘思想。
*/
class ForTest2 {
public static void main(String[] args) {
//定義最終結果變量
int jc = 1;
//這里的x其實可以直接從2開始
//for(int x=1; x<=5; x++)
for(int x=2; x<=5; x++) {
jc *=x;
}
System.out.println("1-5的階乘是："+jc);
}
}
3、在控制臺輸出所有的“水仙花數”：
/*
需求：在控制臺輸出所有的”水仙花數”
分析：
我們都不知道什么叫"水仙花數"，你讓我怎么做呢?
所謂的水仙花數是指一個三位數，其各位數字的立方和等于該數本身。
舉例：153就是一個水仙花數。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
A:三位數其實是告訴了我們范圍。
B:通過for循環我們就可以實現獲取每一個三位數
但是麻煩是如何獲取這個三位數的個,十,百位上的數據
我們如何獲取一個數據的個,十,百呢?
假設有個一個數據:153
ge: 153%10 = 3
shi: 153/10%10 = 5
bai：153/10/10%10 = 1
qian：x/10/10/10%10
wan: x/10/10/10/10%10
...
C:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較
如果相同，就把該數據在控制臺輸出。
*/
class ForTest3 {
public static void main(String[] args) {
//三位數其實是告訴了我們范圍。
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數據比較
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果相同，就把該數據在控制臺輸出。
System.out.println(x);
}
}
}
}
三、循環結構(while循環語句)
while循環語句格式：
while(判斷條件語句) {
循環體語句;
}
//擴展格式
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
流程圖：
for循環和while循環的區別：
for循環語句和while循環語句可以等價轉換，但還是有些小區別的。
(1)使用區別：
控制條件語句所控制的那個變量，在for循環結束后，就不能再被訪問到了，而while循環結束還可以繼續使用，如果你想繼續使用，就用while，否則推薦使用for。原因是for循環結束，該變量就從內存中消失，能夠提高內存的使用效率。
(2)場景區別：
for循環適合針對一個范圍判斷進行操作while循環適合判斷次數不明確操作
代碼舉例：
我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
/*
我國最高山峰是珠穆朗瑪峰：8848m，我現在有一張足夠大的紙張，厚度為：0.01m。
請問，我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
分析：
A:定義一個統計變量，默認值是0
B:最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
C:我折疊多少次，就可以保證厚度不低于珠穆朗瑪峰的高度?
折疊一次有什么變化呢?就是厚度是以前的2倍。
D:只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
E:輸出統計變量。
*/
class WhileTest01 {
public static void main(String[] args) {
//定義一個統計變量，默認值是0
int count = 0;
//最高山峰是珠穆朗瑪峰：8848m這是最終的厚度
//我現在有一張足夠大的紙張，厚度為：0.01m這是初始厚度
//為了簡單，我把0.01變成1，同理8848就變成了884800
int end = 884800;
int start = 1;
while(start
//只要每次變化的厚度沒有超過珠穆朗瑪峰的高度，就折疊，統計變量++
count++;
//折疊一次有什么變化呢?就是厚度是以前的2倍。
start *= 2;
System.out.println("第"+count+"次厚度是"+start);
}
//輸出統計變量。
System.out.println("要疊"+count+"次");
}
}
四、循環結構(do…while循環語句)
基本格式：
do {
循環體語句;
}while((判斷條件語句);[/code]
擴展格式：
初始化語句;
do {
循環體語句;
控制條件語句;
} while((判斷條件語句);[/code]
流程圖：
五、循環結構的區別及注意事項：
三種循環語句其實都可以完成一樣的功能，也就是說可以等價轉換，但還是有小區別的:
do…while循環至少會執行一次循環體。for循環和while循環只有在條件成立的時候才會去執行循環體
1、注意事項：
寫程序優先考慮for循環，再考慮while循環，最后考慮do…while循環。
如下代碼是死循環：
while(true){}
for(;;){}
2、循環的嵌套使用：就是循環語句的循環體本身是一個循環語句
(1)題目一：請輸出一個4行5列的星星(*)圖案：
提示：外循環控制行數，內循環控制列數
/*
需求：請輸出下列的形狀
*
**
***
****
*****
提示：外循環控制行數，內循環控制列數
*/
class ForForTest01 {
public static void main(String[] args) {
//通過簡單的觀察，我們看到這是一個行是5，列數是變化的形狀
//我們先打印出一個5行5列的形狀
for(int x=0; x<5; x++) {
for(int y=0; y<5; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------");
//我們實現了一個5行5列的形狀
//但是這不是我們想要的
//我們要的是列數變化的
//列數是如何變化的呢?
//第一行：1列 y=0,y<=0,y++
//第二行：2列 y=0,y<=1,y++
//第三行：3列 y=0,y<=2,y++
//第四行：4列 y=0,y<=3,y++
//第五行：5列 y=0,y<=4,y++
//在看外循環x的變化，恰好就是x=0,1,2,3,4
//所以這個最終版的程序就是如下
for(int x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
(2)題目二：在控制臺輸出九九乘法表：
/*
需求：在控制臺輸出九九乘法表。
首先我們寫出九九乘法表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
...
1*9=9 2*9=18 3*9=27 ...
我們先把這個九九乘法表看出是這樣的一個形狀：
*
**
***
****
*****
******
*******
********
*********
注意：
'\x' x表示任意，這種做法叫轉移字符。
'\t' 一個制表符的位置(tabtab鍵)
'\r' 回車
'\n' 換行
*/
class ForForTest02 {
public static void main(String[] args) {
for(int x=0; x<9; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------");
//為了使用數據，我們從1開始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}
運行效果：
六、跳轉控制語句：
前面我們已經說過了，Java中的goto是保留字，目前不能使用。雖然沒有goto語句可以增強程序的安全性，但是也帶來很多不便，比如說，我想在某個循環知道到某一步的時候就結束，現在就做不了這件事情。為了彌補這個缺陷，Java就提供了break，continue和return來實現控制語句的跳轉和中斷。
break 中斷
continue 繼續
return 返回
1、跳轉控制語句(break)：
break的使用場景：
~在選擇結構switch語句中
~在循環語句中(循環語句中加入了if判斷的情況)
注：離開使用場景的存在是沒有意義的
break的作用：
A:跳出單層循環
B:跳出多層循環
要想實現這個效果，就必須知道一個東西。帶標簽的語句。標簽名要符合Java的命名規則
格式：
標簽名: 語句
代碼舉例：
/*
控制跳轉語句：
break:中斷
continue:繼續
return:返回
break:中斷的意思
使用場景：
A:switch語句中
B:循環語句中。
(循環語句中加入了if判斷的情況)
注意：離開上面的兩個場景，無意義。
如何使用呢?
A:跳出單層循環
B:跳出多層循環
要想實現這個效果，就必須知道一個東西。帶標簽的語句。
格式：
標簽名: 語句
*/
class BreakDemo {
public static void main(String[] args) {
//在 switch 或 loop 外部中斷
//break;
//跳出單層循環
for(int x=0; x<10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
System.out.println("over");
System.out.println("-------------");
//跳出多層循環
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
if(y == 2) {
//break nc;
break wc;
}
System.out.print("*");
}
System.out.println();
}
}
}
第38行，我們給外面的循環加了一個標簽叫wc，然后在第42行跳轉出這個標簽。
運行效果：
注：實際開發中，幾乎用不到跳轉多層循環這個功能。
2、跳轉控制語句(continue)：
continue的使用場景：
在循環語句中離開使用場景的存在是沒有意義的
continue和break的區別：
break 跳出單層循環continue 跳出一次循環，進入下一次的執行。
效果如下：
面試題：
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此處填寫代碼
}
System.out.println("Java學習");
}
在上面代碼的第4行填入一行代碼，滿足一下條件：
我想在控制臺輸出2次:"Java學習" break;
我想在控制臺輸出7次:"Java學習" continue;
我想在控制臺輸出13次:"Java學習" System.out.println("Java學習");
3、跳轉控制語句(return)
return關鍵字不是為了跳轉出循環體，更常用的功能是結束一個方法，也就是退出一個方法，跳轉到上層調用的方法。
說白了：return的作用不是結束循環，而是結束方法。
效果如下：
循環語句結合break的練習：
面試題：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，請問，經過多少天，小芳才可以存到100元錢。
代碼實現：
/*
需求：小芳的媽媽每天給她2.5元錢，她都會存起來，但是，
每當這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
請問，經過多少天，小芳才可以存到100元錢。
分析：
A:小芳的媽媽每天給她2.5元錢
double dayMoney = 2.5;
B:她都會存起來
double daySum = 0;
C:從第一天開始存儲
int dayCount = 1;
D:經過多少天，小芳才可以存到100元錢。
double result = 100;
E:這一天是存錢的第5天或者5的倍數的話，她都會花去6元錢，
說明要判斷dayCount的值，如果對5整除就減去6元錢。
daySum -= 6;
由此還隱含了一個問題，就是如果不是5的倍數天的話，錢要累加
daySum += dayMoney;
F:因為不知道是多少天，所以我用死循環，一旦超過100元我就退出循環。
*/
class WhileDemo {
public static void main(String[] args) {
//每天要存儲的錢是2.5元
double dayMoney = 2.5;
//存錢的初始化值是0
double daySum = 0;
//從第一天開始存儲
int dayCount = 1;
//最終存儲不小于100就不存儲了
int result = 100;
//因為不知道是多少天，所以我用死循環，
while(true) {
//累加錢
daySum += dayMoney;
//一旦超過100元我就退出循環。
if(daySum >= result) {
System.out.println("共花了"+dayCount+"天存儲了100元");
break;
}
if(dayCount%5 == 0) {
//花去6元錢
daySum -= 6;
System.out.println("第"+dayCount+"天花了6元錢");
}
//天數變化
dayCount++;
}
}
}
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。
總結
以上是生活随笔為你收集整理的java中循环语句_Java语法基础之循环结构语句详解的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java oracle 图片_JAVA读
- 下一篇： java resources 目录_Ma