java編寫圖形界面程序「java創建數組的幾種方式」

數組是具有相同數據類型的一組數據的集合，作為對象允許使用new關鍵字進行內存分配。首先先來熟悉一下一維數組的創建和使用。

聲明一維數組，有下列兩種方式：

數組元素類型 數組名字[];

數組元素類型[] 數組名字；

數組元素類型據定了數組的數據類型，它可以是java中任意的數據類型，聲明一維數組，如：int arr[]; String str[]; int arr[]是聲明int型數組，數組中的每個元素都是int型數值，同理，str[]數組中的每個元素都是String類型。

註：Java語言中聲明數組時不能指定其長度（數組中元素的個數），這是因為數組是一種引用類型的變量，因此使用它定義一個變量時，僅僅表示定義了一個引用變量（也就是定一個了一個指針），這個引用變量還未指向任何有效的內存，所以定義數組時不能指定數組的長度。而且由於定義數組僅僅只是定一個引用變量，並未指向任何有效的內存空間，所以還沒有內存空間來存儲數組元素，因此這個數組也不能使用，只有在數組進行初始化後才可以使用。

為數組分配內存空間的語法格式如下：

數組名字=new 數組元素的類型[數組元素的個數]；

例如，arr=new int[5];也可以在聲明數組的同時為數組分配內存，例如：int arr[]=new int[5];

附:一旦使用new關鍵字為數組分配了內存空間，每個內存空間存儲的內容就是數組元素的值，也就是數組元素就有了初始值，即使這個內存空間存儲的內容是空，這個空也是一個值null。也就是說不可能只分配內容空間而不賦初始值，即使自己在創建數組對象（分配內容空間）時沒有指定初始值，系統也會自動為其分配。

附：諸如基礎數據類型的包裝類，其默認的初始化值均為null，因為基礎數據類型的包裝類創建的數組屬於引用數組（對象數組），對象數組默認的初始化值都是null。

理解了一維數組的聲明和創建，二維數組的聲明和創建大同小異。二維數組的聲明，int arr[][]；二維數組常用於表示表，第一個下標表示行，第二個下標表示列。直接為二維數組分配內存，方法如下：a=new int[2][4];

為數組分配內存之後，就要學習如何初始化數組了。一維數組的初始化形式有兩種：

int arr[]=new int[]{1,2,3,4};

或 int arr[]={1,2,3,4};

二維數組的初始化方法： int myarr[][]={{12,2},{43,45}}; 注意，寫成intmyarr[][]={12,2,43,45}是錯誤的。

接下來，通過兩段小的代碼來解釋如何使用一維數組和二維數組。

第一個例子是使用一維數組將1~12月各月的天數輸出。代碼如下：

public class shuZu{
 public static void main(String[] args){
   int day[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
   for (int i=0;i<12;i++){
     System.out.println((i+1)+"月有"+ day[i]+"天");
     }    
   }
 }

第二個例子是使用二維數組將數組中的元素輸出。代碼如下：

public class shuZu{
public static void main(String args[]){
 int arr[][]=new int[][]{{1},{2,3},{4,5,6}};
 for(int i=0;i<arr.length;i++){
   for(int j=0;j<arr[i].length;j++){
     System.out.print(arr[i][j]);
     }
     System.out.println();
   }
 }
 }

簡單介紹了一下數組的基本內容，接下來講解一下經典的數組冒泡排序算法。

冒泡排序原理：相鄰的兩位數做比較，1和2比較 2和3比較 3和4比較 4和5比較，這樣依次比較，如果前面的數小於後面的，不做操作，如果前面的數大於後面的數則調換兩個數字的位置，列1>2 則數字順序為2 1(註：此時的1 2 3 4 5代表索引而不是數組)，所以一層循環能挑出一個當前數組參與比較數字中的最大的數字，並將其排到數組的最末尾。
但是一層循環根本不夠用，只能挑選出一個最大數，數組中其他的數字還沒有正確排序。
這裡遵循一個原理就是數組裡面有length個數字，要進行length-1次循環。至於為什麼要this.length-i，是因為第一次比較7個數字，第二個只要比較前6個就行了，第7個肯定是最大的了。這裡要着重強調為什麼會有2個for循環，為什麼要用this.length-i。

下面用一個例子來做詳細的說明：

var array = [8,7,9,2,3,5,6,1]; 
var temp = 0; 
function sort(arr){
    for (var i = 0; i < arr.length; i++){
     //這裡的i控制循環比較的次數
       for (var j = 0; j < arr.length - i; j++){
      //這裡的j控制參與比較的數字個數，因為每比較一次都會產生一個最大的數字，
      //那麼下次比較的時候就沒必要參與比較了，所以每比較一次都會減少一個數字
          if (arr[j] > arr[j + 1]){
               temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;      
           }
    }
  }
 } 
console.log('before: ' + array);
//輸出[8,7,9,2,3,5,6,1] 
sort(array); 
console.log(' after: ' + array);
//輸出[1,2,3,5,6,7,8,9]

var array = [8,7,9,2,3,5,6,1]; 
var temp = 0; 
function sort(arr){
    for (var i = 0; i < arr.length; i++){
     //這裡的i控制循環比較的次數
       for (var j = 0; j < arr.length - i; j++){
      //這裡的j控制參與比較的數字個數，因為每比較一次都會產生一個最大的數字，
      //那麼下次比較的時候就沒必要參與比較了，所以每比較一次都會減少一個數字
          if (arr[j] > arr[j + 1]){
               temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;      
           }
    }
  }
 } 
console.log('before: ' + array);
//輸出[8,7,9,2,3,5,6,1] 
sort(array); 
console.log(' after: ' + array);
//輸出[1,2,3,5,6,7,8,9]

var array = [8,7,9,2,3,5,6,1]; 
var temp = 0; 
function sort(arr){
    for (var i = 0; i < arr.length; i++){
     //這裡的i控制循環比較的次數
       for (var j = 0; j < arr.length - i; j++){
      //這裡的j控制參與比較的數字個數，因為每比較一次都會產生一個最大的數字，
      //那麼下次比較的時候就沒必要參與比較了，所以每比較一次都會減少一個數字
          if (arr[j] > arr[j + 1]){
               temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;      
           }
    }
  }
 } 
console.log('before: ' + array);
//輸出[8,7,9,2,3,5,6,1] 
sort(array); 
console.log(' after: ' + array);
//輸出[1,2,3,5,6,7,8,9]