数组与内存的控制

爱被打了一巴掌 2022-07-14 10:39 104阅读 0赞

1.1数组初始化

使用数组之前必须先对数组对象进行初始化,当数组的所有元素均被分配合适内存空间,并指定了初始值时,数组初始化完成.java的数组是静态的,一旦为数组初始化完成,数组元素的内存空间分配即结束,程序只能改变数组元素的值,而无法改变数组的长度.

1.1.1Java数组是静态的

因为Java数组变量是一种引用类型的变量,数组变量并不是数组本身,它只是指向堆内存中的数组对象.因此,可以改变一个数组变量所引用的数组,这样可以造成数组长度可变的假象.

不要同时使用静态初始化和动态初始化.也就是说,不要在进行数组初始化时,既指定数组的长度,也为每个数组元素分配初始值.

静态初始化:初始化时由程序员显式指定每个数组元素的初始值,由系统决定数组长度.

动态初始化:初始化时程序员只指定数组长度,由系统分配数组元素初始值.

package com.lic.array;
    
    public class Demo01 {
    	public static void main(String[] args) {
    		// 采用静态初始化方式初始化第一个数组
    		String [] books = new String []{"English","Math","Medicine"};
    		// 采用静态初始化简化形式初始化第二个数组
    		String [] names = {"猪八戒","唐曾","孙悟空","沙僧"};
    		// 采用动态初始化方式初始化第三个数组
    		String [] arrStr = new String [5];
    		
    		System.out.println(books.length+"--"+names.length+"--"+arrStr.length);
    		System.out.println(books[1]);		
    		
    		// 让books,arrStr数组变量指向names所引用的数组
    		books = names;
    		arrStr = names;
    		System.out.println(books.length+"--"+names.length+"--"+arrStr.length);
    		System.out.println(books[1]);	
    		
    		books[1] = "饿了,困了,喝东鹏特饮!";
    		System.out.println(books[1]+"---"+names[1]+"--"+arrStr[1]);
    	}
    }

控制台输出如下:

3--4--5
    Math
    4--4--4
    唐曾
    饿了,困了,喝东鹏特饮!---饿了,困了,喝东鹏特饮!--饿了,困了,喝东鹏特饮!

将books和arrStr指向names引用的对象后,原来的books和arrStr的长度并没有变.只是没有变量指向它们了,无法被使用了,它们将会被垃圾回收器回收.这时我们改变books\[1\]的指,它改变的也是names\[1\]的值.

1.1.2数组一定要初始化吗?

始终记住:java数组变量是引用类型的数组变量,它并不是数组对象本身.只用让数组变量指向有效的数组对象,程序中即可使用该数组变量.

package com.lic.array;
    
    public class Demo02 {
    
    	public static void main(String[] args) {
    		// 定义并初始化nums数组
    		int [] nums = new int[]{3,2,43,5,22};
    		// 定义一个prices数组变量
    		int [] prices;
    		// 让prices数组指向nums引用的数组
    		prices = nums;
    		for(int i = 0; i < prices.length; i++){
    			System.out.println(prices[i]);
    		}
    		// 将prices的第三个元素赋值为34;
    		prices[2] = 34;
    		// 访问nums的第三个元素,将看到输出34
    		System.out.println(nums[2]);
    	}
    }

从以上代码可以看出,程序定义prices数组后,并未对其进行初始化,当执行int\[\] prices;之后,程序并未对prices进行内存分配.此时prices数组变量还未指向任何有效的内存,未指向任何数组对象,此时程序还不能使用prices变量.

那么java数组不需要初始化吗?其实主要是区分java数组对象和java数组变量.java数组变量只是一个引用变量,通常存放于栈内存中(也可放入堆内存中);而数组对象就是保存在堆内存中的连续空间.对数组执行初始化并不是对数组变量执行初始化,而是对数组对象执行初始化.数组变量只需要指向一个有效的数组对象.

对于java程序中的所有引用变量都不需要经过所谓的初始化操作,需要初始化操作的是该引用变量所引用的对象.

1.1.3基本类型数组的初始化

对于基本数组而言,数组元素的值直接存储在对应的数组元素中,因此基本类型数组的初始化比较简单:程序直接先为数组分配内存空间,再将数组元素的值存入对应内存里.

package com.lic.array;
    
    public class Demo03 {
    
    	public static void main(String[] args) {
    		// 定义一个int类型数组变量
    		int [] iArr;
    		// 静态初始化数组,数组长度为5
    		iArr = new int[] {1,2,3,4,5};
    	}
    }

上面代码的执行过程代表了基本类型数组初始化的典型过程.执行第一行代码int\[\] iArr;时,仅定义一个数组变量,存放在main栈区,此时堆内存还没有内数组创建内存空间.当执行iArr = new int\[\]\{1,2,3,4,5\};静态初始化后,系统会根据程序员指定的数组元素来决定数组的长度.此时指定了5个数组元素,系统将创建一个长度为5的数组对象,一旦数组对象创建成功,该数组的长度将不可改变.程序只能改变数组元素的值,此时,堆内存中已经创建了一段连续的内存空间,并存放了值.

静态初始化完成后,iArr数组变量所 引用的数组所占用的内存空间被固定下来,程序员只能改变各数组元素内的值,但不能移动该数组所占用的内存空间----既不能扩大该数组对象所占用的内存,也不能缩减该数组对象所占用的内存.

所有局部变量都是放在栈内存里保存的,不管其是基本类型的变量,还是引用类型的变量,都是存储在各自的方法栈区中;但引用类型变量所引用的对象(包括数组,普通Java对象)则总是存储在堆内存中.

对于Java语言而言,堆内存中的对象(不管是数组对象,还是普通的Java对象)通常不允许直接访问,为了访问堆内存中的对象,通常只能通过引用变量.这也是很容易混淆的地方.例如,iArr本质上只是main栈区的引用变量,但使用iArr.length,iArr\[2\]时,系统将会自动变为访问堆内存中的数组对象.

对于很多Java程序员而言,他们最容易混淆的是:引用类型变量何时只是栈内存中的变量本身,何时又变为引用实际的Java对象.其实规则很简单:引用变量本质上只是一个指针,只要程序通过引用变量访问属性,或者通过调用引用变量来调用方法,该引用变量将会由它所引用的对象代替.

package com.lic.array;
    
    public class Demo04 {
    
    	public static void main(String[] args) {
    		// 定义一个int类型数组变量
    		int[] iArr = null;
    		// 只要不访问 iArr的属性和方法,程序完全可以使用该数组变量
    		System.out.println(iArr);         // ①
    		// 动态初始化数组长度为5
    		iArr = new int[5];
    		// 只有当iArr指向有效的数组对象后,下面才可以访问iArr的属性
    		System.out.println(iArr.length);  // ②
    	}
    
    }

上面程序中两次访问iArr变量.对于①行代码而言,虽然此时的iArr数组变量并未引用到有效的数组对象,但程序在①处并不会出现任何问题,因此此时并未通过iArr访问属性或者调用方法,所以系统不会去访问iArr所引用的数组对象.对于②行代码而言,此时程序通过iArr访问了length属性,程勋将自动变为访问iArr所引用的数组对象,这就要求iArr必须引用一个有效的对象.

1.1.4引用类型数组的初始化

引用类型数组的数组元素依然是引用类型的,因此数组元素里存储的还是引用,它指向另一块内存,这块内存里存储了该引用变量所引用的对象(包括数组和Java对象).

为了说明引用类型数组的运行过程,下面程序先定义一个Person类,然后定义了一个Person\[\]数组,并动态初始化了该Person\[\]数组,再显式为数组的不同数组元素指定值.

package com.lic.array;
    
    public class Demo05 {
    	public static void main(String[] args) {
    		// 定义一个students数组变量,其类型时Person();
    		Person[] students;
    		// 执行动态初始化
    		students = new Person[2];
    		System.out.println("students所引用的数组的长度是:"+students.length); // ①
    		// 创建一个Person实例,并将这个Person实例赋给zhang变量
    		Person zhang = new Person();
    		// 为zhang所引用的Person对象属性赋值
    		zhang.age = 15;
    		zhang.height = 158;
    		// 创建一个Person实例,并将这个Person实例赋给lee变量
    		Person lee = new Person();
    		// 为lee所引用的Person对象的属性赋值
    		lee.age = 16;
    		lee.height = 161;
    		// 将zhang变量的值赋给第一个数组元素
    		students[0] = zhang;
    		// 将lee变量的值赋给第二个数组元素
    		students[1] = lee;
    		// 下面两行代码的结果完全一样,因为lee和students[1]指向的是同一个Person实例
    		lee.info();
    		students[1].info();
    	}
    }

上面代码的执行过程代表了引用类型数组的初始化的典型过程.

执行Person\[\] students;代码时,这行代码仅仅在栈内存中定义了一个引用变量,也就是一个指针,这个指针并未指向任何有效的内存区.栈内存中定义了一个students变量,它仅仅是一个空引用,并未指向任何有效的内存.直到执行初始化,本程序对students数组执行动态初始化.动态初始化由系统为数组元素分配默认的初始化值null,即每个数组元素的值都是null.students数组的2个数组元素都是引用,而且这2个引用并未指向任何有效的内存,因此,每个数组元素的值都是null.此时,程序可以通过students来访问它所引用的数组的属性,因此在①行代码通过students访问该数组的长度,将输出2.

students数组是引用类型的数组,因此students\[0\],students\[1\]两个数组元素相当于两个引用类型的变量.如果程序只是直接输出这两个引用类型的变量,那么程序完全正常.但程序依然不能通过students\[0\],students\[1\]来调用属性或方法,因此它们还未指向任何有效的内存区,所以这两个连续的Person变量(students数组的数组元素)还不能被使用.

接着,程序定义了zhang和lee两个引用变量,并让它们指向堆内存中的两个Person对象,此时的zhang,lee两个引用变量存储在main方法栈区中,而两个Person对象则存储在堆内存中.

对于zhang,lee两个引用变量来说,它们可以指向任何有效的Person对象,而students\[0\],students\[1\]也可以指向任何有效的Person对象.从本质上来讲,zhang,lee,students\[0\],students\[1\]所能存储的内容完全相同.接着,程序执行students\[0\] = zhang; students\[1\] = lee;两行代码.也就是让zhang和students\[0\]指向同一个对象.让lee和students\[1\]指向同一个对象.此时zhang和students\[0\]指向同一个内存区,而且他们都是引用类型的变量.因此,通过zhang和students\[0\]来访问Person对象的属性和方法效果完全一样.不论修改students\[0\]所指向的Person实例的属性,还是zhang所指向的Person实例的属性,所修改的其实是同一个内存区,所以必然互相影响.同理,lee和students\[1\]也是引用到同一个Person对象,也有同样的效果.

对于引用类型的数组而言,他的数组元素其实就是一个引用类型的变量,因此可以指向任何有效的内存----此处"有效"的意思指强类型的约束.比如对Person\[\]类型的数组而言,它的每个数组元素都相当于Person类型的变量,因此他的数组元素只能指向Person对象.

\-- 摘自<<疯狂Java--突破程序员基本功16课>>