<Java Class> 1.1数组初始化

1.1.1Java数组是静态的

Java语言是静态语言，所以Java数组是静态的，当数组完成初始化后该数组的长度是不可变的。（初始化就是为数组元素分配存储空间并制定每个元素的初始值）

数组初始化有两种方式：

静态初始化：初始化时由程序员指定数组元素的初始值，有系统决定数组长度；

动态初始化：初始化时由程序员指定数组长度，由系统为数组元素分配初始值。

两种初始化完成后数组长度都不可改变！

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2. /** 
  3.  *  
  4.  * @author vincent 
  5.  * 
  6.  */  
  7.   
  8. public class ArrayTest {  
  9.   
  10.     public static void main(String[] args) {  
  11.         //静态初始化第1个数组  
  12.         String[] books = new String[] {  
  13.                       "疯狂Java讲义",  
  14.                       "轻量级JavaEE企业应用实战",  
  15.                       "疯狂ajax讲义",  
  16.                       "疯狂XML讲义"  
  17.         };  
  18.         //静态初始化的简化初始方式,初始化第2个数组  
  19.         String[] names = {"孙悟空", "猪八戒", "白骨精"};  
  20.         //动态初始化第3个数组  
  21.         String[] setArry = new String[5];  
  22.         //访问3个 数组的长度  
  23.         System.out.println("数组1长度： " + books.length);  
  24.         System.out.println("数组2长度：" + names.length);  
  25.         System.out.println("数组3长度：" + setArry.length);  
  26.     }  
  27. }  

 

注意：数组初始化是不要既指定数组长度，又为每个数组元素分配初始值！

Java数组变量是一种引用变量，数组变量不是数组本身，它只是指向对内存中的数组对象。因此可以改变数组变量所引用的数组，这样可以造成数组长度可变的假象。

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2. /** 
  3.  *  
  4.  * @author vincent 
  5.  * 
  6.  */  
  7.   
  8. public class ArrayTest {  
  9.   
  10.     public static void main(String[] args) {  
  11.         //静态初始化第1个数组  
  12.         String[] books = new String[] {  
  13.                       "疯狂Java讲义",  
  14.                       "轻量级JavaEE企业应用实战",  
  15.                       "疯狂ajax讲义",  
  16.                       "疯狂XML讲义"  
  17.         };  
  18.         //静态初始化的简化初始方式,初始化第2个数组  
  19.         String[] names = {"孙悟空", "猪八戒", "白骨精"};  
  20.         //动态初始化第3个数组  
  21.         String[] setArry = new String[5];  
  22.           
  23.         //改变数组变量所引用的数组  
  24.         books = names;  
  25.         setArry = names;  
  26.           
  27.         //访问3个 数组的长度  
  28.         System.out.println("数组1长度： " + books.length);  
  29.         System.out.println("数组2长度：" + names.length);  
  30.         System.out.println("数组3长度：" + setArry.length);  
  31.     }  
  32. }  


1.1.2数组一定要初始化吗

 

可以换一个方式初始化数组，或者说数组无需初始化。记住：数组变量是引用类型变量，不是数组本身，只要将 数组变量指向有效的数组对象，即可在程序中使用该数组变量。

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2.   
  3.   
  4. public class ArrayTest3 {  
  5.   
  6.     public static void main(String[] args) {  
  7.         //定义并初始化数组nums  
  8.         int[] nums = new int[] {3, 5, 20, 12};  
  9.         //定义prices数组变量  
  10.         int[] prices;  
  11.         //让prices数组变量指向nums所引用的数组  
  12.         prices = nums;  
  13.         for (int i = 0; i < prices.length; i++)  
  14.             System.out.println(prices[i]);  
  15.         //将prices数组的第三个元素赋值为34  
  16.         prices[2] = 34;  
  17.         System.out.println("nums数组的第三个元素值为：" + nums[2]);  
  18.     }  
  19. }  


1.1.3基本类型数组的初始化

 

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2.   
  3. /** 
  4.  * @author vincent 
  5.  */  
  6.   
  7. public class PrimitiveArrayTest {  
  8.   
  9.     public static void main(String[] args) {  
  10.         // 定义一个int[]类型的数组变量  
  11.         int[] iArr = new int[] { 2, 5, -12, 20 };  
  12.         for (int i = 0; i < iArr.length; i++)  
  13.             System.out.println(iArr[i]);  
  14.     }  
  15. }  


所有的局部变量都是放在栈内存中的，不管是基本类型的变量，还是引用类型的变量，都是存储在各自的方法栈区中；但引用类型变量所引用的对象总是存储在堆内存中。

 

Java是不允许访问堆内存中的对象，为了访问他们只能通过引用变量。（引用变量本质上只是一个指针）

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2.   
  3.   
  4. public class PrimitiveArrayTest2 {  
  5.   
  6.     public static void main(String[] args) {  
  7.         //定义一个int[]类型的数组变量  
  8.         int[] iArry = null;  
  9.         //只要不访问iArry的属性和方法，程序完全可以使用该数组变量  
  10.         System.out.println(iArry);  
  11.         //初始化数组  
  12.         iArry = new int[5];  
  13.         //只有当iArry指向有效的数组对象后，才可以方位iArry的属性  
  14.         System.out.println(iArry.length);  
  15.     }  
  16. }  


1.1.4引用类型数组的初始化

 

引用类型数组的数组元素依然是引用类型的，因此数组元素里存储的还是引用，它指向另一块内存，这块内存里存储了该引用变量所引用的对象

 

[java] view plaincopy
 
  1. package javaclass.arraytest_1_1_1;  
  2.   
  3.   
  4. public class ReferenceArratTest {  
  5.   
  6.     private static Person[] students;  
  7.   
  8.     public static void main(String[] args) {  
  9.         //定义数组变量students，类型是Person[]  
  10.         students = new Person[2];  
  11.         System.out.println("students所引用的数组的长度是：" + students.length);  
  12.           
  13.         //创建一个Person实例  
  14.         Person zhang = new Person();  
  15.         zhang.age = 15;  
  16.         zhang.height = 165;  
  17.           
  18.         Person lee = new Person();  
  19.         lee.age = 16;  
  20.         lee.height = 170;  
  21.           
  22.         students[0] = zhang;  
  23.         students[1] = lee;  
  24.           
  25.         //下面两行代码的结果完全一样，因为lee和students[1]指向同一个Person实例  
  26.         lee.info();  
  27.         students[1].info();  
  28.     }  
  29. }  
  30.   
  31. class Person {  
  32.     public int age;  
  33.     public int height;  
  34.     public void info() {  
  35.         System.out.println("age:" + age + "  height:" + height);  
  36.     }  
  37. }  
posted @ 2013-02-27 18:05  vincent_hv  阅读(489)  评论(0)  编辑  收藏  举报