Java控制流程範例程式碼詳解

2022-03-08 13:04:03

使用者互動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();
        }
        //使用hasNextFloat()方法判讀使用者輸入的資料是否為Float型別
        if (scanner.hasNextFloat()) {
            //使用nextFloat()方法讀取float資料，並賦值給f(這裡因為f我們上面已經定義了所以不用在指定型別)
            f = scanner.nextFloat();
            System.out.println("輸入的資料為："+f);
            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("曉迪");
            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("小迪");
        case 1:
            System.out.println("曉迪");
        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 {
        }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能看見當前輸出的結果

到此這篇關於Java控制流程的文章就介紹到這了,更多相關Java控制流程內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！