java数组学习

java数组的静态特性
java数组的内存分配机制
java初始化数组的两个方法
初始化基本类型数组的内存分配
舒适话应用类型数组的内存分配
数组引用变量和数组对象
数组引用变量是什么，何时是数组对象
数组元素等同于变量
多维数组的内存分配

java数组是静态的

java是静态语言，因此当数组被初始化之后，该数组的长度是不可变的。java程序里的数组必须经过初始化（为数组对象的元素分配内存空并制定初始值）。

数组的两种初始化方式：

静态初始化：初始化由程序员显式制定每个数组元素初始值，由系统决定数组长度（初始化后长度不变）。
动态初始化：初始化时候程序员只是制定数组长度，由系统为数组元素分配初始值。

无论哪种方式数组被初始化之后，长度就不变，可以用数组的length属性来访问数组长度。

public class Arraytest{
	public static void main(String[] args){
	//静态初始化的方式
	String[] books=new String[]{
		"java","python","c","r"
		};
	String[] name = {
		"java","c"
	};
	//动态初始化的方式
	String[]ss= new String[5];
	System.out.println(ss.length);
	books{}
	}
}

**执行动态初始化，程序员只需要指定数组的长度，**即为每个数组元素制定所需的内存空间，系统将负责为这些数组元素分配初始值如下：

1. 数组元素的类型是整数类型（byte\short\int\long）值是0
2. 浮点类型（float\double）值是0.0
3. 字符类型（cahr）值是u0000
4. 布尔类型（boolean）值是false
5. 数组是引用类型（类、接口和数组）值是null

引用的初始化方式

java数组变量是一种引用类型变量，数组变量并不是数组本身，只是指向堆内存中的数组对象。

public class test01 {
	public static void main(String[] args) {
		String[] books = new String[] { // 静态初始化
				"crazy java",
				"java EE ",
				"crazy ajax",
				"crazy xml"
		};
		
		String[] names = {
				"sunwukong",
				"zhubajie",
				"baigujing"
		};
		
		String[] strArr= new String[5];//动态初始化
		
		System.out.println("第1个数组长度："+books.length);
		System.out.println("第2个数组长度："+names.length);
		System.out.println("第3个数组长度："+strArr.length);
		System.out.println("--------");
		
		books = names;//books数组变量指向引用的names数组
		strArr = names;//strArr数组变量指向引用的names数组
		System.out.println("books数组长度："+books.length);
		System.out.println("names数组长度："+names.length);
		System.out.println("strArr数组长度："+strArr.length);
		
		//改变books的第3个元素值
		books[2] = "tangseng";
		System.out.println("第二个books的元素值"+books[2]);
		System.out.println("第二个books的元素值"+names[2]);	
	}
}

输出结果
第1个数组长度：4
第2个数组长度：3
第3个数组长度：5
--------
books数组长度：3
names数组长度：3
strArr数组长度：3
第二个books的元素值tangseng
第二个books的元素值tangseng

java数组必须先初始化，也就是为数组元素分配内存空间。
java 数组变量 是引用类型变量，让数组变量指向有效的数组对象，也可以进行初始化，

public static void main(String[] args){
	int[] nums = new int[] {3,5,20,12};
		//定义prices数组变量
		int[] prices;
		prices = nums;
		for (int i = 0; i < prices.length; i++) {
		System.out.println(prices[i]);
	}
}

创建了prices数组但是为初始化的时候是如下的状态；

当初始化之后，prices=nums指向
nums变量引用的数组，完成初始化。

案例分析一

public static void main(String[] args){
	//定义int[]类型数组变量静态初始化
	int[] iArr;
	iArr = new int[2,5,-12,20];
}

int[] iArr在main方法栈里定义一个叫做iArr的数组变量，此时是一个引用类型的变量，没有指向任何有效内存，没有指向实际的数组对象，此时不能被使用。
静态初始化之后，iArr数组变量引用的数组所占用内存空间被定下来， 只允许改变数组的元素值，不在允许增减数组对象所占用的内存。
所有的局部变量都是存放在栈内存里的， 不管是基本类型的变量还是引用类型的变量，都是存在各自方法栈区里。所以常看见说的基本类型变量的值是存在栈内存里这句话是错误的。

案例分析二

引用类型变量可以看作一个指针 ， 那何时引用类型变量会从栈内存里的变量变成java对象呢？
当程序通过引用变量访问属性或者调用方法，引用变量就会由它所引用的对象代替。

public class Person{
	public int age,height;
	public void info(){
		System.out.println("age = "+age+"height = "+height
	};
}
public class ReTest{
	public static void main(String[] args){
		Person[] students;
		students = new Person[2];//动态方式初始化数组
		System.out.println(students.length);
		
		Person zhang = new Person();
		zhang.age=15;zhang.height=158;

		Person lee = new Person();
		lee.age=16;lee.height=161;

		students[0] = zhang;
		students[1] = lee;
		lee.info();
		students[1].info();
	}
}

mian的栈内存里有students变量，是空引用，没有指向有效内存。

初始化students后系统为数组元素分配默认初始化值为null。students[0]和students[1]还是两个引用类型变量，不指向任何有效内存区，还不能通过students[0]和students[1]调用属性或方法。

main栈里定义两个引用变量zhang和lee，并且两个引用变量指向有效的、存储在堆内存的Person对象，

使用数组

public static void main(String[] args){
	int[] pos=new int[5];
	for(int i=0;i<pos.length;i++){
		pos[i] = (i+1)*2;
	}
	int a = pos[1];
	int b = 20;
	pos[2] = b;
	Cat[] cats = new Cat[2];
	cats[0] = new Cat(3.14,2);
	cats[1] = new Cat(3.2,2);
	Cat c1 = cats[0];
	Cat c2 = new Cat(4.3,3);
	cats[1] = c2;
}

多维数组

所谓多维数组，其数组元素是降一维的数组的。2维数组的数组元素是以为1维数组，3维数组的数组元素是2维数组…N维数组的数组元素是N-1维数组。

		int[][] a;//定义二维数组
		a = new int[4][];
		for(int i=0;i<a.length;i++) {
			System.out.println(a[i]);
		}
		System.out.println("----");
		a[0] = new int[2];
		a[0][1] = 6;
		for(int i=0;i<a[0].length;i++) {
			System.out.println(a[0][i]);
		}

参考资料

疯狂Java：突破程序员基本功的16课