5.4 數組的綜合實例

【實例5.6】設計一個程序，有兩個整型數組：a[]和b[]。a數組中有5個元素，b數組中有5個元素。現在要求：

（1）分別輸出兩個數組中的各個元素及其長度。

（2）有一個數組c，它的元素就是a數組和b數組中一一對應的元素的乘積，并且輸出其長度。

（3）有一個數組d，它的元素是前面三個數組中一一對應的元素滿足的表達式：a[i]*c[i]-b[i]。

分析與編寫：

要輸出各個元素及長度。這個程序在前面也遇到過，具體程序段如下所示。

01   public class arrary6
02   {
03         public static void main(String[] args)
04         {
05              int[] a=new int[]{2，4，6，8，10};
06              for(int i=0;i<a.length;i++)
07              {
08                   System.out.println("a["+i+"]="+a[i]);
09              }
10              System.out.println("數組a的長度是："+a.length);
11         }
12   }

【代碼說明】第5行初始化數組，第6～9行通過循環輸出數組中的元素。

【運行效果】

a[0]=2;
a[1]=4
a[2]=6
a[3]=8
a[4]=10;
數組a的長度是：5

輸出另一個數組的程序代碼如下。

01   public class arrary7
02   {
03         public static void main(String[] args)
04         {
05              int[] b=new int[]{1，3，5，7，9};
06              for(int i=0;i<b.length;i++)
07              {
08                   System.out.println("b["+i+"]="+b[i]);
09              }
10              System.out.println("數組b的長度是："+b.length);
11         }
12   }

【代碼說明】第5行初始化數組b，第6～9行輸出數組中各個元素。

【運行效果】

b[0]=1
b[1]=3
b[2]=5
b[3]=7
b[4]=9
數組b的長度是：5

在第二個要求里，必須要創建一個新的數組c，接著就是操作前兩個數組的元素。這個要求內的程序段在前面的小節內已經詳細舉過例子，下面看程序段。

01   public class arrary8
02   {
03         public static void main(String[] args)
04         {
05              int[] a=new int[]{2，4，6，8，10};
06              int[] b=new int[]{1，3，5，7，9};
07              int[] c=new int[5];
08              for(int i=0;i<a.length;i++)
09              {
10                   c[i]=a[i]＊b[i];
11              }
12              for(int j=0;j<a.length;j++)
13              {
14                   System.out.println("c["+j+"]="+(a[j]＊b[j]));
15              }
16              System.out.println("數組c的長度是："+c.length);
17         }
18   }

【代碼說明】

第5～7行創建了3個數組，其中數組a和b創建時有默認值，數組c沒有默認值。

第8～11行設置數組c的值，然后第12～15行輸出數組c。

【運行效果】

c[0]=2;
c[1]=12
c[2]=30
c[3]=56
c[4]=90;
數組c的長度是：5

這個程序是一個數組內部各個對應的元素的操作，這在前面已經舉過例子，此處不再詳細描述。

第三個要求比起前兩個，稍微復雜了點，但是可以通過分析，來編寫程序段。先看下面的程序，然后再來分析。

01   public class arrary9
02   {
03         public static void main(String[] args)
04         {
05              int[] a=new int[]{2，4，6，8，10};
06              int[] b=new int[]{1，3，5，7，9};
07              for(int i=0;i<b.length;i++)
08              {
09                   System.out.println("d["+i+"]="+(a[i]＊a[i]＊b[i]-b[i]));
10              }
11         }
12   }

【代碼說明】讀者在代碼中沒有看到數組c，因為本身數組c就是數組a和數組b中元素相乘的結果，所以第9行代碼中用a[i]*b[i]代替數組c。

【運行效果】

d[0]=3
d[1]=45
d[2]=175
d[3]=441
d[4]=891

整個程序段其實與上一個程序段相似，只不過表達式比上一例稍微復雜。

上面三個程序段其實可以用一個程序段來表示，這就涉及面向對象編程的理念。代碼如下所示。

01   public class arrary10
02   {
03         int[] a=new int[]{2，4，6，8，10};
04         int[] b=new int[]{1，3，5，7，9};
05         public static void main(String[] args)
06         {
07              arrary10 w=new arrary10();
08              w.print1();
09              w.print2();
10              w.print3();
11              w.print4();
12         }
13         void print1()
14         {
15              for(int i=0;i<b.length;i++)
16              {
17                   System.out.println("b["+i+"]="+b[i]);
18              }
19              System.out.println("數組b的長度是："+b.length);
20         }
21         void print2()
22         {
23               for(int i=0;i<a.length;i++)
24               {
25                   System.out.println("a["+i+"]="+a[i]);
26         }
27              System.out.println("數組a的長度是："+a.length);
28         }
29         void print3()
30         {
31              for(int i=0;i<b.length;i++)
32              {
33                     System.out.println("c["+i+"]="+(b[i]＊a[i]));
34              }
35              System.out.println("數組c的長度是："+b.length);//因為數組c和b相同，可以用b.length
36         }
37         void print4()
38         {
39              for(int i=0;i<b.length;i++)
40              {
41                   System.out.println("d["+i+"]="+(a[i]＊a[i]＊b[i]-b[i]));
42              }
43         }
44   }

【代碼說明】第35行在獲取數組c的長度時，使用了b.length，因為數組c和數組b其實一樣長，這里簡化了代碼，直接輸出數組b的長度，同樣也是數組c的長度。

【運行效果】

b[0]=1
b[1]=3
b[2]=5
b[3]=7
b[4]=9
數組b的長度是：5
a[0]=2
a[1]=4
a[2]=6
a[3]=8
a[4]=10
數組a的長度是：5
c[0]=2
c[1]=12
c[2]=30
c[3]=56
c[4]=90
數組c的長度是：5
d[0]=3
d[1]=45
d[2]=175
d[3]=441
d[4]=891

每個功能使用一個方法來實現，在主運行函數內，利用創建新對象，再使用對象的方法來引用功能函數。這樣，整個程序看起來就很清晰明了，并且功能模塊很獨立。不會因為修改一處而導致全部代碼修改，這也正是面向對象程序開發的一個最大優勢。

在編寫有關數組方面的程序時，主要是操作數組中的元素。而在實際的程序開發中，不可能像前面舉的例子一樣簡單。在實際開發工作中，要涉及的不單純是基本類型的數組，絕大多數會遇到數組中元素的數據類型是對象類型。至于對象類型的使用，其實同基本類型的數組一樣，只不過是數據類型不同而已，對象數組將會在后面的章節中講解。