陣列：陣列是相同型別資料的有序集合。陣列描述的是相同型別的若干個資料，按照一定的先後次序順序排列組合而成。其中，每一個數據作一個元素，每個元素可以通過一個索引（下標）來訪問他們。

陣列變數屬引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變數

陣列基本特點：

1.長度是確定的。陣列一旦被建立，它的大小就是不可以改變的。

2.其元素必須是相同型別，不允許出現混合型別。

3.陣列型別可以是任何資料型別，包括基本型別和引用型別

陣列的宣告方式

type[] arr_name;//推薦使用方式
type   arr_name[];

定義陣列，給陣列賦值，當給建立陣列時，棧記憶體中有變數，堆記憶體什麼都沒有，當給陣列分配空間10以後，才會在堆記憶體中給陣列真的分配空間。

注意：陣列長度為0與null不相同

建立引用型別的一維陣列

陣列的初始化方式分為三種：靜態初始化，動態初始化，預設初始化

//靜態初始化
int[] a={1,2,3,4,5,6,7,8,9,11,12,32,43,,54,34,35};

陣列預設初始化與成員變數預設初始化相同

陣列遍歷

增強for迴圈：for-each是JDK1.5新增的功能，專門用於讀取陣列或集合中所有元素，即對陣列進行遍歷。但是不能修改陣列或集合中元素的值

ss代表要遍歷的陣列，temp時一箇中間臨時變數。

增強for迴圈不能遍歷二維陣列，要想訪問多維陣列的所有元素，就要用到巢狀。

二維陣列

public class Test01{

    public static void main(String[] args){
        //靜態初始化
        int[][] a={
        
            {1,2},
            {3,4,0,9},
            {5,6,7}    
        }
        //動態初始化
         int[][] a=new int[3][];
         a[0]=new int[2];
         a[1]=new int[4];
         a[1]=new int[3];
         a[0][0]=new int[1]; 
         a[0][1]=new int[2];
  
         a[1][0]=new int[3];  
         a[1][1]=new int[4];  
         a[1][2]=new int[0];  
         a[1][3]=new int[9];
  
         a[2][0]=new int[5];  
         a[2][1]=new int[6];  
         a[2][2]=new int[7];  
  
    }
}
 

二維陣列的記憶體分析

二維陣列例子：矩陣的運算

public class Materix{

    public static void main(String[] args){
        
        int[][] a={
            {1,2},{2,4}
        };
        
        int[][] a={
            {3,4},{5,6}
        };
        
        int[][] c=new int[2][2];
        for(int i=0;i<c.length;i++){
            for(int j=0j<c.length;j++){
                c[i][j]=a[i][j]+b[i][j]
            }
        }
        
    }
}
 

實際上java中沒有多維陣列，只有一維陣列，因為多維陣列被解釋為“陣列的陣列”，而這也正是java的一個優勢所在。

在java.util.Arrays類下有很多對陣列操作的方法，具體請看java的API,裡面會有對方法使用的詳細解釋。

陣列的拷貝，用System類中的arratcopy方法，java.util.Arrays包含了運算元組的各種方法，比如搜尋、排序，aList方法用於將陣列轉換成集合。

Arrays.sort(a)陣列的排序，Arrays.toString(a)列印陣列   陣列的填充  Arrays.file(a,2,4,100);將2到4索引的元素替換為100

二分查詢法 

//二分法查詢的前提是：陣列的順序必須是已經排好的
public class TestBinarySearch{
    public static void main(String[] args){

        System.out.println(args[1]);
        int[] arr={234,245,77,3,543,67,78,95,378,205,369,703,251}
        int searchWord=6780;//所要查詢的數
        int searchCount=0;//迴圈的次數

        System.out.println("普通迴圈查詢%d的次數是%d"，searchWord,genetalLoop(arr,searchWord));
 System.out.println("二分法查詢%d的次數是%d"，searchWord,binarySearch(arr,searchWord));

        static int genetalLoop(int[] arr,int searchWord){
            // 普通迴圈發，最好需要比較一次，比如查詢1；
            int searchCount=0; 
        for(int 1=0;i<arr.length;i++){
                
                searchCount++;
                if(searchWord==arr[i])
                break;
            }
          return searchCount;
        }
    }

    static int binarySearch(int[] arr,int searchWord){

        Arrays,sort(arr);//首先對傳進來的陣列進行排序
        //二分查詢法
        int index=0;//相當於指標的東西
        int iStart=0;
        int iEnd=arr.length;
        int searchCount=0;
        for(int i=0;i<arr.length/2;i++){
            searchCount++;
            index=(iStart+iEnd)/2;
            if(arr[index]<searchWord){
                iStart=index;
            }else if (arr[index]>searchWord){
                iEnd=index
            }else{break;}
        }
      return searchCount;
    }


}

氣泡排序法

public class Test{

        public static void main(String[] args){

        int[] values={2,1,0,5,9,7,6,3,15,21};
        sort(values);
    System.out.println(Arrays.toString(values));
    }

    public static void sort(int[] values){
        int temp;
        for(int i=0;i<values.length;i++){
            for(int j=0;j<values.length-1-i;j++){
                if(values[j]>values[j+1]){
                temp=values[j];
                values[j]=values[j+1];
                values[j+1]=temp;
                }
            }
        }
    }
}

//從小到到達排序，會先將最大的找出來，放到最後；從大到小排列，會先將最小的找出來放放到最後
//第一次完全把陣列遍歷一次，把最小的找出來了，再遍歷一次會把比最小的大一個的數找出來，以此類推。

轉載請註明出處！