Java流程控制*
用戶互動Scanner、Scanner進階使用
用戶互動Scanner
? 之前我們學習的基本語法中我們并沒有實作程式和人的互動，但是Java給我們提供了這樣一個工具類，我們可以獲取用戶的輸入，java.util.Scanner 是java5的新特征，我們可以通過Scanner類來獲取用戶的輸入
基本語法：
Scanner s = new Scanner(System.in);
//有些代碼大家可能不理解，比如這個new，大家目前先不用理解代碼的意思，先學會跟著操作，之后我們講面向物件的時候你就會逐一明白這些代碼每一個具體的意思
? 通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字串，在讀取前我們一般需要使用 hasNext() 與 hasNexLine() 來判斷是否還有輸入的資料，
? 下面我們來實踐一下加深理解和記憶
使用next方式讀取：
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args){
//創建一個掃描器物件 用于接收鍵盤資料
//使用IDEA開發工具輸入Scanner之后回車，它就會自動匯入這個類import java.util.Scanner;
//我們之前一直用的是System.out是輸出；System.in是輸入
//這里參考了Scanner資料型別
//通過new Scanner(System.in);接收用戶的輸入，并且把它封裝成了scanner物件
Scanner scanner = new Scanner(System.in);
//輸出一行字
System.out.println("使用next()方法接收：");
//判斷用戶有沒有輸入字串
//if陳述句還沒學，if就是如果的意思
//如果scanner這個物件有沒有用戶輸入，（==true不寫就是默認上節課講過，一般新手才會加）有的話就使用執行里面的陳述句
if (scanner.hasNext()){
//使用next方式接收用，并封裝給資料型別為String的str變數
String str = scanner.next();
//輸出用戶輸入的內容
System.out.println("輸入的內容為："+str);
}
//凡是屬于IO流的類如果不關倍訓一直占用資源，要養成好習慣用完就關
scanner.close();
}
}
? 我們運行起來之后，他會顯示使用next方式讀取，然后等待你輸入字串，我輸入hello world回傳輸入的內容為：hello；然后程式結束
? String str = scanner.next();這句代碼執行完程式會等待用戶輸入完畢，如果你沒去輸入資料那么程式就會一直卡在那
? 但是有沒有發現我們輸入的hello world它只輸出了一個hello
剛才我們使用的是next()，現在我們使用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()方式讀取，并封裝給資料型別為String的str變數
String str = scanner.nextLine();
System.out.println("輸入的內容為："+str);
}
scanner.close();
}
}
這次輸入hello world，回傳的也是hello world
那我們來看一下next()和nextLine()兩種接收用戶輸入到底有上面區別
next()：
- 一定要讀取到有效字符后才可以結束輸入，
- 對輸入有效符之前遇到的空白，next()方法會自動去掉
? 例如我輸入： hello；則回傳：hello
-
只有輸入有效字符后才將其后面輸入的空白作為分隔符或結束符
-
next() 不能讀取帶有空格的字串
nextLine()：
- 以Enter為結束符，也就說 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("請輸入資料：");
String str = scanner.nextLine();
System.out.println("輸入的內容為："+str);
scanner.close();
}
}
以上內容請務必掌握！！！
Scanner進階使用
萬一我們需要用戶輸入指定型別的資料，那該怎么判斷用戶輸入的是否是我們指令型別的資料
我們在IDEA定義好scanner物件后；輸入scanner.后會跳出很多方法出來
比如scanner.hasNextInt() ：這樣就是判斷是否輸入的是Int型別；這樣我們就能配合if...else...陳述句來使用；if...else...就是如果就否則就的意思，
讀取資料的方法也要變成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("請輸入資料：");
//使用hasNextInt()方法判讀用戶輸入的資料是否為Int型別
if (scanner.hasNextInt()) {
//使用nextInt()方法讀取Int資料，并賦值給i(這里因為i我們上面已經定義了所以不用在指定型別)
i = scanner.nextInt();
System.out.println("輸入的資料為："+i);
}else {
System.out.println("請輸入整數型別的資料!");
String a = scanner.nextLine();
}
//提示用戶輸入
System.out.println("請輸入資料：");
//使用hasNextFloat()方法判讀用戶輸入的資料是否為Float型別
if (scanner.hasNextFloat()) {
//使用nextFloat()方法讀取float資料，并賦值給f(這里因為f我們上面已經定義了所以不用在指定型別)
f = scanner.nextFloat();
System.out.println("輸入的資料為："+f);
}else {
System.out.println("請輸入小數型別的資料!");
}
scanner.close();
}
}
運行的結果為：
第一種情況：
? 請輸入資料：
? 1
? 輸入的資料為：1
? 請輸入資料：
? 1.2
? 輸入的資料為：1.2
第二種情況
請輸入資料：
xiaodi
請輸入整數型別的資料!
請輸入資料：
xiaodi
請輸入小數型別的資料!
有沒有發現我在第一個if...else...陳述句中的else中加了一行代碼
String a = scanner.nextLine();
你不加這行代碼的話，你運行起來，你第一個資料輸入錯誤了，它會直接將第一個資料拿到第二次做判斷，導致你第二次不能輸入資料，（但是有的地方會有需要這種情況，但是我們這里測驗的話就不用了）
案例：
? 我們可以輸入多個數字，并求其總和與平均數，每輸入一個數字用回車確認，通過輸入輸入非數字來結束輸入并輸出執行結果
package com.xiaodi.operator.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//和,有可能會輸入小數，所以使用double型別
double sum = 0.0;
//個數，因為最后要求平均值，平均值就是和除以個數
int m = 0;
//使用while循，判斷是否輸入數字，如果是就一直回圈獲取用戶輸入，如果不是則退出回圈
while (scanner.hasNextDouble()) {
//獲取用戶輸入，并賦值給i
double i = scanner.nextDouble();
//把和加上獲取的輸入
sum = sum + i;
//個數加1
m = m + 1;//m++
System.out.println("您輸入了第"+m+"個資料當前的總和為："+sum);
}
//輸出總和和平均數
System.out.println("您輸入的資料的總和為："+sum);
System.out.println("您輸入的資料的平均數為："+(sum / m));
scanner.close();
}
}
運行結果：
? 10.5
? 您輸入了第1個資料當前的總和為：10.5
? 19.5
? 您輸入了第2個資料當前的總和為：30.0
? 30
? 您輸入了第3個資料當前的總和為：60.0
? 40
? 您輸入了第4個資料當前的總和為：100.0
? x
? 您輸入的資料的總和為：100.0
? 您輸入的資料的平均數為：25.0
? 其中while回圈還不懂沒關系，你先跟著我的代碼寫一遍，等一下學到你再回來看一下，你就會恍然大悟，原來是這個樣子的！
順序結構
-
Java的基本結構就是順序結構，除非特別指明，否則就按照順序一句一句執行
-
順序結構是最簡單的演算法結構
-
陳述句與陳述句之間，框與框之間是按從上到下的順序進行的，它是又若干個依次執行的處理步驟組成的，它是任何一個演算法都離不開的一種基本演算法結構
選擇結構*
if選擇結構
if單選擇結構
? 我們很多時候需要去判斷一個東西是否可行，然后我們才去執行，這樣一個程序在程式中用if陳述句來表示
語法：
if (布爾運算式) {
//如果布爾運算式為true將執行的陳述句，如果為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("請輸入內容：");
String s = scanner.nextLine();
//equals：判斷字串是否一致的方法，是字串的一種方法
if (s.equals("Hello")) {
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
第一次輸入Hello則執行if陳述句結果如下：
? 請輸入內容：
? Hello
? Hello
? End
第二次輸入XiaoDi則跳過if陳述句結果如下：
? 請輸入內容：
? XiaoDi
? End
if雙選擇結構
? 那現在有一個需求，學校要一個輸入分數來判定學生成績是否及格的程式，>=60分為及格，<60分為不及格，這樣的需求用一個if就搞不定了，我們需要有兩個判斷，需要一個雙選擇結構，所以就要使用if-else結構
語法：
if (布爾運算式) {
//如果布爾運算式值為true執行的代碼
}else {
//如果布爾運算式值為false執行的代碼
}
演示：
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("請輸入你的分數：");
int score = scanner.nextInt();
if (score>=60) {
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}
第一個同學考了10分(走了else的分支)結果如下：
? 請輸入你的分數：
? 10
? 不及格
第二個同學考了90分(走了if的分支)結果如下：
? 請輸入你的分數：
? 90
? 及格
if多選擇結構
? 我們發現剛才的代碼不符合實際情況，真實的情況還可能存在SABCD，存在區間多級判斷，比如90-100就是S，80-90就是B..等等，在生活中我們很多時候的選擇也不僅僅只有兩個，所以我們需要一個多選擇結構來處理這類問題!
語法：
if (布爾運算式1){
//如果布爾運算式1的值為true執行的代碼
}else if {
//如果布爾運算式2的值為true執行的代碼
}else if {
//如果布爾運算式2的值為true執行的代碼
}else {
//如果以上布爾運算式都不為true執行的代碼
}
演示：
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("本次評級的分數為0-100,請輸入正確的成績");
}
scanner.close();
}
}
太多分支，可以自己執行看看！我這里就不演示執行結果了！會使文章看起來怪怪的
嵌套的if結構
使用嵌套的if...else陳述句是合法的，也就是你可以在另一個if或 else if陳述句中使用if或else if陳述句，你可以像if陳述句一樣嵌套else if...else
語法：
if (布爾運算式1) {
//如果布爾運算式1的值為true執行的代碼
if (布爾運算式2) {
//如果布爾運算式2的值為true執行的代碼
}
}
? 有時候我們在解決一些問題的時候，可以縮小操作范圍，它可以通過層級來判斷，提高效率
? 比如我們現在有一個需求：要查找1-100之間這樣的一個數字，這樣的話是比較麻煩的；
? 我們最笨的方法就是將用戶輸入的數字去1-100之間一個一個的對比，但是萬一他輸入了100，那程式就要對比到100才能成功，這樣就會花費更多的資源和時間；我們就可以用if嵌套來判斷，把這個100分成1-50，50-100去判斷用戶輸入的值在哪個里面，或者分成更多份去判斷；
我們生活在這個大資料時代，我們應該不斷去思考如何提高我們程式的效率，或許哪一天你就想出來了能夠提高效率的演算法那你將在程式的歷史上留下一些痕跡了！
記住一點：我們流程控制陳述句都可以相互嵌套而互不影響
Switch選擇結構
? 多選擇結構還有一個實作方法就是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("優秀");
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時運行如下：
? 優秀
為什么會這樣，我說過這個break是可選的，如果不寫break他就會執行匹配到的分支以及后面的分支直到遇到break，如果沒遇到，就會直接執行到最后；這種現象叫做case穿透；(所以要養成一個好習慣，寫完每一個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("優秀");
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的時候就會執行default分支;
? 跟if比起來switch是有一些好處的，它在執行case陳述句的時候會先匹配，匹配成功就會回傳當前case的值，然后再根據它是否有break判斷是否繼續輸出，if是判斷匹配區間，而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("曉迪");
break;
default :
System.out.println("神馬東西？？");
}
}
}
運行結果為：曉迪
還記不記得我之前講過字符的本質還是數字，給大家講一個東西反編譯
什么叫反編譯：比如.java檔案編譯成.class檔案，這個class檔案叫做位元組碼檔案是人類看不懂的，我們要看懂就要進行反編譯
反編譯教程：
? 使用IDEA，點開享目結構(File-->Project Structure)，就能看到Compiler output，將地址復制到檔案管理器，打開找對對應需要反編譯的檔案，你可以使用notepad++打開看一下，你會發現看不懂，沒事我也看不懂，
? 在IDEA檔案夾那邊右鍵，選擇Open ln，再選擇Explorer打開對應檔案夾，把class檔案復制進去，在IDEA雙擊這個位元組碼檔案，選擇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("小迪");
break;
case 1:
System.out.println("曉迪");
break;
default:
System.out.println("神馬東西？？");
}
}
}
? 你會發現 switch (name) {} 變成了 switch(name.hashCode()) {} ； case "曉迪" : 變成了 case 848887: ，也就是說它進行編譯之后是通過hashCode()進行判斷的，什么是hashCode()，你現在可以理解為每一個物件都有一個hashCode，它是通過一些特定演算法生成的，而我們case后面的字串中文都會有一個自己對應的hash值，然后它就判斷這個hash值是否跟name的hash值相同，這就是JDK7新特性的原理
回圈結構*
while 回圈
while是最基本的回圈，她的結構為：
while (布爾運算式) {
//回圈內容
}
- 只要布爾運算式為 true ，回圈就會一直執行下去，
- 我們大多數情況會讓回圈停止下來，我們需要一個讓運算式失效的方式來結束回圈
- 少部分情況需要回圈一直執行，比如服務器的請求回應監聽等
- 回圈條件一直為true就會造成無限回圈【死回圈】，我們正常的業務編程中應該盡量避免死回圈，會影響程式性能或者造成程式卡死崩潰！
演示輸出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
演示死回圈：
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);
}
}
結果5050
其中while回圈還能像下面這樣寫自己思考一下有什么不同
while (i<=100) {
sum = sum + i;
i++;
}
do..while 回圈
- 對于 while 回圈而言，如果不滿足條件，則不能進入回圈，但有時候我們需要即使不滿足條件，也至少執行一次，
- do...while 回圈和 while 回圈相似，不同的是，do...while 回圈至少會執行一次，
語法：
do {
//代碼陳述句
}while (布爾運算式);
同樣是1+2+3...+100，看看DoWhile是怎么實作的吧！
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的區別：
- while先判斷后執行，dowhile是先執行后判斷！
- Do...while總是保證回圈體會被至少執行一次！這是他們的主要差別，
演示：兩者區別
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 {
System.out.println(a);
a++;
}while (a<0);
}
}
輸出結果為：
? ===========
? 0
for 回圈
-
雖然所有的回圈結構都可以用while或者do...while表示，但java提供了另一種陳述句 for回圈，使一些回圈結構變得更加簡單
-
for回圈陳述句是支持迭代的一種通用結構,是最有效、最靈活的回圈結構
-
在IDEA直接輸入100.for然后回車能快捷生成
-
for回圈執行的次數是在執行前就確定的，語法格式如下：
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回圈結束");
//初始化;布爾運算式;迭代
for (int i=0;i<=100;i++) {
System.out.println(i);
}
System.out.println("For回圈結束");
}
}
for的死回圈
package com.xiaodi.operator.struct;
public class ForDemo02 {
public static void main(String[] args) {
for (;;) {
}
}
}
練習1：計算0-100之間的基數和偶數的和；
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) { //奇數
oddSum+=i;
}else { //偶數
evenSum+=i;
}
}
System.out.println("0-100之間的奇數和："+oddSum);
System.out.println("0-100之間的偶數和："+evenSum);
}
}
練習2：用while或for回圈輸出1-1000之間能被5整除的數，并且每行輸出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();
}
}
}
}
? 這些練習不一定要用我寫的方法才能實作，大家也可以多思考，主要思路肯定是回圈
至于我為什么這題要寫兩種方法呢？
- 第一種使用的是i++每次只+1，需要回圈1000次，第二種使用的是直接+5，只需回圈200次即可，如果遇到非常大的資料時可以減少%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再用一個回圈包起來
//使用for (int j = 1; j <= 9; j++) {}把上面的包起來 把固定的1換成回圈的j
//3、去掉重復項，
//i<=j
//4、調整樣式
//使用print使其不換行 間隔用"\t"
//里面的回圈每次完成一次則輸出一次換行 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();
}
}
}
? 這道題主要學習思路，學會把一個大問題拆分成若干個小問題，逐一攻破！，這也是我們以后開發專案的一個基本思路！
增強型for回圈
- 這里我們先只是先見一面，做個了解，之后陣列我們重點使用
- Java5引入了一種主要用于陣列或集合的增強型 for回圈，
語法：
for (宣告陳述句 : 運算式) {
//代碼句子
}
宣告陳述句：宣告新的區域變數，該變數的型別必須和陣列元素的型別匹配，其作用域限定在回圈陳述句塊，其值與此時陣列元素的值相等
運算式：運算式是要訪問的陣列名，或者是回傳值為陣列的方法，
演示：
package com.xiaodi.operator.struct;
public class ForDemo06 {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50}; //定義了一個陣列
//遍歷陣列的元素
for (int x:numbers) {
System.out.println(x);
}
}
}
分析：把numbers這個陣列每一項遍歷出來，賦值給int x，每次回圈x就從numbers中取值
我們用普通for回圈演示一下 上面的操作，上面使用的增量型for回圈就是用來簡化下面的操作，核心原理是一樣的，大家簡單理解一下
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]);
}
}
}
現在能理解當然是最好的了，不理解也沒關系，我們現在只是讓大家知道一下我們以后會學一個這樣簡化的東西！不理解不必深究！
break &continue*
- break在任何回圈陳述句的主體部分，均可用break控制回圈的流程，break用于強行退出回圈，不執行回圈中剩余的陳述句，（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的時候，則跳出回圈體
break;
}
}
System.out.println("123"); //證明break只是跳出回圈體
}
}
break只是跳出回圈，程式還會繼續執行，
- continue 陳述句用在回圈陳述句體中，用于終止某次回圈程序，即跳過回圈體中尚未執行的陳述句，接著進行下一次是否執行回圈的判定，
演示：
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整除，則輸出換行，然后跳過當前這次回圈
System.out.println();
continue;
}
System.out.print(i+"\t");
}
}
}
通過上面的演示，break可以理解為，我不干了；continue可以理解為，我不干了第二天又慫了又回來繼續干
練習
列印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，然后把第一步列印的內容變為空格
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能看見當前輸出的結果
這個提主要還是學思維哈，一定要去認真的理解一下，Debug也要學起來
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/439132.html
標籤：Java
上一篇：springcloud alibaba 阿里 Nacos 注冊中心 配置啟動說明
下一篇：Java 雜記