首先繼續來談一下迴圈：while迴圈、do…while迴圈、for each迴圈。

while迴圈

 與for迴圈一樣，while也是一個預測試的迴圈，但是while在迴圈開始之前，並不能確定重複執行迴圈開始語句序列的次數。while按不同的條件執行迴圈語句序列零次或多次。

• 例：求1+2+……的和，值之和大於1000為止。

package kkzz;
public class SumWhile {
    public static void  main(String[] args) {
        int sum = 0;
        int i = 0;
        while (sum <= 10000){
            sum += i;
            i++;
        }
        System.out.printf("%d",sum);
    }
}
 

10011

do…while迴圈

 do語句按不同條件執行一次或多次迴圈語句序列。do…while迴圈的測試條件在執行完迴圈後執行，迴圈體至少執行一次，而while迴圈的迴圈體可能一次也不執行。
 do…while迴圈語句的格式：
do{
迴圈體語句序列；
}while（條件表示式）；

• 例：求1-100的和、奇數和、偶數和。

package com.k;
public class Dowhile {
 public static int sum(int n) {
        int sum = 0;
        int i = 1;
        do {
            sum = sum + i;
            i++;
        } while (i <= n);//1-100求和
        return sum;
    }

    public static int sumodd(int n) {
        int sumOdd = 0;
        int i = 1;
        do {
            sumOdd = sumOdd + i;
            i += 2;
        } while (i <= n);//1-100奇數求和
        return  sumOdd;
    }

    public static int sumeven(int n) {
        int sumEven = 0;
        int i = 2;
        do {
            sumEven = sumEven + i;
            i += 2;
        } while (i <= n);//1-100偶數求和
        return  sumEven;
    }
    public static void  main(String[] args) {
        System.out.println(sum(100));
        System.out.println(sumodd(100));
        System.out.println(sumeven(100));
    }
 }
 

5050
2500
2550

for each 語句

 用於迴圈訪問陣列或集合，以獲取所需資訊。基本語句格式：for（變數：資料或集合）{ 迴圈體語句序列；}

跳轉語句

 跳轉語句用於無條件的轉移控制。使用跳轉語句執行分支，該語句會導致立即傳遞程式控制。Java提供了許多立即跳轉到程式中另一行程式碼的語句，包括break、continue、return、throw。Java語言不支援goto語句。

break

 break語句用於結束全部迴圈。

• 例：1+2+3+……n>1000時，輸出m 的值。

package com.k;
public class Dowhile {
public  static  int fun1(){
            int i = 1;
            int tmp = 0;
            for(;tmp <= 1000;i ++){
                tmp += i;
            }
            return i - 1;
        } //只用for迴圈
        public  static  int fun2(){
            int i = 1;
            int tmp = 0;
            for(;;i ++){
                tmp += i;
                if(tmp > 1000){
                    break;
                }
            }  //break 結束迴圈黨tmp大於1000時，返回i的值
            return i;
        }
         public static void  main(String[] args) {
        System.out.println(fun1());
        System.out.println(fun2());
        }
}
 

45
45

continue

 continue語句用於結束本次迴圈。

• 例：求既能被3整除又能被5整除的數字。

package com.k;
public class Dowhile {
ublic static void main(String[] args) {
            System.out.println("1-100之間既能被3整除又能被5整除的數：");
            for (int i = 1; i <= 100; i++) {
              if (i % 15 != 0) {
                  continue;
              }
                System.out.println(i);
          }
      }
 }

1-100之間既能被3整除又能被5整除的數：
15
30
45
60
75
90

return語句

 return語句用於終止方法的執行並將控制返回給呼叫方法。如果方法有返回型別，return語句必須返回這個型別的值。如果方法為void型別，應使用沒有表示式的return語句；如果方法為void型別，方法體最後的return語句可以省略。

陣列（Array）

 陣列是一種資料結構，包含相同型別的一組資料。陣列本身是陣列引用型別物件，陣列元素可以是任何資料型別（簡單型別或引用型別），包括陣列型別。
 陣列有一個“秩（rank）”，確定和每個陣列元素的索引個數，其值是陣列型別的方括號對（[]）的個數。陣列的秩又稱為陣列的維度。“秩”為1的陣列稱為一維陣列，“秩”大於1的陣列稱為多維陣列。維度大小確定的多維陣列通常稱為二維陣列、三維陣列等。
 陣列的每一個維度都有一個關聯的長度（length），它是一個大於或等於0的整數。建立陣列例項時，將確定維度和各維度的長度，它們在該陣列例項的整個生存期內保持不變。換言之，對於一個已存在的陣列例項，既不能更改它的維度，也不能調整它的維度大小。
 Java 語言中提供的陣列是用來儲存固定大小的同類型元素。

陣列的宣告：

 首先必須宣告陣列變數，才能在程式中使用陣列。因為陣列型別為引用型別，陣列變數的宣告只是為陣列例項的引用留出空間。陣列的宣告有以下兩種形式：1.型別[] 陣列變數名； //一般用該種形式； 2. 型別 陣列變數名[];

• 例：

int[] arr1;    //宣告一個整型陣列
byte[] arrByte1;	//宣告一個byte型別陣列  

陣列的例項化（建立）和初始化：

 陣列在聲明後必須例項化才能使用。陣列例項在執行時使用new運算子動態建立（即例項化）。
 new運算子指定陣列例項的長度。new運算子自動將陣列的元素初始化為相應的預設值：簡單數值型別的陣列元素預設值設定為零；char型別陣列元素被初始化為0（\u0000）；boolean型別陣列元素被初始化為false；而引用型別陣列元素的預設值設定為null。使用new運算子建立陣列時，還可以通過{}初始化陣列的元素。

• 例：

int[] arr1;		//宣告陣列
arr1 = new int[10];		//建立一個可以儲存10個整數的陣列(例項化陣列)
int[] arr2 = new int[10];		//同時宣告和建立陣列
arr2 = new int[]{1,2,3,4};		//建立並初始化一個可以儲存5個整數的陣列
int[] arr3 = {1,2,3,4,5};		//宣告並初始化一個儲存4個整數的int陣列（Java編譯器將自動出啊年陣列）
String str[][] = new String[3][4];  //多維陣列

 如果通過{ }初始化陣列的元素，則使用new運算子建立陣列不需要也不能指定陣列元素的個數，Java編譯器將自動推斷出陣列的元素個數。 宣告陣列時，可直接初始化（無需使用new運算子建立陣列），Java編譯器將自動建立陣列（例項化）。

陣列的基本訪問操作

 通過陣列下標（或索引）來訪問陣列中的資料元素。可以使用for each迴圈訪問陣列的各個元素。陣列下標從0開始，具有n個元素（即維度長度為n）的陣列下標是 0~n-1。通過陣列的length屬性，可以獲取陣列的長度。注意：訪問陣列時，如果使用了超過陣列下標範圍的索引，即陣列越界，則會引發ArrayIndexOutOfBoundsException。

• 例：

package kkee;
import java.util.Arrays;
public class NewArray {
    public static void main(String[] args) {
        int[] myList = {9, 2, 4, 5};		//宣告並初始化陣列myList
        // 列印所有陣列元素
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
        }
        // 計算所有元素的總和
        int total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is " + total);
        // 查詢最大元素
        int max = myList[0];
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max)
                max = myList[i];
        }
        System.out.println("Max is " + max);
         Arrays.sort(myList);		//Arrays.sort 陣列排序
        System.out.println(Arrays.toString(myList));
    }
}

9 
2 
4 
5 
Total is 20
Max is 9
[2, 4, 5, 9]

• 例：用陣列列印斐波那契數列的前20項。

package com.k;
import java.util.Arrays;		//匯入Arrays包
public class Array {
    public static void fabonacci(int[] array){ //陣列作為函式的引數
        int i;
        array[0] = 1;
        array[1] = 1;
        for(i = 2;i < array.length; i++){
            array[i] = array[i - 1] + array[i - 2];
        }
    }
    public static void main(String[] args) {
        int[] array = new int[20];
      fabonacci(array);
      System.out.println(Arrays.toString(array));

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

• 例： for each輸出陣列元素:

package kkee;
import java.util.Arrays;
/**
 - @Package: kkee
 - @Author:kkz
 - @Description:
 - @Date:Created in 2018/10/16 17:04
 */
public class Arrayforeach {
    public static void main(String[] args) {
        int[] array1 = new int[]{1,2,3,4,5};
        for(int i = 0;i < array1.length;i++) {
            System.out.print(array1[i] + " " );
        }
        System.out.println();
        for(int i : array1) {
            System.out.println(i);
        }//for each 換行輸出陣列元素
        System.out.println(Arrays.toString(array1));//返回指定陣列的字串形式
    }
}

1 2 3 4 5 
1
2
3
4
5
[1, 2, 3, 4, 5]

• Arrays 類
  java.util.Arrays 類能方便地運算元組，它提供的所有方法都是靜態的。具有以下功能：
  （1）給陣列賦值：通過 fill 方法。
  （2）對陣列排序：通過 sort 方法,按升序。
  （3）比較陣列：通過 equals 方法比較陣列中元素值是否相等。
  （4）查詢陣列元素：通過 binarySearch 方法能對排序好的陣列進行二分查詢
  法操作。
  （5）複製陣列：通過copyOf方法複製陣列，擷取或預設值填充，結果為相同資料型別的長度為指定長度的陣列。
  （6）複製陣列的指定範圍內容：通過copyO分Range方法從起始索引（包括）到結束索引（不包括），結果為相同的資料型別的陣列。
  （7）返回指定陣列內容的字串形式：通過toString方法。

練習

• 1.實現二分查詢演算法：有序的陣列
  pubclic static int binarySearch(int[] array,int key) {} 找到返回下標，沒有找到-1； 陣列名，鍵值

• 二分查詢演算法：
   二分查詢又稱折半查詢，它是一種效率較高的查詢方法。
  折半查詢的演算法思想是將數列按有序化(遞增或遞減)排列，查詢過程中採用跳躍式方式查詢，即先以有序數列的中點位置為比較物件，如果要找的元素值小 於該中點元素，則將待查序列縮小為左半部分，否則為右半部分。通過一次比較，將查詢區間縮小一半。 折半查詢是一種高效的查詢方法。它可以明顯減少比較次數，提高查詢效率。但是，折半查詢的先決條件是查詢表中的資料元素必須有序。
   折半查詢法的優點是比較次數少，查詢速度快，平均效能好;其缺點是要求待查表為有序表，且插入刪除困難。因此，折半查詢方法適用於不經常變動而查詢頻繁的有序列表。
   二分演算法步驟描述
  ① 首先確定整個查詢區間的中間位置 middle;
  ② 用待查關鍵字值與中間位置的關鍵字值進行比較；
  若相等，則查詢成功
  若大於，則在後（右）半個區域繼續進行折半查詢
  若小於，則在前（左）半個區域繼續進行折半查詢
  ③ 對確定的縮小區域再按折半公式，重複上述步驟。
  最後，得到結果：要麼查詢成功， 要麼查詢失敗。折半查詢的儲存結構採用一維陣列存放。

package mypratice;
/**
 * @Package: mypratice
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/16 17:15
 *
 */
public class OrderArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 11, 15, 17};
        int key = 15;		//查詢元素
        System.out.println("所查詢元素在陣列中的下標為：" + binarySearch(arr, key, 0, 10));
    }
    public static int binarySearch(int[] arr, int key,int start,int end) {
        start = 0;
        end = arr.length - 1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (arr[middle] == key) {
                return middle;
            } else if (arr[middle] < key) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        return -1;
    }
}

所查詢元素在陣列中的下標為：9

• 2.求連續子陣列的最大和？
  {10,2，-1,9，-10，-99}最小值：不能超過0x80000000
  從頭到尾遍歷整個陣列，用一個整數記錄子陣列和的最大值，如果子陣列和大於這個值，則更新最大值，如果子陣列和為負，子陣列和清零，然後繼續往後遍歷。考慮陣列全是負數、陣列為空等邊界情況即可。

package mypratice;

/**
 * @Package: mypratice
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/16 22:45
 */
public class ConstantArray {
    public static int SumOfSubArray(int[] array) {
        if (array.length==0 || array==null) {
            return 0;
        }
        int currentSum = 0;     //儲存當前連續n項的和
        int max = 0;            //儲存連續子陣列和的最大值
        for (int i = 0; i < array.length; i++) {
         
            if(currentSum<=0){      //如過當前連續n項的和小於等於0,則沒必要與後面的元素相加
                currentSum = array[i];      //currentSum重新賦值
            }else{
                currentSum += array[i];     //如果currentSum的值大於0,則繼續與後面的元素相加,
            }
            if(currentSum>max){         //每次改變currentSum的值都有與max進行比較
                max = currentSum;       //如果currentSum的值大於max,則將currentSum的值賦值給max
            }
        }
        return max;
    }
    public static void main(String[] args) {
        int[] array = {10,2,-1,9,-10,-99};
        int result = SumOfSubArray(array);
        System.out.println("連續子陣列的最大和為："+result);
    }
}

連續子陣列的最大和為：20

• 3.交換兩個數？

package mypratice;

import java.util.Arrays;

/**
 * @Package: mypratice
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/16 22:24
 */
public class ChangeValue {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int temp = 0; //引入臨時變數，賦初始值為0
        temp = arr[1];  //將arr[1]的值賦給temp   temp = 1
        arr[1] = arr[4];  //將arr[4]的值賦給arr[1]   arr[1] = 5
        arr[4] = temp;  //將temp的值賦給arr[4]    arr[4] = 1
        System.out.println(Arrays.toString(arr));    //返回指定陣列的字串形式
    }
}

[1, 5, 3, 4, 2]

• 4.逆置陣列？{1,2,3,4}===》{4,3,2,1}

package mypratice;
import java.util.Arrays;
/**
 * @Package: com.k
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/14 21:09
 *
 * 逆置陣列？{1,2,3,4}===》{4,3,2,1}
 * 將陣列中的
 */
public class TestArray {
    public static void main(String[] args) {
        int n = 1/2;
        int[] array = {1,2,3,4};//宣告並初始化陣列
        for(int i = 0;i < (array.length)/2; i ++){
            int tmp = array[i];//把陣列中的值賦給臨時變數
            array[i] = array[array.length - i - 1];//將後面的值賦給陣列前面
            array[array.length - i - 1] = tmp;//將臨時變數裡的值賦給後面 即交換陣列前一半與後面的元素
        }
        for(int i = 0;i < array.length; i ++) {}
            System.out.println(Arrays.toString(array));
    }
}

[4, 3, 2, 1]