迴圈語句的理解

1. do while 語句和while語句的區別：

while語句在進入迴圈體之前要先判斷條件是否成立，如果成立的話則進入迴圈體。
而do…while語句則是先執行迴圈體，然後再判斷條件是否成立，如果成立的話則繼續迴圈體，如果不成立則跳出迴圈；
也就是說do-while迴圈至少要執行一次迴圈語句。

2.break和continue的區別：

break和continue都是用來控制迴圈結構的，主要是停止迴圈。
1.break
有時候我們想在某種條件出現的時候終止迴圈而不是等到迴圈條件為false才終止。
這是我們可以使用break來完成。break用於完全結束一個迴圈，跳出迴圈體執行迴圈後面的語句。
2.continue
continue和break有點類似，區別在於continue只是終止本次迴圈，接著還執行後面的迴圈，break則完全終止迴圈。
可以理解為continue是跳過當次迴圈，執行下一次迴圈。

陣列

建立一個一維陣列有很多種寫法：

1. int[] array1 = {1,2,3,4,5};
   

2. int[] array2 = new int[5];
   

3. int[] array3 = new int[] {1,2,3,4,5};
   

陣列引用之間的賦值

 public static void main(String[] args) {
   int[] array = {1,2,3,4,5};
        int[] array2 = array;
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array2));
        array[0] = 6;
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array2));
 }
 

輸出結果為：

我們都知道通過array[0]=6; 修改的是array的中0下標的元素的值，但是
第二次輸出的array2的0元素的值也為 6；
因為 int[] array2 = array; 這個賦值語句，其實是運算元棧中array2指向了堆疊中的array的地址，修改array中的元素的值，但是其地址沒有變化，在輸出array2的時候，array2還是先去找那個地址，然後再去訪問地址所對應的資料，所以修改了array的值，array2的值也同樣跟著改變。

練習題：

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

public static void main(String[] args) {
  　　int[] array=new int[]{1,2,3,4,5,6,7,8,9,10};
      System.out.println(binnary(array,6));
    　 ｝
 public static int binnary(int[] array,int key){
        int a=0;
        int b=array.length-1;
        int middie=(a+b)/2;
        if(key<array[a]||key>array[b]) {
            return -1;
        }
        while(a<=b){
            if(array[middie]==key){
                return middie;
            }else{
                if(array[middie]>key){
                    b=middie-1;
                }
                else{
                    a=middie+1;
                }
            }
            }
        return -1;
    }
 

2.求一個數組的連續子陣列的最大和（最好輸出最大的子陣列）？

public static void main(String[] args) {
     int[] array=new int[]{-1,2,5,-8,4,10};
    　maxArray(array);
        ｝
 public static void maxArray(int[] array){
        int sum=array[0];
        int max=array[0];
        int s1=0;
        int start=0;
        int end=0;
        for(int i=1;i<array.length;i++) {
                if (sum >0) {
                    sum = sum + array[i];

                } else {
                    sum = array[i];
                    s1 = i;
                }
                if (sum >= max) {
                    max = sum;
                    start = s1;
                    end = i;
                }
        }
            int[] array2=new int[end-start+1];
        for(int i=start;i<=end;i++){
            array2[i-start]=array[i];
        }
            System.out.println(max);
            System.out.println(Arrays.toString(array2));
    }

3.交換兩個數？

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

4.逆置陣列？

public static void main(String[] args) {
 　　 int[] array=new int[]{1,2,3,4,5,6} ;
  　　change(array);
        ｝
 public static void change(int[] array) {
        int a=0,b=array.length-1;
        while (a<b){
            int c=0;
            c=array[a];
            array[a]=array[b];
            array[b]=c;
            a++;
            b--;
        }
        System.out.println(Arrays.toString(array));
    }