Java基础--数组

1.一维数组的声明

type var[];或type[] var;

java语言中声明数组时不能指定其长度

使用new创建，数组名 = new 数组元素的类型 [数组元素的个数]

        int[] s;             //栈内存中创建一个s数组
        s = new int[5];     //堆内存中分配5个小格，存储int类型

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

注意：元素为引用数据类型的数组中的每一个元素都需要实例化

public class Date {
    int year;
    int month;
    int day;

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

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

2.数组的初始化

动态初始化：数组的定义与为数组元素分配空间和赋值的操作分开进行，先分配空间再赋值，上例就是

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

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

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

public class Test {
    public static void main(String agrs[]) {
        int a[] = new int[5];
        Date[] days = new Date[5];
        System.out.println(a[3]);
        System.out.println(days[3]);
    }
}

结果为：0  null

3.数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：

arrayName[数组下标]

每个数组都有一个属性length指明它的长度，a.length的值为数组a的长度（元素个数）

4.二维数组

二维数组可以看成以数组为元素的数组。例如：

int a[][] = {{1,2},{3,4,5,6},{7,8,9}};

Jave中多维数组的声明和初始化应按从高维到低维的顺序进行

        int a[][] = new int[3][];
        a[0] = new int [2];
        a[1] = new  int[4];
        a[2] = new int[2];              //合法
        int t[][] = new int[][4];       //不合法

5.二维数组初始化

静态初始化：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][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];

举例：

    public static void main(String agrs[]) {
        String s[][] = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[4];
        for (int i = 0; i < s.length; i++) {
            for (int j = 0; j < s[i].length; j++) {
                s[i][j] = new String("我的位置是：" + i + "," + j);
            }
        }
        for (int i = 0; i < s.length; i++) {
            for (int j = 0; j < s[i].length; j++) {
                System.out.print(s[i][j] + " ");
            }
            System.out.println();
        }
    }

结果是：

我的位置是：0,0  我的位置是：0,1 
我的位置是：1,0  我的位置是：1,1 我的位置是：1,2 
我的位置是：2,0  我的位置是：2,1 我的位置是：2,2  我的位置是：2,3

6.数组的拷贝

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

public static void arraycopy(Object src,int scrPos,Objectdest,int destPos,int length)

可以用于数组src从第scrPos项元素开始的length个元素拷贝到目标数组dest从destPos项开始的length个位置。

如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常。

public class TestArrayCopy {
    public static void main(String args[]) {
        String[] s = {"Mircosoft", "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.print(sBak[i] + " ");
        }

        System.out.println();
        int[][] intArray = {{1, 2}, {1, 2, 3}, {3, 4}};
        int[][] intArrayBak = new int[3][];
        System.arraycopy(intArray, 0, intArrayBak, 0, intArray.length);
        intArrayBak[2][1] = 100;      //intarray与拷贝后的intarrayBak是指的同一内存，如下图，所以同时也修改了intarray
        for (int i = 0; i < intArray.length; i++) {
            for (int j = 0; j < intArray[i].length; j++) {
                System.out.print(intArray[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

结果是：

Mircosoft IBM Sun Oracle Apple null
1  2 
1  2  3 
3  100 
3 100的原因如下