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{}
}
}
**执行动态初始化,程序员只需要指定数组的长度,**即为每个数组元素制定所需的内存空间,系统将负责为这些数组元素分配初始值如下:
- 数组元素的类型是整数类型(byte\short\int\long)值是0
- 浮点类型(float\double)值是0.0
- 字符类型(cahr)值是u0000
- 布尔类型(boolean)值是false
- 数组是引用类型(类、接口和数组)值是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课