java數組

數組

到目前爲止，咱們都是使用一個變量就聲明一個變量，可是咱們咱們如今要聲明10個整型變量，那麼咱們是否是須要寫10行代碼呢？雖然咱們能夠在一行代碼中同時聲明多個變量，寫10個也不算什麼，可是若是要聲明50個，或者100個呢！這個時候最好的方法是使用數組組織這些數據了。

1、數組的做用和組織方式

數組是一個能夠保存多個相同類型的變量的順序集合，這些變量在數組中以列表的形式存在，每一個信息都對應的有本身的腳標，編程時能夠經過數據項的腳標很方便的訪問到每一個信息。數組類型在建立時須要指定長度，它是固定長度值存儲一類信息的集合。

數組的組織方式在物理方式和邏輯方式上都是以順序表的方式保存的，也就是說若是有一個由10個整型變量組成的數組，那麼這10個變量都是存儲在相鄰的內存區域中，邏輯上也是相鄰的。

數組a

a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

2、數組的聲明和初始化

要使用數組的第一步固然就是聲明一個數組，和聲明一個變量相似，也須要先寫上數組的類型，數組名稱的命名規範和變量的命名同樣，可是爲了和其餘的變量的聲明相區別，在聲明一個數組是須要使用一對中括號([])。

聲明一個數組能夠這樣：

String unames[];
int uages[];
float scores[];

學過C語言的同窗應該感動很是熟悉了，可是java也可以使用下面這種寫法，把中括號前置，其效果是同樣的。

String []unames;
int []uages;
float[] scores; // 中括號前置仍是後置的聲明是等效的

和聲明變量同樣，咱們也能夠在聲明的同時初始化內容，也能夠聲明數組對象的大小，之後在再進行賦值操做。

由於數據也是對象，因此咱們可使用new運算符來直接構造數組對象，並初始化數組的大小。以下面的示例：聲明數組，而後使用new關鍵字例如：

String unames[];
unames=new unames[50];//能夠先聲明unames數組，再建立數組，指定長度

聲明瞭一個數組名是unames的對象，該對象能夠放10個字符串對象。固然，咱們也能夠在聲明的同時建立數組，以下面這個示例：

String unames[] = newString [50]; 
int[] scores;  = new int [50];

new關鍵字一般的含義是建立對象分配計算機內存空間，當咱們使用new建立數組時，java將會自動給基本數據類型的數組賦予初始值，好比int的數組每一個位置都是0，boolean的數組每一個位置都是true，char的數組每項都是’\0’,若是是對象則給null值。

顯示的賦值。

對數組的建立固然也能夠同時賦值，這樣的語法不使用new關鍵字，被稱做靜態初始化數組。好比咱們聲明一個長度是5的字符串數組:

String unames[] = {「java」, 「oracle」, 「mysql」,「tomcat」, 「jvaScript」};

String unames[] = new unames[]{「java」, 「oracle」, 「mysql」,「tomcat」, 「jvaScript」};

3、數組的訪問和操做

咱們先聲明一個整型變量，並顯示爲其賦值，其代碼以下：

int []a={10,20,30,40,50,60,70,80,90,100};

a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

由上面可知，數組是順序存儲的，並且每個數組都有一個下標表示，注意下標由0做爲起始數，根據上表可知咱們要查找，修改數組裏的某個數組可使用下標來惟必定位一個數。其格式是

數組名[下標]。

好比咱們想打印該數組的第5個數，那麼對數組的訪問可使用數據腳本進行：

System.out.println(a[4]);//注意下標從0開始，第5個，下標對應是4。

另外數組還提供了一個屬性length 能夠得到數組的長度，代碼以下：

System.out.println("數組的長度："+a.length);

那麼若是我要打印數組的所有類型呢?咱們固然不須要寫10行語句，能夠結合咱們上面介紹的循環語句幫幫忙，示例代碼以下：

for(int i=0;i<a.length;i++){
     System.out.println(a[i]);
}

這樣就能夠打印數據的所有類型了，由於數組的下標是以0做爲起點的，所以第一個項應該對應a[0]。在a數組中存儲信息的項的腳標分別是:0,1,2...9，因此咱們就聲明瞭一個整型變量i=0，而後讓i不斷的累加1，而且i不能大於數組的長度。在遍歷數組時，咱們經常會用到這樣的循環。

明白了數組的訪問後，對數組項賦值也就很是簡單了。代碼以下：

a[9] = 1000;// 數組a的第10個項賦值1000

咱們也能夠聲明一個大小爲100的整型數據，併爲其賦值1,2,3...100、其代碼以下

int []a=new int[100];
for(int i=0;i<a.length;i++){
   a[i]=i+1;
}

4、數組的一些示例

在程序中數組使得比較多，爲了加深你們對數組的理解，下面舉幾個簡單的示例說明。例子1：已知一組數據 12 ，34，56，78 。在程序定義以上數組，輸出數組中最大值。其實現代碼以下：

int arr[]={12,34,56,78};
int max=arr[0];
for(int i=1;i<arr.length;i++){
   max=max>arr[i]?max:arr[i];
}
System.out.println(max);

程序開始先定了數組和初始化數據，而後定義了一個max變量，該變量保存每一次比較後的較大值，在比較前先把數組的第一個數賦值給該變量，而後經過循環把max保存的值和數組的值逐個數組的值進行比較，每一次比較都把較大值保存在max變量中，這樣循環結束後，max保存的就是數組裏的最大值了。

例子2：對int arr[]={23,10,39,56,7,8,2,3}從大到小的進行排序,並輸出。（冒泡排序）

int arr[]={23,10,39,56,7,8,2,3};
int max;//中間變量
for(int j=0;j<arr.length;j++){
         boolean flag=true;//是否還有數據須要交換
         for(int i=0;i<arr.length-1-j;i++){
            if(arr[i]>arr[i+1]){
                //每次兩兩比較，若是前一個數比後一個數要，那麼就交換它們的位置
                max=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=max;
                flag=false;//還有數據須要交換
            }
         }
         //若是沒有數據須要交換就能夠退出循環
         if(flag){
            break;
         }
        
         //測試每次結果
         /*for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
         }
         System.out.println();*/
        
} 
//測試最後比較的結果
for(int i=arr.length-1;i>=0;i--){
    System.out.println(arr[i]);
}

這個道題目是使用了冒泡排序的算法，初學者可能比較難理解，有關排序的詳細說明咱們在後面的章節中專門論述，這裏暫不說明了，你們能夠先本身理解代碼。

5、多維數組

上面介紹都是一維數組，由於數組裏的元素都是基本數據類型了，java也能夠表示多維數組，可是在內存的物理組織方式仍是和一維數組同樣的方式保存的，所謂的多維數組的實際就是數組裏面又包含一個數組而已。

多維數組在邏輯上的組織方式在咱們平常生活中很是常見，好比像Excal表格，就是二維表。咱們生活的立體三維世界,使用x、y、z座標可以精肯定位到立體空間所在的位置。在真實世界，多維信息模型很是廣泛。但Java 中沒有真正的多維數組，只有數組的數組，這樣的用法功能上跟多維數組是同樣。

int arr[]={1,2,3};//一維數組
int arr2[][]={{1},{2},{3}};//二維數組
int arr3[][][]={{{1}},{{2}},{{3}}};//三維數組     
三維以上的數組用得比較少，這裏咱們就以二維數組進行學習，先看看下面的示例代碼：
 public static void main(String[] args) {
  //定義二維數組，並賦值
       int arrs[][]={{1,2,3,4},
                     {5,6,7,8},
                     {9,10,11,12}};
      System.out.println("數組的長度："+arrs.length);
      System.out.println("第一行數組的長度"+arrs[0].length);
      System.out.println("訪問第一行第一列的數據："+arrs[0][0]);
      System.out.println("訪問第二行第三列的數據："+arrs[1][2]);
    
      //打印
      for(int i=0;i<arrs.length;i++){
         for(int j=0;j<arrs[i].length;j++){
            System.out.print("i="+i+",j="+j+":");
            System.out.print(arrs[i][j]+",");
         }
         System.out.println();
      }
}

咱們一開始定義了一個二維數組arrs，併爲其賦初值，爲了代碼的可讀性更強，我特地每一維代碼就換一行，這樣咱們的二維數組的邏輯結構與下面的表格相似

物理結構其實就是一維數組arrs裏面的元素又一個一維數組而已，因此咱們能夠打印出數組arrs的長度

System.out.println("數組的長度："+arrs.length);

程序輸出的結果是3，由於一維數組arrs裏面只放了三個元素，只是這三個元素又是一個一維數組。

那麼咱們也能夠從一維數組arrs得到第一個元素（也是一個數組），而後打印該數組的長度：

 System.out.println("第一行數組的長度"+arrs[0].length);

程序輸出爲4，由於該數組只有四個元素，並且是基本元素了。

若是如今我想得到第一個元素，那麼我應該如何訪問呢？你能夠把上面的表格想象成爲進入電影院後找座位。你能夠根據你電影票上面的第幾行和第幾列的信息，找到本身的座位，和現實生活不一樣的地方在於——下標從0開始。因此能夠像下面代碼同樣訪問數組裏面的元素：

System.out.println("訪問第一行第一列的數據："+arrs[0][0]);
 System.out.println("訪問第二行第三列的數據："+arrs[1][2]);

「arrs[0][0]」爲何這樣能夠訪問第一行第一列的數據，其實arrs[0]就是得到第一行的元素，也就是第一維的數組，arrs[0][0]固然也就是第一行第一列的數據了。從這個例子總咱們能夠理解「數組的數組」的含義，同理去理解三維及更多維度的數組。

接下來咱們還把該數組的全部的數組所有打印出來，使用了二重循環，它的運行過程其實就是先得到第一行的數組，而後把第一行的數組經過循環數組打印處理，外層循環在移動到第二行的數組，依次類推，就打印了所有的數組。

//打印
for(int i=0;i<arrs.length;i++){
   for(int j=0;j<arrs[i].length;j++){
        System.out.print("i="+i+",j="+j+":");
        System.out.print(arrs[i][j]+",");
    }
   System.out.println();
}