JavaSE之数组的定义与使用

数组初始化：

1.数组动态初始化（声明并开辟数组）

数据类型 [ ] 数组名称 = new 数据类型 [ 长度 ]

eg:声明并开辟一个长度为5的整形数组

int [  ] data = new int [5];

当数组开辟之后，可采用如下方式进行操作：

a.数组通过下标来取得元素，下标默认从0开始。数组下标超出数组长度，数组越界异常（运行时异常）。

b.数组中每个元素都有默认值，默认值是该数据类型默认值。

c.数组名称.length：取得数组长度。

d.数组遍历推荐使用for-each循环（仅限于数组的内容读取），要修改数组内容，还是使用常规for循环

for( int x : data ){……}

注意：数组属于引用数据类型，必须在使用前先初始化。否则会NullPointerException（空指针异常），属于运行时异常。

2.数组静态初始化

在数组定义时直接设置内容，根据值的个数确定数组长度，并且长度不可修改。

简化格式：

数据类型[  ] 数组名称 = {值，值......}

完整格式（推荐）：

数据类型[  ]  数组名称 = new 数据类型[   ] {值，值......}

eg：int [  ] data = new int [  ] {1,3,5,7,9,10};

public class Test{
    public static void main(String[] args){
    //数组的动态初始化
    int[] data1 = new int[3];
    data1[0] = 1;
    data1[1] = 2;
    data1[2] = 3;
    for(int x:data1)
    {
        System.out.print(x+"、");
    }
    System.out.println();
    //数组的静态初始化
    int[] data2 = {11,22,33,44};
    for(int x:data2)
    {
        System.out.print(x+"、");
    }
}
}

二维数组：

二维数组只要了解即可，在这里不做阐述。

数组引用传递：

数组作为引用数据类型，也一定可以发生引用传递。

观察一个简单的程序：

public class Test{
    public static void main(String[] args){
    //数组的动态初始化
    int[] data = null;
    data = new int[3];
    data[0] = 1;
    data[1] = 2;
    data[2] = 3;
    for(int x:data)
    {
        System.out.print(x+"、");
    }
}
}

引用传递：同一块堆内存空间同时可以被不同的占内存指向。

public class Test{
    public static void main(String[] args){
    int[] data = null;
    int[] tmp = null;//声明对象
    data = new int[3];
    data[0] = 1;
    data[1] = 2;
    data[2] = 3;
    for(int x:data)
    {
        System.out.print(x+"、");
    }
    System.out.println();
    tmp = data;//如果要发生引用传递，不要出现[]
    tmp[0] = 10;
    for(int x:tmp)
    {
        System.out.print(x+"、");
    }
}
}

引用传递的内存分析都是类似的：同一块堆内存被不同的栈内存所指向。

数组与方法互操作：

数组是引用数据类型，所有引用数据类型都可以为其设置多个栈内存指向。所以在数组操作的时候，可以将其通过方法进行处理。

方法接收数组：

public class Test{
    public static void main(String[] args){
        int[] data = new int[]{1,2,3,4};
        printArray(data);//其效果等价于int[] tmp = data;
    }
    public static void printArray(int[] tmp){
        for(int x:tmp)
        {
            System.out.println(x);
        }
    }
}

方法返回数组：

public class Test{
    public static void main(String[] args){
        int[] data = init();
        printArray(data);//其效果等价于int[] tmp = data;
    }
    public static int[] init(){
        return new int[]{1,2,3,4};//匿名数组
    }
    public static void printArray(int[] tmp){
        for(int x:tmp)
        {
            System.out.println(x);
        }
    }
}

方法修改数组：

public class Test{
    public static void main(String[] args){
        int[] data = init();
        changeArray(data);
        printArray(data);//其效果等价于int[] tmp = data;
    }
    public static int[] init(){
        return new int[]{1,2,3,4};//匿名数组
    }
    //将数组中的值扩大两倍
    public static void changeArray(int[] arr){
        for(int i = 0; i < arr.length; i++)
        {
            arr[i] = arr[i]*2;
        }
    }
    public static void printArray(int[] tmp){
        for(int x:tmp)
        {
            System.out.println(x);
        }
    }
}

Java对数组的支持：

1.排序---java.util.Arrays.sort(数组名称);

支持所有基本数据类型数组

内部使用双轴快速排序

public class Test{
    public static void main(String[] args){
     int[] data = new int[]{1,99,34,76,55};
     char[] arr = new char[]{'d','a','w','y'};
     java.util.Arrays.sort(data);
     java.util.Arrays.sort(arr);
     printArray(data);
     printArray(arr);
    }
    public static void printArray(int[] tmp)
    {
        for(int x:tmp)
        {
            System.out.print(x+"、");
        }
        System.out.println();
    }
    //重载
    public static void printArray(char[] tmp)
    {
        for(int i = 0; i < tmp.length; i++)
        {
            System.out.print(tmp[i]+"、");
        }
    }
}

2.数组部分拷贝

System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，拷贝长度)；

注意：目标数组的选取

例：数组arr1：1,2,3,4,5,6  数组arr2：11,22,33,44,55  结果数组：1,2,33,44,55,6

public class Test{
    public static void main(String[] args){
    int[] arr1 = new int[]{1,2,3,4,5,6};
    int[] arr2 = new int[]{11,22,33,44,55};
    System.arraycopy(arr2, 2, arr1, 2, 3);
    for(int x:arr1)
    {
        System.out.print(x+"、");
    }
    }
}

3.数组全拷贝

Java动态数组动态扩容方法

java.util.Arrays.copyOf(源数组名称，新数组长度)；

public class Test{
    public static void main(String[] args){
    int[] arr1 = new int[]{1,2,3,4,5,6};
    int[] arr2 = new int[3];
    arr2 = java.util.Arrays.copyOf(arr1, 3);
    for(int x:arr2)
    {
        System.out.print(x+"、");
    }
    }
}