Java控制流程示例代碼詳解
用戶交互Scanner、Scanner進階使用
用戶交互Scanner
? 之前我們學習的基本語法中我們并沒有實現(xiàn)程序和人的交互，但是Java給我們提供了這樣一個工具類，我們可以獲取用戶的輸入。java.util.Scanner 是java5的新特征，我們可以通過Scanner類來獲取用戶的輸入
基本語法：
Scanner s = new Scanner(System.in);
//有些代碼大家可能不理解，比如這個new，大家目前先不用理解代碼的意思，先學會跟著操作，之后我們講面向?qū)ο蟮臅r候你就會逐一明白這些代碼每一個具體的意思
? 通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字符串，在讀取前我們一般需要使用 hasNext() 與 hasNexLine() 來判斷是否還有輸入的數(shù)據(jù)。
? 下面我們來實踐一下加深理解和記憶
使用next方式讀取：
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args){
//創(chuàng)建一個掃描器對象 用于接收鍵盤數(shù)據(jù)
//使用IDEA開發(fā)工具輸入Scanner之后回車，它就會自動導入這個類import java.util.Scanner;
//我們之前一直用的是System.out是輸出；System.in是輸入
//這里引用了Scanner數(shù)據(jù)類型
//通過new Scanner(System.in);接收用戶的輸入，并且把它封裝成了scanner對象
Scanner scanner = new Scanner(System.in);
//輸出一行字
System.out.println("使用next()方法接收：");
//判斷用戶有沒有輸入字符串
//if語句還沒學，if就是如果的意思
//如果scanner這個對象有沒有用戶輸入，（==true不寫就是默認上節(jié)課講過，一般新手才會加）有的話就使用執(zhí)行里面的語句
if (scanner.hasNext()){
//使用next方式接收用，并封裝給數(shù)據(jù)類型為String的str變量
String str = scanner.next();
//輸出用戶輸入的內(nèi)容
System.out.println("輸入的內(nèi)容為："+str);
}
//凡是屬于IO流的類如果不關(guān)閉會一直占用資源，要養(yǎng)成好習慣用完就關(guān)
scanner.close();
}
}? 我們運行起來之后，他會顯示使用next方式讀取，然后等待你輸入字符串，我輸入hello world返回輸入的內(nèi)容為：hello；然后程序結(jié)束
? String str = scanner.next();這句代碼執(zhí)行完程序會等待用戶輸入完畢，如果你沒去輸入數(shù)據(jù)那么程序就會一直卡在那
? 但是有沒有發(fā)現(xiàn)我們輸入的hello world它只輸出了一個hello
剛才我們使用的是next()，現(xiàn)在我們使用nextLine()試一下：
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine()方法讀?。?);
if (scanner.hasNext()) {
//使用nextLine()方式讀取，并封裝給數(shù)據(jù)類型為String的str變量
String str = scanner.nextLine();
System.out.println("輸入的內(nèi)容為："+str);
}
scanner.close();
}
}這次輸入hello world，返回的也是hello world
那我們來看一下next()和nextLine()兩種接收用戶輸入到底有上面區(qū)別
next()：
- 一定要讀取到有效字符后才可以結(jié)束輸入。
- 對輸入有效符之前遇到的空白，next()方法會自動去掉
? 例如我輸入： hello；則返回：hello
只有輸入有效字符后才將其后面輸入的空白作為分隔符或結(jié)束符
next() 不能讀取帶有空格的字符串
nextLine()：
- 以Enter為結(jié)束符，也就說 nextLine()方法返回的是輸入回車之前的所有字符
- 可以獲得空白
我們還沒有學習到if上面的代碼看起來會比較復雜，我下面寫一個不用if語句和判斷用戶輸入方法的的代碼，讓大家自己分析，我就不寫注釋了
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入數(shù)據(jù)：");
String str = scanner.nextLine();
System.out.println("輸入的內(nèi)容為："+str);
scanner.close();
}
}以上內(nèi)容請務必掌握！??！
Scanner進階使用
萬一我們需要用戶輸入指定類型的數(shù)據(jù)，那該怎么判斷用戶輸入的是否是我們指令類型的數(shù)據(jù)
我們在IDEA定義好scanner對象后；輸入scanner.后會跳出很多方法出來
比如scanner.hasNextInt() ：這樣就是判斷是否輸入的是Int類型；這樣我們就能配合if...else...語句來使用；if...else...就是如果就否則就的意思。
讀取數(shù)據(jù)的方法也要變成scanner.nextInt()
下面我們來演示一下
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int i = 0;
float f = 0.0F;
//提示用戶輸入
System.out.println("請輸入數(shù)據(jù)：");
//使用hasNextInt()方法判讀用戶輸入的數(shù)據(jù)是否為Int類型
if (scanner.hasNextInt()) {
//使用nextInt()方法讀取Int數(shù)據(jù)，并賦值給i(這里因為i我們上面已經(jīng)定義了所以不用在指定類型)
i = scanner.nextInt();
System.out.println("輸入的數(shù)據(jù)為："+i);
}else {
System.out.println("請輸入整數(shù)類型的數(shù)據(jù)!");
String a = scanner.nextLine();
}
//使用hasNextFloat()方法判讀用戶輸入的數(shù)據(jù)是否為Float類型
if (scanner.hasNextFloat()) {
//使用nextFloat()方法讀取float數(shù)據(jù)，并賦值給f(這里因為f我們上面已經(jīng)定義了所以不用在指定類型)
f = scanner.nextFloat();
System.out.println("輸入的數(shù)據(jù)為："+f);
System.out.println("請輸入小數(shù)類型的數(shù)據(jù)!");
scanner.close();
}
}運行的結(jié)果為：
第一種情況：
? 請輸入數(shù)據(jù)：
? 1
? 輸入的數(shù)據(jù)為：1
? 請輸入數(shù)據(jù)：
? 1.2
? 輸入的數(shù)據(jù)為：1.2
第二種情況
請輸入數(shù)據(jù)：
xiaodi
請輸入整數(shù)類型的數(shù)據(jù)!
請輸入數(shù)據(jù)：
xiaodi
請輸入小數(shù)類型的數(shù)據(jù)!
有沒有發(fā)現(xiàn)我在第一個if...else...語句中的else中加了一行代碼
String a = scanner.nextLine();
你不加這行代碼的話，你運行起來，你第一個數(shù)據(jù)輸入錯誤了，它會直接將第一個數(shù)據(jù)拿到第二次做判斷，導致你第二次不能輸入數(shù)據(jù)。（
案例：
? 我們可以輸入多個數(shù)字，并求其總和與平均數(shù)，每輸入一個數(shù)字用回車確認，通過輸入輸入非數(shù)字來結(jié)束輸入并輸出執(zhí)行結(jié)果
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//和,有可能會輸入小數(shù)，所以使用double類型
double sum = 0.0;
//個數(shù)，因為最后要求平均值，平均值就是和除以個數(shù)
int m = 0;
//使用while循，判斷是否輸入數(shù)字，如果是就一直循環(huán)獲取用戶輸入，如果不是則退出循環(huán)
while (scanner.hasNextDouble()) {
//獲取用戶輸入，并賦值給i
double i = scanner.nextDouble();
//把和加上獲取的輸入
sum = sum + i;
//個數(shù)加1
m = m + 1;//m++
System.out.println("您輸入了第"+m+"個數(shù)據(jù)當前的總和為："+sum);
}
//輸出總和和平均數(shù)
System.out.println("您輸入的數(shù)據(jù)的總和為："+sum);
System.out.println("您輸入的數(shù)據(jù)的平均數(shù)為："+(sum / m));
scanner.close();
}
}運行結(jié)果：
? 10.5
? 您輸入了第1個數(shù)據(jù)當前的總和為：10.5
? 19.5
? 您輸入了第2個數(shù)據(jù)當前的總和為：30.0
? 30
? 您輸入了第3個數(shù)據(jù)當前的總和為：60.0
? 40
? 您輸入了第4個數(shù)據(jù)當前的總和為：100.0
? x
? 您輸入的數(shù)據(jù)的總和為：100.0
? 您輸入的數(shù)據(jù)的平均數(shù)為：25.0
? 其中while循環(huán)還不懂沒關(guān)系，你先跟著我的代碼寫一遍，等一下學到你再回來看一下，你就會恍然大悟，原來是這個樣子的！
順序結(jié)構(gòu)
Java的基本結(jié)構(gòu)就是順序結(jié)構(gòu)，除非特別指明，否則就按照順序一句一句執(zhí)行
順序結(jié)構(gòu)是最簡單的算法結(jié)構(gòu)
語句與語句之間，框與框之間是按從上到下的順序進行的，它是又若干個依次執(zhí)行的處理步驟組成的，它是任何一個算法都離不開的一種基本算法結(jié)構(gòu)
選擇結(jié)構(gòu)*
if選擇結(jié)構(gòu)
if單選擇結(jié)構(gòu)
? 我們很多時候需要去判斷一個東西是否可行，然后我們才去執(zhí)行，這樣一個過程在程序中用if語句來表示
語法：
if (布爾表達式) {
//如果布爾表達式為true將執(zhí)行的語句，如果為false則跳過if語句
}演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入內(nèi)容：");
String s = scanner.nextLine();
//equals：判斷字符串是否一致的方法，是字符串的一種方法
if (s.equals("Hello")) {
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}第一次輸入Hello則執(zhí)行if語句結(jié)果如下：
? 請輸入內(nèi)容：
? Hello
? Hello
? End
第二次輸入XiaoDi則跳過if語句結(jié)果如下：
? 請輸入內(nèi)容：
? XiaoDi
? End
if雙選擇結(jié)構(gòu)
? 那現(xiàn)在有一個需求，學校要一個輸入分數(shù)來判定學生成績是否及格的程序，>=60分為及格，<60分為不及格。這樣的需求用一個if就搞不定了，我們需要有兩個判斷，需要一個雙選擇結(jié)構(gòu)，所以就要使用if-else結(jié)構(gòu)
語法：
if (布爾表達式) {
//如果布爾表達式值為true執(zhí)行的代碼
}else {
//如果布爾表達式值為false執(zhí)行的代碼
}演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入你的分數(shù)：");
int score = scanner.nextInt();
if (score>=60) {
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}第一個同學考了10分(走了else的分支)結(jié)果如下：
? 請輸入你的分數(shù)：
? 10
? 不及格
第二個同學考了90分(走了if的分支)結(jié)果如下：
? 請輸入你的分數(shù)：
? 90
? 及格
if多選擇結(jié)構(gòu)
? 我們發(fā)現(xiàn)剛才的代碼不符合實際情況，真實的情況還可能存在SABCD，存在區(qū)間多級判斷。比如90-100就是S，80-90就是B..等等，在生活中我們很多時候的選擇也不僅僅只有兩個，所以我們需要一個多選擇結(jié)構(gòu)來處理這類問題!
語法：
if (布爾表達式1){
//如果布爾表達式1的值為true執(zhí)行的代碼
}else if {
//如果布爾表達式2的值為true執(zhí)行的代碼
}else if {
//如果布爾表達式2的值為true執(zhí)行的代碼
}else {
//如果以上布爾表達式都不為true執(zhí)行的代碼
}演示：
package com.xiaodi.operator.struct;
import java.util.Scanner;
import java.util.SortedMap;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入你的成績：");
int score = scanner.nextInt();
if (score<40 && score>=0) {
System.out.println("你的成績評級為：D");
}else if (score>=40 && score<60) {
System.out.println("你的成績評級為：C");
}else if (score>=60 && score<80) {
System.out.println("你的成績評級為：B");
}else if (score>=80 && score<90) {
System.out.println("你的成績評級為：A");
}else if (score>=90 && score<=100) {
System.out.println("你的成績評級為：S");
}else {
System.out.println("本次評級的分數(shù)為0-100,請輸入正確的成績");
}
scanner.close();
}
}太多分支，可以自己執(zhí)行看看！我這里就不演示執(zhí)行結(jié)果了！會使文章看起來怪怪的
嵌套的if結(jié)構(gòu)
使用嵌套的if...else語句是合法的。也就是你可以在另一個if或 else if語句中使用if或else if語句，你可以像if語句一樣嵌套else if...else
語法：
if (布爾表達式1) {
//如果布爾表達式1的值為true執(zhí)行的代碼
if (布爾表達式2) {
//如果布爾表達式2的值為true執(zhí)行的代碼
}
}? 有時候我們在解決一些問題的時候，可以縮小操作范圍，它可以通過層級來判斷，提高效率
? 比如我們現(xiàn)在有一個需求：要查找1-100之間這樣的一個數(shù)字，這樣的話是比較麻煩的；
? 我們最笨的方法就是將用戶輸入的數(shù)字去1-100之間一個一個的對比，但是萬一他輸入了100，那程序就要對比到100才能成功，這樣就會花費更多的資源和時間；我們就可以用if嵌套來判斷，把這個100分成1-50，50-100去判斷用戶輸入的值在哪個里面，或者分成更多份去判斷；
我們生活在這個大數(shù)據(jù)時代，我們應該不斷去思考如何提高我們程序的效率，或許哪一天你就想出來了能夠提高效率的算法那你將在程序的歷史上留下一些痕跡了！
記住一點：我們流程控制語句都可以相互嵌套而互不影響
Switch選擇結(jié)構(gòu)
? 多選擇結(jié)構(gòu)還有一個實現(xiàn)方法就是switch case語句。
? switch case 語句判斷一個變量與一系列值中某個值是否相等，每個值稱為一個分支
語法：
switch(expression) {
case value :
//語句
break; //可選
case value :
//語句
break //可選
default : //可選
語句
}switch語句中的變量類型可以是：
? byte、short、int或char
? 從Java SE7開始，switch支持String類型了
? 同時case標簽必須在為字符串常量或字面量
演示：
package com.xiaodi.operator.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'C';
switch (grade) {
case 'A' :
System.out.println("優(yōu)秀");
break; //可選
case 'B' :
System.out.println("良好");
case 'C' :
System.out.println("及格");
case 'D' :
System.out.println("再接再厲");
case 'E' :
System.out.println("掛科");
}
}
}當grade為C時運行如下：
? 及格
? 再接再厲
? 掛科
當grade為A時運行如下：
? 優(yōu)秀
為什么會這樣，我說過這個break是可選的，如果不寫break他就會執(zhí)行匹配到的分支以及后面的分支直到遇到break，如果沒遇到，就會直接執(zhí)行到最后；這種現(xiàn)象叫做case穿透；(所以要養(yǎng)成一個好習慣，寫完每一個case后面都應該加一個break(除非特殊需求))
我們還可以來一個default
package com.xiaodi.operator.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'F';
switch (grade) {
case 'A' :
System.out.println("優(yōu)秀");
break; //可選
case 'B' :
System.out.println("良好");
break; //可選
case 'C' :
System.out.println("及格");
break; //可選
case 'D' :
System.out.println("再接再厲");
break; //可選
case 'E' :
System.out.println("掛科");
break; //可選
default :
System.out.println("未知等級");
}
}
}當grade不等于任何一個case的時候就會執(zhí)行default分支;
? 跟if比起來switch是有一些好處的，它在執(zhí)行case語句的時候會先匹配，匹配成功就會返回當前case的值，然后再根據(jù)它是否有break判斷是否繼續(xù)輸出。if是判斷匹配區(qū)間，而switch是匹配一個具體的值！
接下來演示JDL7開始才支持的字符串類型：
package com.xiaodi.operator.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "曉迪";
switch (name) {
case "小迪" :
System.out.println("小迪");
break;
case "曉迪" :
System.out.println("曉迪");
default :
System.out.println("神馬東西？？");
}
}
}運行結(jié)果為：曉迪
還記不記得我之前講過字符的本質(zhì)還是數(shù)字，給大家講一個東西反編譯
什么叫反編譯：比如.java文件編譯成.class文件，這個class文件叫做字節(jié)碼文件是人類看不懂的，我們要看懂就要進行反編譯
反編譯教程：
? 使用IDEA，點開享目結(jié)構(gòu)(File-->Project Structure)，就能看到Compiler output，將地址復制到文件管理器，打開找對對應需要反編譯的文件，你可以使用notepad++打開看一下，你會發(fā)現(xiàn)看不懂，沒事我也看不懂。
? 在IDEA文件夾那邊右鍵，選擇Open ln，再選擇Explorer打開對應文件夾，把class文件復制進去，在IDEA雙擊這個字節(jié)碼文件，選擇Accept，這個就是反編譯之后的
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
package com.xiaodi.operator.struct;
public class SwitchDemo02 {
public SwitchDemo02() {
}
public static void main(String[] args) {
String name = "曉迪";
byte var3 = -1;
switch(name.hashCode()) {
case 767419:
if (name.equals("小迪")) {
var3 = 0;
}
break;
case 848887:
if (name.equals("曉迪")) {
var3 = 1;
}
switch(var3) {
case 0:
System.out.println("小迪");
case 1:
System.out.println("曉迪");
default:
System.out.println("神馬東西？？");
}? 你會發(fā)現(xiàn) switch (name) {} 變成了 switch(name.hashCode()) {} ； case "曉迪" : 變成了 case 848887: ，也就是說它進行編譯之后是通過hashCode()進行判斷的，什么是hashCode()，你現(xiàn)在可以理解為每一個對象都有一個hashCode，它是通過一些特定算法生成的，而我們case后面的字符串中文都會有一個自己對應的hash值，然后它就判斷這個hash值是否跟name的hash值相同，這就是JDK7新特性的原理
循環(huán)結(jié)構(gòu)*
while 循環(huán)
while是最基本的循環(huán)，她的結(jié)構(gòu)為：
while (布爾表達式) {
//循環(huán)內(nèi)容
}- 只要布爾表達式為 true ，循環(huán)就會一直執(zhí)行下去。
- 我們大多數(shù)情況會讓循環(huán)停止下來，我們需要一個讓表達式失效的方式來結(jié)束循環(huán)
- 少部分情況需要循環(huán)一直執(zhí)行，比如服務器的請求響應監(jiān)聽等
- 循環(huán)條件一直為true就會造成無限循環(huán)【死循環(huán)】，我們正常的業(yè)務編程中應該盡量避免死循環(huán)。會影響程序性能或者造成程序卡死崩潰！
演示輸出1-100：
package com.xiaodi.operator.struct;
public class WhileDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;//i = i + 1;
System.out.println(i);
}
}
}運行會輸出1-100
演示死循環(huán)：
package com.xiaodi.operator.struct;
public class WhileDemo02 {
public static void main(String[] args) {
while (true) {
System.out.println(1);
}
}
}運行會無限輸出1 直到程序崩潰
演示：計算1+2+3+...+100=？
package com.xiaodi.operator.struct;
public class WhileDemo03 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
while (i<100) {
i++;
sum = sum + i;
}
System.out.println(sum);
}
}結(jié)果5050
其中while循環(huán)還能像下面這樣寫自己思考一下有什么不同
while (i<=100) {
sum = sum + i;
i++;
}do..while 循環(huán)
- 對于 while 循環(huán)而言，如果不滿足條件，則不能進入循環(huán)。但有時候我們需要即使不滿足條件，也至少執(zhí)行一次。
- do...while 循環(huán)和 while 循環(huán)相似，不同的是，do...while 循環(huán)至少會執(zhí)行一次。
語法：
do {
//代碼語句
}while (布爾表達式);同樣是1+2+3...+100，看看DoWhile是怎么實現(xiàn)的吧！
package com.xiaodi.operator.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
i++;
sum = sum + i;
}while (i<100);
System.out.println(sum);
}
}While和do-While的區(qū)別：
- while先判斷后執(zhí)行。dowhile是先執(zhí)行后判斷！
- Do...while總是保證循環(huán)體會被至少執(zhí)行一次！這是他們的主要差別。
演示：兩者區(qū)別
package com.xiaodi.operator.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a = 0;
int sum = 0;
while (a<0) {
System.out.println(a);
a++;
}
System.out.println("===========");
do {
}while (a<0);
}
}輸出結(jié)果為：
? ===========
? 0
for 循環(huán)
雖然所有的循環(huán)結(jié)構(gòu)都可以用while或者do...while表示，但java提供了另一種語句 for循環(huán)，使一些循環(huán)結(jié)構(gòu)變得更加簡單
for循環(huán)語句是支持迭代的一種通用結(jié)構(gòu),是最有效、最靈活的循環(huán)結(jié)構(gòu)
在IDEA直接輸入100.for然后回車能快捷生成
for循環(huán)執(zhí)行的次數(shù)是在執(zhí)行前就確定的。語法格式如下：
for (初始化;布爾表達式;迭代) {
//代碼語句
}實例：
package com.xiaodi.operator.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1;//初始化條件
while (a<=100) { //布爾表達式
System.out.println(a);//輸出a
a+=2; //迭代
}
System.out.println("while循環(huán)結(jié)束");
//初始化;布爾表達式;迭代
for (int i=0;i<=100;i++) {
System.out.println(i);
System.out.println("For循環(huán)結(jié)束");
}
}for的死循環(huán)
package com.xiaodi.operator.struct;
public class ForDemo02 {
public static void main(String[] args) {
for (;;) {
}
}
}練習1：計算0-100之間的基數(shù)和偶數(shù)的和；
package com.xiaodi.operator.struct;
public class ForDemo03 {
public static void main(String[] args) {
int oddSum = 0;
int evenSum = 0;
for (int i=0;i<100;i++) {
if (i%2!=0) { //奇數(shù)
oddSum+=i;
}else { //偶數(shù)
evenSum+=i;
}
}
System.out.println("0-100之間的奇數(shù)和："+oddSum);
System.out.println("0-100之間的偶數(shù)和："+evenSum);
}
}練習2：用while或for循環(huán)輸出1-1000之間能被5整除的數(shù)，并且每行輸出3個
第一種方法：
package com.xiaodi.operator.struct;
public class ForDemo04 {
public static void main(String[] args) {
for (int i=0;i<1000;i++) {
if (i%5==0) {
System.out.print(i+"\t");
}
if (i%(3*5)==0) {
System.out.println();
//System.out.print("\n");
}
}
//println 輸出完會換行
//print 輸出完不會換行
}
}第二種方法：
package com.xiaodi.operator.struct;
public class ForDemo04_1 {
public static void main(String[] args) {
for (int i = 0; i < 1000; i+=5) {
System.out.print(i+"\t");
if (i%(3*5)==0) {
System.out.println();
}
}
}
}? 這些練習不一定要用我寫的方法才能實現(xiàn)，大家也可以多思考，主要思路肯定是循環(huán)
至于我為什么這題要寫兩種方法呢？
- 第一種使用的是i++每次只+1，需要循環(huán)1000次，第二種使用的是直接+5，只需循環(huán)200次即可，如果遇到非常大的數(shù)據(jù)時可以減少%75的資源，這是一件很好的事情哈
? 我們可以在不影響程序正常工作的條件下，減少程序運行所需資源
練習3：打印99乘法表
package com.xiaodi.operator.struct;
//效果如下
//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*5=5 2*5=10 3*5=15 4*5=20 5*5=25
//1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
//1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
//1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
//1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
public class ForDemo05 {
public static void main(String[] args) {
//1、我們先打印第一列，這個大家應該都會
//for (int i = 1; i <= 9; i++) {System.out.println("1*"+i+"="+(1*i));}
//2、我們把固定的1再用一個循環(huán)包起來
//使用for (int j = 1; j <= 9; j++) {}把上面的包起來 把固定的1換成循環(huán)的j
//3、去掉重復項，
//i<=j
//4、調(diào)整樣式
//使用print使其不換行 間隔用"\t"
//里面的循環(huán)每次完成一次則輸出一次換行 System.out.println();
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(i+"x"+j+"="+(j*i) + "\t");
}
System.out.println();
}
}
}? 這道題主要學習思路，學會把一個大問題拆分成若干個小問題，逐一攻破！，這也是我們以后開發(fā)項目的一個基本思路！
增強型for循環(huán)
- 這里我們先只是先見一面，做個了解，之后數(shù)組我們重點使用
- Java5引入了一種主要用于數(shù)組或集合的增強型 for循環(huán)。
語法：
for (聲明語句 : 表達式) {
//代碼句子
}聲明語句：聲明新的局部變量，該變量的類型必須和數(shù)組元素的類型匹配，其作用域限定在循環(huán)語句塊，其值與此時數(shù)組元素的值相等
表達式：表達式是要訪問的數(shù)組名，或者是返回值為數(shù)組的方法。
演示：
package com.xiaodi.operator.struct;
public class ForDemo06 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50}; //定義了一個數(shù)組
//遍歷數(shù)組的元素
for (int x:numbers) {
System.out.println(x);
}
}
}分析：把numbers這個數(shù)組每一項遍歷出來，賦值給int x，每次循環(huán)x就從numbers中取值
我們用普通for循環(huán)演示一下 上面的操作，上面使用的增量型for循環(huán)就是用來簡化下面的操作，核心原理是一樣的，大家簡單理解一下
package com.xiaodi.operator.struct;
public class ForDemo07 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
for (int i = 0;i<5;i++) {
System.out.println(numbers[i]);
}
}
}現(xiàn)在能理解當然是最好的了，不理解也沒關(guān)系，我們現(xiàn)在只是讓大家知道一下我們以后會學一個這樣簡化的東西！不理解不必深究！
break &continue*
- break在任何循環(huán)語句的主體部分，均可用break控制循環(huán)的流程。break用于強行退出循環(huán)，不執(zhí)行循環(huán)中剩余的語句。（break語句也在switch'語句中使用）
演示：
package com.xiaodi.operator.struct;
public class BreakDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;
System.out.println(i);
if (i==30) { //如果i等于30的時候，則跳出循環(huán)體
break;
}
}
System.out.println("123"); //證明break只是跳出循環(huán)體
}
}break只是跳出循環(huán)，程序還會繼續(xù)執(zhí)行。
- continue 語句用在循環(huán)語句體中，用于終止某次循環(huán)過程，即跳過循環(huán)體中尚未執(zhí)行的語句，接著進行下一次是否執(zhí)行循環(huán)的判定。
演示：
package com.xiaodi.operator.struct;
public class ContinueDemo01 {
public static void main(String[] args) {
int i = 0;
while (i<100) {
i++;
if ((i%10)==0) { //如果i能被10整除，則輸出換行，然后跳過當前這次循環(huán)
System.out.println();
continue;
}
System.out.print(i+"\t");
}
}
}通過上面的演示，break可以理解為，我不干了；continue可以理解為，我不干了第二天又慫了又回來繼續(xù)干
練習
打印5行的三角形
解題思維：
我們把三角形切一下，然后分部完成
第一步打印1
package com.xiaodi.operator.struct;
public class TestDemo01 {
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();
}
}
}第二部打印2，然后把第一步打印的內(nèi)容變?yōu)榭崭?/p>
package com.xiaodi.operator.struct;
public class TestDemo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}第三步打印第三部分
package com.xiaodi.operator.struct;
public class TestDemo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}如果不理解使用IDEA中的Debug
? 在你不理解的行開始打上斷點，就是在行號后面點一下，然后點擊小蟲子圖標，然后程序運行到斷點會停住，然后通過↓這個符號一步一步的去運行下去，去一步一步理解！點擊console能看見當前輸出的結(jié)果
到此這篇關(guān)于Java控制流程的文章就介紹到這了,更多相關(guān)Java控制流程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Java并發(fā) CompletableFuture異步編程的實現(xiàn)
這篇文章主要介紹了Java并發(fā) CompletableFuture異步編程的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-01-01
這篇文章主要介紹了Java創(chuàng)建多線程服務器流程，以下實例演示了如何使用Socket類的accept()方法和ServerSocket類的MultiThreadServer(socketname)方法來實現(xiàn)多線程服務器程序2023-05-05
這篇文章主要介紹了Java并發(fā)CopyOnWrite容器原理解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-01-01
Java springboot壓縮文件上傳,解壓,刪除壓縮包方式
這篇文章主要介紹了Java springboot壓縮文件上傳,解壓,刪除壓縮包方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2025-04-04
springMVC幾種頁面跳轉(zhuǎn)方式小結(jié)
本篇文章主要介紹了springMVC 幾種頁面跳轉(zhuǎn)方式，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-02-02
使用IDEA搭建Hadoop開發(fā)環(huán)境的操作步驟(Window10為例)
經(jīng)過三次重裝，查閱無數(shù)資料后成功完成hadoop在win10上實現(xiàn)偽分布式集群，以及IDEA開發(fā)環(huán)境的搭建。一步一步跟著本文操作可以避免無數(shù)天坑2021-07-07
這篇文章主要介紹了關(guān)于@Configuration的作用說明，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01
這篇文章主要介紹了java應用開發(fā)之JVM運行時內(nèi)存，文中附含圖文示例內(nèi)容分析非常簡要，有需要的朋友可以借鑒參考下，希望能夠有所幫助2021-09-09
Consul是一款由HashiCorp公司開源的，用于服務治理的軟件，Spring Cloud Consul對其進行了封裝，這篇文章主要介紹了springcloud組件consul服務治理,需要的朋友可以參考下2022-08-08
這篇文章主要介紹了java實現(xiàn)倒序讀取文件功能示例,需要的朋友可以參考下2014-04-04