java基礎(5):流程控制語句（switch）、數組

時間 2019-11-18

標籤 java 基礎流程控制語句 switch 數組欄目 Java 简体版

原文原文鏈接

1. 流程控制語句（續）

1.1 選擇結構switch

switch 條件語句也是一種很經常使用的選擇語句，它和if條件語句不一樣，它只能針對某個表達式的值做出判斷，從而決定程序執行哪一段代碼。例如，在程序中使用數字1~7來表示星期一到星期天，若是想根據某個輸入的數字來輸出對應中文格式的星期值，能夠經過下面的一段僞代碼來描述：java

用於表示星期的數字
    若是等於1，則輸出星期一
    若是等於2，則輸出星期二
    若是等於3，則輸出星期三
    若是等於4，則輸出星期四
    若是等於5，則輸出星期五
    若是等於6，則輸出星期六
    若是等於7，則輸出星期天

對於上面一段僞代碼的描述，你們可能會馬上想到用剛學過得if…else if…else語句來實現，可是因爲判斷條件比較多，實現起來代碼過長，不便於閱讀。Java中提供了一種switch語句來實現這種需求，在switch語句中使用switch關鍵字來描述一個表達式，使用case關鍵字來描述和表達式結果比較的目標值，當表達式的值和某個目標值匹配時，會執行對應case下的語句。具體實現代碼以下：數組

switch(用於表示星期的數字) {
    case 1 :
        輸出星期一;
        break;
    case 2 :
        輸出星期二;
        break;
    case 3 :
        輸出星期三
        break;
    case 4 :
        輸出星期四;
        break;
    case 5 :
        輸出星期五;
        break;
    case 6:
        輸出星期六;
        break;
    case 7:
        輸出星期天;
        break;
}

上面改寫後的僞代碼便描述了switch語句的基本語法格式，具體以下：安全

switch (表達式){
    case 目標值1:
        執行語句1
        break;
    case 目標值2:
        執行語句2
        break;
    ．．．．．．
    case 目標值n:
        執行語句n
        break;
    default:
        執行語句n+1
        break;
}

在上面的格式中，switch語句將表達式的值與每一個case中的目標值進行匹配，若是找到了匹配的值，會執行對應case後的語句，若是沒找到任何匹配的值，就會執行default後的語句。switch語句中的break關鍵字將在後面的作具體介紹，此處，咱們只須要知道break的做用是跳出switch語句便可。學習

須要注意的是，在switch語句中的表達式只能是byte、short、char、int類型的值，若是傳入其它類型的值，程序會報錯。但上述說法並不嚴謹，實際上在JDK5.0中引入的新特性enum枚舉也能夠做爲switch語句表達式的值，在JDK7.0中也引入了新特性，switch語句能夠接收一個String類型的值。spa

1.2 選擇結構switch練習

接下來經過一個案例演示根據數字來輸出中文格式的星期，以下所示。SwitchDemo01.java指針

public class SwitchDemo01 {
    public static void main(String[] args) {
        int week = 5;
        switch (week) {
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期天");
            break;
        default:
            System.out.println("輸入的數字不正確...");
            break;
        }
    }
}

運行結果如圖所示。code

上述代碼中，因爲變量week的值爲5，整個switch語句判斷的結果知足第17行的條件，所以打印「星期五」，例程中的default語句用於處理和前面的case都不匹配的值，將第3行代碼替換爲int week = 8，再次運行程序，輸出結果以下圖所示。對象

在使用switch語句的過程當中，若是多個case條件後面的執行語句是同樣的，則該執行語句只需書寫一次便可，這是一種簡寫的方式。例如，要判斷一週中的某一天是否爲工做日，一樣使用數字1~7來表示星期一到星期天，當輸入的數字爲一、二、三、四、5時就視爲工做日，不然就視爲休息日。接下來經過一個案例來實現上面描述的狀況，以下所示。SwitchDemo02.javablog

public class SwitchDemo02 {
    public static void main(String[] args) {
        int week = 2;
        switch (week) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            // 當 week 知足值 一、二、三、四、5 中任意一個時，處理方式相同
            System.out.println("今天是工做日");
            break;
        case 6:
        case 7:
            // 當 week 知足值 六、7 中任意一個時，處理方式相同
            System.out.println("今天是休息日");
            break;
        }
    }
}

運行結果以下圖所示。排序

上述代碼中，當變量week值爲一、二、三、四、5中任意一個值時，處理方式相同，都會打印「今天是工做日」。同理，當變量week值爲六、7中任意一個值時，打印「今天是休息日」。

2. 數組

在生活中，咱們可能會碰到以下的場景。

如今須要統計某公司員工的工資狀況，例如計算平均工資、最高工資等。假設該公司有50名員工，用前面所學的知識完成，那麼程序首先須要聲明50個變量來分別記住每位員工的工資，這樣作會顯得很麻煩。

其實在Java中，咱們可使用一個數組來記住這50名員工的工資。數組是指一組數據的集合，數組中的每一個數據被稱做元素。在數組中能夠存聽任意類型的元素，但同一個數組裏存放的元素類型必須一致。

2.1 數組的定義

在Java中，可使用如下格式來定義一個數組。以下

數據類型[] 數組名 = new 數據類型[元素個數或數組長度];

int[] x = new int[100];

上述語句就至關於在內存中定義了100個int類型的變量，第一個變量的名稱爲x[0]，第二個變量的名稱爲x[1]，以此類推，第100個變量的名稱爲x[99]，這些變量的初始值都是0。爲了更好地理解數組的這種定義方式，能夠將上面的一句代碼分紅兩句來寫，具體以下：

int[] x;              // 聲明一個int[]類型的變量
x = new int[100];    // 建立一個長度爲100的數組

接下來，經過兩張內存圖來詳細地說明數組在建立過程當中內存的分配狀況。

第一行代碼 int[] x; 聲明瞭一個變量x，該變量的類型爲int[]，即一個int類型的數組。變量x會佔用一塊內存單元，它沒有被分配初始值。內存中的狀態以下圖所示。

第二行代碼 x = new int[100]; 建立了一個數組，將數組的地址賦值給變量x。在程序運行期間可使用變量x來引用數組，這時內存中的狀態會發生變化，以下圖所示。

在上圖中描述了變量x引用數組的狀況。該數組中有100個元素，初始值都爲0。數組中的每一個元素都有一個索引(也可稱爲角標)，要想訪問數組中的元素能夠經過「x[0]、x[1]、……、x[98]、x[99]」的形式。須要注意的是，數組中最小的索引是0，最大的索引是「數組的長度-1」。在Java中，爲了方便咱們得到數組的長度，提供了一個length屬性，在程序中能夠經過「數組名.length」的方式來得到數組的長度，即元素的個數。

接下來，經過一個案例來演示如何定義數組以及訪問數組中的元素，以下所示。ArrayDemo01.java

public class ArrayDemo01 {
        public static void main(String[] args) {
         int[] arr; // 聲明變量
         arr = new int[3]; // 建立數組對象
         System.out.println("arr[0]=" + arr[0]); // 訪問數組中的第一個元素
         System.out.println("arr[1]=" + arr[1]); // 訪問數組中的第二個元素
         System.out.println("arr[2]=" + arr[2]); // 訪問數組中的第三個元素
         System.out.println("數組的長度是：" + arr.length); // 打印數組長度
     }
}

運行結果以下圖所示。

在上述代碼中聲明瞭一個int[]類型變量arr，並將數組在內存中的地址賦值給它。在5~7行代碼中經過角標來訪問數組中的元素，在第8行代碼中經過length屬性訪問數組中元素的個數。從打印結果能夠看出，數組中的三個元素初始值都爲0，這是由於當數組被成功建立後，數組中元素會被自動賦予一個默認值，根據元素類型的不一樣，默認初始化的值也是不同的。具體以下表所示。

數據類型	默認初始化值
byte、short、int、long	0
float、double	0.0
char	一個空字符（空格），即’\u0000’
boolean	false
引用數據類型	null，表示變量不引用任何對象

若是在使用數組時，不想使用這些默認初始值，也能夠顯式地爲這些元素賦值。接下來經過一個程序來學習如何爲數組的元素賦值，以下所示。ArrayDemo02.java

public class ArrayDemo02 {
        public static void main(String[] args) {
                int[] arr = new int[4]; // 定義能夠存儲4個整數的數組
                arr[0] = 1; // 爲第1個元素賦值1
                arr[1] = 2; // 爲第2個元素賦值2
         // 下面的代碼是打印數組中每一個元素的值
         System.out.println("arr[0]=" + arr[0]);
         System.out.println("arr[1]=" + arr[1]);
         System.out.println("arr[2]=" + arr[2]);
        System.out.println("arr[3]=" + arr[3]);
       }
}

運行結果以下圖所示。

在上述代碼中，第3行代碼定義了一個數組，此時數組中每一個元素都爲默認初始值0。第二、3行代碼經過賦值語句將數組中的元素arr[0]和arr[1]分別賦值爲1和2，而元素arr[2]和arr[3]沒有賦值，其值仍爲0，所以打印結果中四個元素的值依次爲一、二、0、0。

在定義數組時只指定數組的長度，由系統自動爲元素賦初值的方式稱做動態初始化。

在初始化數組時還有一種方式叫作靜態初始化，就是在定義數組的同時就爲數組的每一個元素賦值。數組的靜態初始化有兩種方式，具體格式以下：

一、類型[] 數組名 = new 類型[]{元素，元素，……};

二、類型[] 數組名 = {元素，元素，元素，……};

上面的兩種方式均可以實現數組的靜態初始化，可是爲了簡便，建議採用第二種方式。接下來經過一段代碼來演示數組靜態初始化的效果，以下所示。ArrayDemo03.java

 public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4 }; // 靜態初始化
        // 下面的代碼是依次訪問數組中的元素
        System.out.println("arr[0] = " + arr[0]);
        System.out.println("arr[1] = " + arr[1]);
        System.out.println("arr[2] = " + arr[2]);
        System.out.println("arr[3] = " + arr[3]);
     }
 }

運行結果以下圖所示。

上述代碼中採用靜態初始化的方式爲數組每一個元素賦予初值，分別是一、二、三、4。須要注意的是，第3行代碼千萬不可寫成int[] arr = new int[4]{1,2,3,4};，這樣寫編譯器會報錯。緣由在於編譯器會認爲數組限定的元素個數[4]與實際存儲的元素{1,2,3,4}個數有可能不一致，存在必定的安全隱患。

2.2 數組的遍歷

在操做數組時，常常須要依次訪問數組中的每一個元素，這種操做稱做數組的遍歷。接下來經過一個案例來學習如何使用for循環來遍歷數組，以下所示。ArrayDemo04.java

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 }; // 定義數組
        // 使用for循環遍歷數組的元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]); // 經過索引訪問元素
        }
    }
}

運行結果以下圖所示。

上述代碼中，定義一個長度爲5的數組arr，數組的角標爲0~4。因爲for循環中定義的變量i的值在循環過程當中爲0~4，所以能夠做爲索引，依次去訪問數組中的元素，並將元素的值打印出來。

2.3 數組的常見問題

數組在編寫程序時應用很是普遍，靈活地使用數組對實際開發很重要。接下來，本節將針對數組的常見操做進行詳細地講解，如數組的遍歷、最值的獲取、數組的排序等。

2.3.1 數組最值

在操做數組時，常常須要獲取數組中元素的最值。接下來經過一個案例來演示如何獲取數組中元素的最大值，以下所示。ArrayDemo05.java

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定義一個數組
int max = arr[0]; // 定義變量max用於記住最大數，首先假設第一個元素爲最大值
        // 下面經過一個for循環遍歷數組中的元素
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > max) { // 比較 arr[x]的值是否大於max
                max = arr[x]; // 條件成立，將arr[x]的值賦給max
            }
        }
        System.out.println("max=" + max); // 打印最大值
    }
}

運行結果以下圖所示。

上述代碼中，定義了一個臨時變量max，用於記住數組的最大值。經過for 循環獲取數組中的最大值，賦值給max變量。

首先假設數組中第一個元素arr[0]爲最大值，而後使用for循環對數組進行遍歷，在遍歷的過程當中只要遇到比max值還大的元素，就將該元素賦值給max。這樣一來，變量max就可以在循環結束時記住數組中的最大值。須要注意的是，在for循環中的變量i是從1開始的，這樣寫的緣由是程序已經假設第一個元素爲最大值，for循環中只須要從第二個元素開始比較，從而提升程序的運行效率。

2.3.2 數組異常

2.3.2.1 數組越界異常

每一個數組的索引都有一個範圍，即0~length-1。在訪問數組的元素時，索引不能超出這個範圍，不然程序會報錯，以下所示。ArrayDemo06.java

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] arr = new int[4]; // 定義一個長度爲4的數組
        System.out.println("arr[0]=" + arr[4]); // 經過角標4訪問數組元素
    }
}

運行結果以下圖所示。

上圖運行結果中所提示的錯誤信息是數組越界異常ArrayIndexOutOfBoundsException，出現這個異常的緣由是數組的長度爲4，其索引範圍爲0~3，而上述代碼中的第4行代碼使用索引4來訪問元素時超出了數組的索引範圍。

所謂異常指程序中出現的錯誤，它會報告出錯的異常類型、出錯的行號以及出錯的緣由，關於異常在後面的章節會有詳細地講解。

2.3.2.2 空指針異常

在使用變量引用一個數組時，變量必須指向一個有效的數組對象，若是該變量的值爲null，則意味着沒有指向任何數組，此時經過該變量訪問數組的元素會出現空指針異常，接下來經過一個案例來演示這種異常，以下所示。ArrayDemo07.java

public class ArrayDemo07 {
     public static void main(String[] args) {
        int[] arr = new int[3]; // 定義一個長度爲3的數組
        arr[0] = 5; // 爲數組的第一個元素賦值
        System.out.println("arr[0]=" + arr[0]); // 訪問數組的元素
        arr = null; // 將變量arr置爲null
         System.out.println("arr[0]=" + arr[0]); // 訪問數組的元素
    }
}

運行結果以下圖所示。

經過上圖所示的運行結果能夠看出，上述代碼中第四、5行代碼都能經過變量arr正常地操做數組。第6行代碼將變量置爲null，當第7行代碼再次訪問數組時就出現了空指針異常NullPointerException。

在程序中能夠經過一個數組來保存某個班級學生的考試成績，試想一下，若是要統計一個學校各個班級學生的考試成績，又該如何實現呢？這時就須要用到多維數組，多維數組能夠簡單地理解爲在數組中嵌套數組。在程序中比較常見的就是二維數組，接下來針對二維數組進行詳細地講解。

2.4.1 二維數組的定義格式

二維數組的定義有不少方式，接下來針對幾種常見的方式進行詳細地講解，具體以下：

第一種方式：

int[][] arr = new int[3][4];

上面的代碼至關於定義了一個3*4的二維數組，即二維數組的長度爲3，二維數組中的每一個元素又是一個長度爲4的數組，接下來經過一個圖來表示這種狀況，以下圖所示。

第二種方式：

int[][] arr = new int[3][];

第二種方式和第一種相似，只是數組中每一個元素的長度不肯定，接下來經過一個圖來表示這種狀況，以下圖所示。

第三種方式：

int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};

上面的二維數組中定義了三個元素，這三個元素都是數組，分別爲{1,2}、{3,4,5,6}、{7,8,9}，接下來經過一個圖來表示這種狀況，以下圖所示。

對二維數組中元素的訪問也是經過角標的方式，如需訪問二維數組中第一個元素數組的第二個元素，具體代碼以下：

arr[0][1];

2.4.2 二維數組元素的訪問

操做二維數組時，常常須要獲取數組中元素的值。接下來經過一個案例來演示如何獲取數組中元素值，以下所示。ArrayDemo08.java

class ArrayDemo08 {
    public static void main(String[] args){
    
        //定義二維數組的方式
        int[][] arr = new int[3][4];
    
        System.out.println( arr );
        System.out.println("二維數組的長度: " + arr.length);
        //獲取二維數組的3個元素
        System.out.println( arr[0] );
        System.out.println( arr[1] );
        System.out.println( arr[2] );
        
        System.out.println("打印第一個一維數組的元素值");
        System.out.println( arr[0][0] );
        System.out.println( arr[0][1] );//訪問的爲二維數組中第1個一維數組的第2個元素
        System.out.println( arr[0][2] );
        System.out.println( arr[0][3] );
        
        System.out.println("打印第二個一維數組的元素值");
        System.out.println( arr[1][0] );
        System.out.println( arr[1][1] );
        System.out.println( arr[1][2] );
        System.out.println( arr[1][3] );
        
        System.out.println("打印第三個一維數組的元素值");
        System.out.println( arr[2][0] );
        System.out.println( arr[2][1] );
        System.out.println( arr[2][2] );
        System.out.println( arr[2][3] );
    }
}

運行結果以下圖所示：

2.4.3 二維數組元素遍歷與數組元素累加和

學習完了數組元素的訪問，咱們來學習下數組的遍歷及數組的元素累加和操做。

class ArrayDemo09 {

    public static void main(String[] args){

        //一維數組的求累加和並遍歷

        int[] arr = {10,20,30,40,50};

        int sum = 0;

        for (int i=0; i<arr.length; i++) {

              //System.out.println(arr[i]);

            sum += arr[i];

        }

        System.out.println("sum= " + sum);

        System.out.println("---------------------");

       

//二維數組的求累加和並遍歷

        int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };

        int sum2 = 0;

        for (int i=0; i<arr2.length; i++) {

            for (int j=0; j<arr2[i].length; j++) {

                 //System.out.println(arr2[i][j])

                sum2 += arr2[i][j];

            }

        }

        System.out.println("sum2= "+ sum2);

    }

}

運行結果以下圖所示：

2.4.4 公司銷售總和練習

接下來經過一個案例來熟悉二維數組的使用。

例如要統計一個公司三個銷售小組中每一個小組的總銷售額以及整個公司的銷售額。以下所示

第一小組銷售額爲{11, 12}萬元

第二小組銷售額爲{21, 22, 23}萬元

第三小組銷售額爲{31, 32, 33, 34}萬元。

ArrayDemo08.java

public class ArrayDemo10 {
       public static void main(String[] args) {

          int[][] arr = new int[3][]; // 定義一個長度爲3的二維數組

          arr[0] = new int[] { 11, 12 }; // 爲數組的元素賦值

          arr[1] = new int[] { 21, 22, 23 };

          arr[2] = new int[] { 31, 32, 33, 34 };
      

          int sum = 0; // 定義變量記錄總銷售額

          for (int i = 0; i < arr.length; i++) { // 遍歷數組元素

                  int groupSum = 0; // 定義變量記錄小組銷售總額

                  for (int j = 0; j < arr[i].length; j++) { // 遍歷小組內每一個人的銷售額
                       groupSum = groupSum + arr[i][j];
                   }

           sum = sum + groupSum; // 累加小組銷售額

           System.out.println("第" + (i + 1) + "小組銷售額爲：" + groupSum + " 萬元");

            }
        System.out.println("總銷售額爲: " + sum + " 萬元");
      }
}

運行結果以下圖所示。

在上述代碼中，第3行代碼定義了一個長度爲3的二維數組，並在4~6行代碼中爲數組的每一個元素賦值。例程中還定義了兩個變量sum和groupSum，其中sum用來記錄公司的總銷售額，groupSum用來記錄每一個銷售小組的銷售額。當經過嵌套for循環統計銷售額時，外層循環對三個銷售小組進行遍歷，內層循環對每一個小組員工的銷售額進行遍歷，內層循環每循環一次就至關於將一個小組員工的銷售總額統計完畢，賦值給groupSum，而後把groupSum的值與sum的值相加賦值給sum。當外層循環結束時，三個銷售小組的銷售總額groupSum都累加到sum中，即統計出了整個公司的銷售總額。