一、while迴圈和do…while迴圈

whlie(條件語句) {
	迴圈體
}//先進行條件語句的判斷，再進行迴圈體

do {
	迴圈體
}whlie （條件語句）//先執行一次迴圈後再進行條件語句的判斷

二、break語句和continue語句

1.break語句：結束全部迴圈,具體應用如下：

//1+2+3+...+n<1000,求n
//此題可以利用break語句在和大於1000時結束迴圈，輸出n的值
public static void deal() {
        int sum = 0;
        int i = 1;
        for (; ; i++
 
) {
            sum = sum + i;
            if (sum > 1000) {
                break;//當和大於1000時，利用break語句跳出迴圈
            }
        }
        System.out.println(i);
    }

2.continue語句：結束本次迴圈,具體應用如下：

//求100以內即能被3整除又能被5整除的數
//利用continue語句在判斷到該數時，結束本次迴圈並輸出該數
public static void deal1(int n) {
        for (int i =
 
 1; i <= n; i++) {
            if (i % 15 != 0) {
                continue;//如果該數不能被3和5整除，結束此次迴圈，進行下次迴圈
            }
            System.out.println(i);
        }
    }

三、一維陣列

1.一維陣列的定義方式：

int[] array1 = new int[3];//宣告建立一個包含3個元素的陣列array1(初始值為0)

int[] array2 = {1, 2, 3};//宣告、建立並初始化一個包含3個元素的陣列

int
 
[] array3 = new int[] {1, 2, 3};//宣告、建立並初始化一個包含3個元素的整型陣列

int[] array4;
array[4] = {1, 2, 3}//先宣告一個數組array，再進行建立及初始化

int[] array5 = new int[3];
array5[0] = 1;
array5[1] = 2;
array5[2] = 3;//先宣告、建立一個具有3個元素的陣列，再用賦值語句進行初始化

2.利用一維陣列輸出斐波那契數列的前20項

public static void fib(int[] array) {
        array[0] = 1;
        array[1] = 1;
        for (int i = 2; i < array.length; i++) {
            array[i] = array[i - 1] + array[i - 2];
        }
        System.out.println(Arrays.toString(array));
}//記得在主函式中建立array陣列

四、題目練習

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

public class TestDemo1 {
    public static int binary(int[] array, int key) {//key為要查詢的數
        Arrays.sort(array);//正序排列陣列
        System.out.println("由從小到大順序排列陣列：" + Arrays.toString(array));
        int left = 0;
        int right = array.length - 1;//將陣列最小下標與最大下標分別賦值給left和right
        int mid = 0;//將中值初始化
        while (left <= right) {//“=”條件防止當輸入的值為陣列最大下標指向的數時，不進入迴圈，而返回-1的情況
            mid = (left + right) / 2;//二分法原理為折半查詢，故中間值為左右下標之和除以2
            if (key == array[mid]) {//如果第一次中間下標指向的值正好等於要查詢的值，返回該下標
                return mid;
            } else if (key > array[mid]) {//如果如果輸入的值大於中間下標指向的值，則將當前中值下標作為下一次迴圈的左下標
                left = mid + 1;/*“+1”的含義：防止輸入的值為陣列最大下標指向的值，當進行二分查詢最後一步時，因為mid為int型別，所以會導
                致左邊下標不在發生變化，所以要+1；當+1時，左邊下標變為上一次中值下標的後一位，不影響此方法的正確性，還可以減少計算步驟*/
            } else {//只剩下輸入的數下標小於中值下標的情況，將當前中值下標作為下次迴圈的右下標
                right = mid - 1;//與“+1”含義類似，防止輸入的數對應的為最右下標
            }
        }
        return -1;//在陣列中找不到輸入的數，返回-1
    }
    
    public static void main(String[] args) {
        int[] array = {22, 15, -46, 35, 69, 20};
        System.out.println("請輸入你想查詢的數字：");
        Scanner scanner = new Scanner(System.in);
        int key = scanner.nextInt();
        System.out.println(binary(array, key));
     
    }
}

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

public class TestDemo1 {
public static void sumArray(int[] array) {
        int sum = array[0];//對陣列求和的變數
        int max = array[0];//求和最大值的變數
        for (int i = 1; i < array.length; i++) {//從第一項開始迴圈
            if (sum + array[i] < array[i]) {//如果前幾項的和與本項之和小於本項，則最大連續子陣列的和肯定不包括前幾項
                sum = array[i];//將本項的值賦給sum，之後的迴圈求和從本項依次向後相加
            } else {
                sum = sum + array[i];//如果前幾項的和與本項之和大於本項，則繼續向後執行遞加操作
            }
            if (sum >= max) {//每次相加之後與初始的max值相比較，如果和大於max的值，則更新max,最後返回的max值即為最大連續子數列的和
                max = sum;
            }
        }
        System.out.println("連續子陣列最大和為：" + max);
    }
     public static void main(String[] args) {
        int[] array = {1, -2, 3, 10, -4, 7, 2, -5};
        sumArray(array);
            }
}

3.交換兩個數

public class TestDemo1 {

	public static void swap(int a,int b) {
		int tmp = 0;
		tmp = a;
		a = b;
		b = tmp;        
}
    
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		swap(a,b);
		System.out.println(a);
		System.out.println(b);   
    }
}

用上面寫的方法在執行交換兩個數運算元會出現錯誤，原因：
在主函式中swap(a,b)操作實際是將實參a,b的地址拷貝到swap方法中，即傳址。在swap方法中進行數值交換操作時只是交換了該方法中形參的地址，而原本實參的地址並沒有改變，所以輸出的a,b值沒有發生改變。

Java中的基本元素不支援傳址，必須是物件或者陣列才能傳址
可作如下修改：

class MyVlue {
    int data;
}
public class TestDemo1 {
    public static void swap(MyVlue myVlue,MyVlue myVlue2) {
        int tmp = myVlue.data;
        myVlue.data = myVlue2.data;
        myVlue2.data = tmp;
    }       
    public static void main(String[] args) {      
        MyVlue myVlue = new MyVlue();
        myVlue.data = 10;
        MyVlue myVlue2 = new MyVlue();
        myVlue2.data = 20;
        swap(myVlue,myVlue2);
        System.out.println(myVlue.data);
        System.out.println(myVlue2.data);        
    }
}
//新建物件進行數值的交換，交換的是實參

4.逆置陣列

public class TestDemo1 { 
    public static void invertArray(int[] array) {
        System.out.println("輸出該陣列：" + Arrays.toString(array));
        for (int front = 0, end = array.length - 1; front < end; front++, end--) {//迴圈將陣列下標由第一項遞增，最後一項遞減，當遞增的下標超過遞減的下標時，結束迴圈
            int temp = array[front];//將陣列的第一個元素臨時賦值給變數temp
            array[front] = array[end];//將陣列最後的元素賦值到陣列的第一個元素
            array[end] = temp;//將temp的值賦給陣列最後的元素，實現陣列下標不變，但元素的值進行倒置的操作
        }
        System.out.println("將該陣列倒置後輸出：" + Arrays.toString(array));
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        invertArray(array);
    }
}