马士兵课程笔记(续4)

数组

• 数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

差别：C/C++中的数组是可以分配在栈上的

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

一维数组的声明

格式：type var[]; 或 type[] var;

• Note：Java语言中声明数组时不能指定其长度（而在创建时，比较C/C++）；

数组对象的创建

格式： 数组名 = new 数组元素类型[元素个数]

public class Test {
    public static void main(String args[]) {
        int[] s;    // 在栈内存中声明数组引用
        s = new int[5];    // 在堆内存中创建数组，并对基本类型的元素初始化{0, 0, 0, 0, 0}, s引用指向它
    }
}

 元素为引用数据类型的数组

Note：每一个元素（引用数据类型）都需要初始化。

public class Test {
    public static void main(String[] args) {
        Date[] days;
        days = new Date[3];
        for (int i=0; i<3; i++) {
            days[i] = new Date(2004, 4, i+1);
        }
    }
}

class Date {
    int year; int month; int day;
    Date(int y, int m, int d) {
        year =y; month =m; day = d;
    }
}

 

数组初始化

• 动态初始化 —— 数组定义与为数组元素分配空间和赋值的操作分开进行

int[] a;
a = new int[3];
a[0] = 3; a[1] = 9; a[2] = 8;

Date[] days;
days = new Date[3];
day[0] = new Date(1, 4, 2004);
day[1] = new Date(2, 4, 2004);
day[2] = new Date(3, 4, 2004);

•  静态初始化 —— 在定义数组的同时就为数组元素分配空间并赋值

int[] a = {3, 9, 8};

Date[] days = {
    new Date(1, 4, 2004);
    new Date(2, 4, 2004);
    new Date(3, 4, 2004);
};

•  数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被默认初始化

... ...
int[] a = new int[5];
Date[] days = new Date[3];

System.out.println(a[3]);
System.out.println(days[3]);
... ...

/* Output:
0
null
*/

数组元素的引用

arrayName[index]

Note: 在用到数组长度的地方都用arrayName.length属性而非长度值；

 

tips： 

• public satic void System.exit(int static) —— 当前运行的虚拟机退出，0正常退出，非0非正常退出（其实两者在Windows下没区别）更多详情见API。
• 基础类型包装类 —— 把基础类型的值包装进对象，有Byte，Short，Integer，Long，Double，Float，Character，Boolean。除了Character类外它们都有把String形式的值转换成基础类型的静态方法，如public static int Integer.parseInt(String value) throws NumberFormatException, 更多详情见API。
• 对每次循环都要用到的变量，把定义放在循环外，循环内赋值，节省每次分配/回收内存操作的花销。

二维数组

• 可以视为数组的数组。 如： int a[][] = {{1, 2}, {3, 4, 5, 6}, {7, 8, 9}};
• 多维数组的声明及初始化应从高维到低维从左到右从外到里

// 静态初始化
int intA[][] = {{1, 2}, {2, 3}, {3, 4, 5}};
// int intB[3][2] = {{1, 2}, {2, 3}, {4, 5}};    非法

// 动态初始化
int a[][] = new int[3][5];

int b[][] = new int[3][];
// int t[][] = new int[][4];    非法
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];

 数组的拷贝

• 使用java.lang.System类的静态方法System.arraycopy

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Note： 这个函数名里c居然没有大写

将源数组src从第srcPos项元素开始的length项元素拷贝到目标数组dest从destPos项开始的length个位置；

若length超过目标数组边界会抛出 IndexOutOfBoundsException 异常。

更多见API。

String[] s = ("Microsoft", "IBM", "Sun", "Oracle", "Apple");
String[] sBak = new String[6];
System.arraycopy(s, 0, sBak, 0, s.length);

for(int i=0; i < sBak.length; i++) {
    System.out.println(sBak[i]);    // sBak[i]和s[i]的值相同，是字符串常量的引用
}

// 二维整型数组拷贝
int[][] a = {{1, 2}, {1, 2, 3}, {3, 4}};
int[][] aBak = new int[3][];
System.arraycopy(a, 0, aBak, 0, a.length);
a[2][1] = 100;

for(int i=0; i<aBak.length; i++) {
    for(int j=0; j<aBak[i].length; j++) {
        System.out.println(aBak[i][j]);    // 因为aBak[2]拷贝了a[2]的数组引用，所以aBak[2][1]和a[2][1]是同一个变量，已经改成了100
    }
}