陣列：

陣列Array即一組資料模式用來記錄多個型別相同的資料

特點：

　　1.陣列長度不可變

　　2.陣列可儲存基本型別，也可以儲存引用型別

　　3.陣列在記憶體中是連續儲存資料的

　　4.陣列通過索引（下標）對連續資料進行訪問的

如何實現陣列元素的刪除：

　　1.判斷待刪除的元素是否在陣列中

　　2.將刪除元素的最後一位依次向前移動

　　3.最後位元素不進行列印

如何實現陣列元素的新增（陣列值必須連續遞增）：

　　1.查詢要新增元素在陣列中的位置

　　2.該位置為第一次比新增值大的元素索引

　　3.從陣列最後位開始向前依次交換元素

　　4.將新增值寫入查詢位置

如何查詢最大值：

　　1.設定一個元素為最大值

　　2.依次將每個元素與最大值進行比較

　　3.比最大值更大的元素將成為新的最大值

常用的排序演算法：

　　1.氣泡排序法（最大值在最後）

　　　　1）將相鄰元素依次比較，如果後一個較小則交換位置

　　　　2）通過一輪比較（陣列中每個元素都比較依次），陣列中的最大值將產生在最後

　　　　3）已經產生的最大值不再參與比較，開啟下一輪比較

　　　　4）每輪都產生一個最大值

　　　　5）直至只有一個元素時結束排序

　　2.選擇排序法

　　　　1）將第一個數作為最小值依次和後面的每個元素進行比較

　　　　2）如果後面的元素比第一個元素小，則交換兩數

　　　　3）一輪比較後，第一個元素即為最小值

　　　　4）第二輪比較從第二個元素開始，依次和後面的每個元素分別比較，比較過後產生第二個最小值在第二位

　　3.快速排序法（二分排序法）：

　　　　1）將第一個數定位基準數：1）j負責從右往左查詢比基準數（第一個數）小的數

　　　　　　　　　　　　　　　　　2）i負責從左往右查詢比基準數（第一個數）大的數

　　　　2）若i和j沒有碰頭，且都找到了，則將兩數array[ i ]和array[ j ] 交換，這樣左邊的就是小的，右邊的就是大的

　　　　3）知道 i 和 j 相遇，則此處即為基準數應該在的地方，將array[ left ]與array[ i ]交換

　　　　4）第一輪結束後，則在基準數位置即i與j相遇處將陣列一分為二

　　　　5）重新呼叫遞迴該方法，左右邊界重新賦值

建立陣列（三種方式）：

/************方式一*********/
String[] array=new String[5];
System.out.println(array[0]);
int[] Array=new int[5];
System.out.println(Array[1]);


/************方式二*********/
String[] array1=new String[]{"tom","jack","jerry"};
//訪問第二個數值
System.out.println(array1[1]);
//訪問第一個數值
System.out.println(array1[0]);
//訪問倒數第二個數值
System.out.println(array1[array1.length-1]);


/************方式三*********/
String[] array2={"tom","jack","jerry"};
for(int i=0;i<array2.length;i++){
    System.out.println(array2[i]);
}

檢索資料是否在陣列中（沒有找到返回-1，找到返回下標）：

 public int find(String[] array,String value){
        //預設返回-1
        int index=-1;
        //遍歷陣列
        for(int i=0;i<array.length;i++){
            //如果有相同的數值
            if(array[i].equals(value)){
                //返回下標
                index=i;
                break;
            }
        }
        return index;
    }

刪除陣列中元素的方法：

　　方法一：將元素賦值為null：列印時判斷是否為null，不為null則打印出來

public void delete(String[] array,String value){
        //查詢是否存在的方法，如果存在返回下標，如果不存在返回-1
        int index=find(array,value);
        //判斷值是否在陣列中存在
        if(index!=-1){
            //如果存在則賦值為null
            array[index]=null;
        }
    }    

　　方法二：向前賦值法：列印時不列印最後一位

 public void delete2(String[] array,String value){
        //陣列中是否存在該值的方法，不存在返回-1，存在返回下標
        int index=find(array,value);
        if(index!=-1){
            //迴圈遍歷
            for(int i=index;i<array.length;i++){
                //從查詢為null的位置開始，從後向前覆蓋
                array[i]=array[i+1];
            }
        }
 }

陣列中的最大值

  public int findMax(int[] array){
      //先確定一個最大值，確定為第一個最方便
      int max=array[0];
      //從第二個開始比較
      for(int i=1;i<array.length;i++){
          //如果數值大於指定的最大值，將值賦值給最大值
          if(array[i]>max){
              max=array[i];
          }
      }
      return max;
  }

氣泡排序法：

public void sort(int[] array){
　　//外層迴圈控制比較的輪數
　　//最後一次只剩一個時不用再比較
　　for(int i=0;i<array.length-1;i++){
　　　　//內層迴圈控制每輪要比較的次數
　　　　//迴圈了多少論，下一輪就少比較多少次（每一輪都多出一個不再參與比較的數）
　　　　for(int i=0;j<array.length-1-i;j++){
　　　　　　//如果後一位更大，將大的數換到最後
　　　　　　if(array[j+1]<array[j]){
　　　　　　　　//交換兩數
　　　　　　　　int temp=array[j+1];
　　　　　　　　array[j+1]=array[j];
　　　　　　　　array[j]=temp;
　　　　　　}
　　　　}
　　}
}

選擇排序法：

　　整個排序方法和氣泡排序方式基本一致，只是冒泡比較的基數在改變

public void sort(int[] array){
　　//外層迴圈控制輪數
　　for(int i=0;i<array.length;i++){
　　　　//內層迴圈控制每一次比較的輪數，將i索引的元素依次和後面的每個元素進行比較
　　　　for(int j=i+1;j<array.length;j++){
　　　　　　//升序：如果前一位更小，則將大的往後交換
　　　　　　if(array[i]>array[j]){
　　　　　　　　int temp=array[j];
　　　　　　　　array[j]=array[i];
　　　　　　　　array[i]=temp;
　　　　　　}
　　　　}
　　}
}

快速排序法（二分排序法）：

public void sort(int[] array,int left,int right){
　　//判斷是否需要繼續遞迴
　　if(left==right){
　　　　teturn;
　　}
　　//定義基準值
　　int middle=array[left];
　　//i是左邊界
　　int i=left;
　　//j是右邊界
　　int j=right;
　　//當i!=j時，則繼續迴圈
　　while(i!=j){
　　　　//進入迴圈後，j從右往左，不能走過i，若j對應的位置大於基準值，則繼續向左前進
　　　　while(array[j]>=middle&&i>i){
　　　　　　j--;
　　　　}
　　　　//進入迴圈後，i從左往右，不能走過j，若i對應的位置小於基準值，則繼續向右前進
　　　　while(array[i]<=middle&&i<j){
　　　　　　i++;
　　　　}
　　　　//當i與j停下來且i!=j時，i與j沒相遇則將兩個數交換，則左邊小，右邊大
　　　　int temp=array[i]；
　　　　array[i]=array[j];
　　　　array[j]=temp;
　　}
　　//當i與j停下來且i=j時，則將該位置與基準值相交換
　　array[left]=array[i];
　　array[i]=middle;
　　//將原陣列分兩段繼續遞迴
　　sort(array,left,i-1);
　　sort(array,i+1,right);
}

實現陣列元素的插入（陣列的原始資料需要連續遞增）