Java程式語句執行的順序包括4種基本控制結構：
（1）順序結構；
（2）選擇結構：if語句和switch語句；
（3）迴圈結構：for、while、do……while、for each；
（4）異常處理邏輯結構。

一、跳轉語句

跳轉語句用於無條件地轉移控制。使用跳轉語句執行分支，該語句會導致立即傳遞程式控制。
（一）break語句
（1）不帶標籤的break語句：
在多分支選擇（switch結構）中的作用是跳出switch結構，繼續執行switch語句的後繼語句。
還可以用於退出for、for each、while或do……while迴圈，即提前結束迴圈，接著執行迴圈語句的後繼語句。

注：不能用於迴圈語句和switch語句之外的任何其他語句之中，否則將產生編譯錯誤。
當多個switch、while、do……while、for或for each語句彼此巢狀時，不帶標籤的break語句只應用於最裡層的語句，即用於跳出最近的一層迴圈。

若要穿過多個巢狀層轉移控制，必須使用帶標籤的break語句。
（2）帶標籤的break語句：
帶標籤的break語句用於跳出有標籤標記的語句/語句塊。
標籤是一個識別符號，標籤後面帶一個冒號，並置於一個語句或語句塊之前，則標記該語句或語句塊。
注：帶標籤的break語句跳轉到目的標籤只能指向包含該break語句的外層語句塊，否則會產生編譯錯誤。
（二）continue語句
（1）不帶標籤的continue語句：
類似於break語句，但它結束本次迴圈，即跳過迴圈體內continue下面尚未執行的語句，返回到迴圈起始處，並根據迴圈條件判斷是否執行下一次迴圈。
與不帶標籤的break語句的區別在於：continue語句只結束本次迴圈，並返回到迴圈起始處，如果條件滿足就開始執行下一次迴圈；而break語句則是結束迴圈，跳轉到迴圈的後繼語句執行。

與不帶標籤的break語句相似，當多個while、do……while、for或for each語句彼此巢狀時，不帶標籤的continue語句只應用於最裡層的語句。如果要穿過多個巢狀層轉移控制，必須使用帶標籤的continue語句。
（2）帶標籤的continue語句：
與帶標籤的break語句相似，用於結束本次迴圈，並跳轉到由標籤標記的外層迴圈。

注：帶標籤的continue語句只能用於穿過多個巢狀層轉移控制，它跳轉到的目標標籤也只能指向包含該continue語句的外層語句塊，否則會產生編譯錯誤。
（三）return語句
用於終止方法的執行並將控制返回給呼叫方法。
如果方法有返回型別，return語句必須返回這個型別的值。
如果方法為void型別，不使用return語句。

二、陣列概述

陣列是一種資料結構，是包含相同資料型別的集合。本身是陣列引用型別物件，陣列元素可以是任何資料型別（簡單型別或引用型別），包括陣列型別。

• 陣列必須先宣告。因為陣列型別為引用型別，陣列變數的宣告只是為陣列例項的引用留出空間。
• 陣列在聲明後必須例項化才能使用。

注：如果通過{}初始化陣列的元素，使用new運算子建立陣列不需要也不能指定陣列元素的個數，Java編譯器將自動推斷陣列的個數。

通過陣列下標來訪問陣列中的資料元素。陣列下標從0開始，具有n個元素（即長度為n）的陣列的下標是0~n-1.

三、Java類庫中運算元組的類和方法

（1）java.util.Arrays：可用於陣列的複製、排序等操作處理。
（2）System.arraycopy：是System類提供的一個靜態方法，可以用它來實現陣列間的複製。
（3）陣列名.clone()：
如果要將一個數組a1的內容複製給另外一個數組a2的方法：

• 使用迴圈語句，將陣列a1的每個元素複製到陣列a2對應的元素。優點：靈活；缺點：需要編碼。
• 使用陣列變數的clone()方法。優點：簡單；缺點：不夠靈活。
• 使用System.arraycopy(src,srcPos,dest,destPos,length)方法。該方法靈活簡單推薦使用。
• 使用java.util.Arrays.CopyOf/copyOfRang方法。簡單靈活推薦使用。

注：clone()方法不能直接作用於多維陣列。如果要用clone()方法對多維陣列進行復制，就要在每一維上呼叫clone()方法。

練習

**1.1.實現二分查詢演算法：有序的陣列
**

//import java.util.Scanner;

public class BinarySearch {
    //二分查詢
    public static int binarySearch(int[] a,int key){
        //開始查詢範圍始從陣列的第一個元素到最後一個
        int low = 0;//最小元素下標為0
        int high = a.length - 1;//最大元素下標==陣列長度-1
        int m = a.length / 2;//中間數下標
        if (key == a[m]){//中間數和key相等，查詢成功
            return m;
        }else{
            //如果不相等，繼續查詢
            while(low <= high){//查詢結束,退出迴圈
                m = (low + high) /2;
                if (key == a[m]){//如果key和比較元素的值相等，查詢成功
//                System.out.println(key + "= array[" + m + "]" );
                    return m;
                }else if(key < a[m]){
                    high = m - 1;//在中間數的左邊查詢
                } else{//key>a[m]
                    low = m +1;//在中間數右邊查詢
                }
            }
            //查詢失敗，返回-1
            return -1;
        }

    }

    public static void main(String[] args){

//        Scanner scan = new Scanner(System.in);
//        System.out.println("輸入一個長度為10的一維陣列：");
//        int[] array = new int[10];
//        for(int i = 0;i < 10;i ++){
//            array[i] = scan.nextInt();
//        }

        int[] array = {1,2,3,4,5,6,7,8,9,10};
        binarySearch(array,3);

//        System.out.println("查詢元素：");
//        int k = scan.nextInt();
////        System.out.println(k);
//        binarySearch(array,k);
    }
}

**2.求連續子陣列的最大和
**

//求連續子陣列的最大和，不能超過0x8000 0000
//import java.util.Scanner;
import java.util.Arrays;

public class MaxSumOfSubarray {
    public static int maxSum(int a[]) {
        if (a.length == 0) //陣列長度為0，直接返回-1
            return -1;
        if (a.length == 1)
            return a[0];
        int sum = a[0];
        int max;
        for (int i = 0; i < a.length - 1; i++) {
            max = a[i];//從a[i]往後遍歷，相加之後和sum比較
            for (int j = i + 1; j < a.length; j++) {
                sum = sum + a[j];
                if (sum > max) {
                    max = sum;
                }
            }
        }
        return max;//返回錯誤？？
    }

    public static void main(String[] args) {
        int array[] = {-1, 5, 10, -2, 9};
        System.out.println("子陣列最大和：");
        maxSum(array);
        System.out.println(Arrays.toString(array));
    }
}

**3.交換兩個數
**
//交換兩個數

import java.util.Arrays;
import java.util.Scanner;

public class ExchangeNumber {
public static void exchange(int a[]){
int t;
t = a[0];
a[0] = a[1];
a[1] = t;
System.out.println(Arrays.toString(a));
}
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println(“輸入兩個數字：”);
int[] array = new int[2];
array[0] = scan.nextInt();
array[1] = scan.nextInt();
exchange(array);
}
}
4.逆置陣列

//逆置陣列
import java.util.Scanner;
import java.util.Arrays;

public class InverseArray {
    //逆置
    public static void inverse(int a[]){
        int t;//設中間變數t，方便陣列元素間的轉換
        for(int i = 0;i <= a.length / 2;i ++){//迴圈5次
            t = a[i];
            a[i] = a[a.length - 1 - i];//對應元素的下標和是陣列長度減一
            a[a.length - 1 - i] = t;
        }
        System.out.println(Arrays.toString(a));//輸出逆置後的陣列
    }
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        System.out.println("輸入一個長度為10的一維陣列：");
        int[] array = new int[10];
        for(int i = 0;i < 10;i ++){
            array[i] = scan.nextInt();
        }

//        int array[] = {0,1,2,3,4,5,6,7,8,9};
        inverse(array);
    }
}