Java中数组的定义及初始化_java中数组的定义和初始化

1. 定义及初始化

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

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

 其中，数据类型可以是8种基本的数据类型，也可以是引用数据类型。
注意：

• 在给数组命名的时候，一般在数组名后加一个 s 表示这是一个包含多个元素的数组（与单个变量区分）。
• 当数组采用动态初始化开辟空间之后，数组之中的每个元素都是该数据类型的默认值。

• 数组名称.length：取得数组长度（数组长度可以由属性length获得）。
• 数组遍历推荐使用for-each循环（仅限于数组内容读取），要修改数组内容，还是使用常规for循环：for(int x: 数组名称) {……}

public class Study02{
    public static void main(String[] args){
        int[] arrays = new int[5];	//定义并开辟了一个长度为3的数组
	    // 可以将上面代码分成两句来写
	   int[] array = null;	// 声明一个长度int[]类型的变量，变量会占用一块内存空间，它没有分配初始值。
	   array = new int[5];	//创建一个长度为5的数组，将数组的地址赋给变量arrays。
		
	   for(int i = 0; i < arrays.length; i++)
        {
            System.out.println("arrays[" + i + "] = " + arrays[i] + " ");
        }
        arrays[0] = 10;	//数组的第一个元素
        arrays[1] = 20;	//数组的第二个元素
        // 数组遍历
        for(int x : array)
        {
            System.out.println(array[x]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2 静态初始化

简化格式：
	数据类型[] 数组名称 = {值, 值, …};
完整格式（推荐）:
	数据类型[] 数组名称 = new 数据类型[]{值, 值, …};
1
2
3
4

注意：
 a. 通过数组下标索取来取得元素，下标默认从0开始。数组下标超出数组长度，数组越界异常（运行时异常）。
 b. 数组属于引用数据类型，在使用之前一定要开辟空间（实例化），否则就会产生"NullPoninterException"。

	int[] arrays = {1, 2, 3, 4, 5};
	int[] arrays = new int[]{1, 2, 3, 4, 5};
1
2

数组的最大缺陷：长度固定（存在越界问题）。

2. 引用传递

 数组作为引用数据类型，也可以发生引用传递。
 引用传递空间：同一块堆内存空间可以被不同的栈内存所指向。
范例： 多个栈内存指向相同的堆内存。

public class Study02{
    public static void main(String[] args){
        int[] arr = new null;
        int[] temp = null;  // 声明对象
        arr = new int[3];   // 开辟一个长度为3的数组
        System.out.println(arr.length);
        arr[0] = 1; // 数组第一个元素
        arr[1] = 2; // 数组第二个元素
        arr[2] = 3; // 数组第三个元素
        for(int i = 0; i < arr.length; i++)
        {
            //通过循环控制索引下标更改
            System.out.println(arr[i]);
        }
        temp = arr; // 发生引用传递，不能出现[]
        temp[0] = 55;  // 修改数据
        System.out.println(arr[0]);
    }
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

3. 二维数组的基本了解

二维数组的初始化

• 动态初始化
   数据类型[][] 对象数组 = new 数据类型[行个数][列个数];
• 静态初始化
   数据类型[][] 对象数组 = new 数据类型[][]{{值, 值, …}, {值, 值, …}, …};

数组的数组就是二维数组。
举例：定义一个二维数组

public class ArrayDemo{
    public static void main(String[] args){
        //数组并不是等列数组
        int[][] data = new int[][]{
                                    {1, 2, 3}, 
                                    {4, 5}, 
                                    {6, 7, 8, 9}};
        for(int i = 0; i < data.length; i++)
        {
            for(int j = 0; j < data[i].length; j++)
            {
                System.out.print("data[" + i + "][" + j + "]="
                 + data[i][j] + " ");
            }
            System.out.println();
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4. 数组与方法的互操作

4.1 方法接收数组

举例：

public class ArrayDemo{
    public static void main(String[] args){
        int[] data = new int[]{1, 2, 3, 4, 5};
        printArray(data);   //其效果等价于 int[] temp = data;
    }
    public static void printArray(int[] temp){
        for(int i = 0; i < temp.length; i++)
        {
            System.out.print(temp[i] + " ");
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.2 方法返回数组

举例：

public class ArrayDemo{
    public static void main(String[] args){
        int[] data = init();
        printArray(data);
    }
    //定义一个返回数组的方法
    public static int[] init()
    {
        return new int[] {11, 22, 33, 44, 55};//匿名数组：只使用一次就失效了
    }
    public static void printArray(int[] temp){
        for(int i = 0; i < temp.length; i++)
        {
            System.out.print(temp[i] + " ");
        }
        System.out.println();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

现在数组上发生了引用传递，意味着在接收数组时可以修改数组。

4.3 方法修改数组

举例：

public class ArrayDemo{
    public static void main(String[] args){
        int[] data = init();//接收了数组，发生了引用传递，可以修改返回的数组
        bigger(data);
        printArray(data);
    }
    //定义一个返回数组的方法
    public static int[] init()
    {
        return new int[] {11, 22, 33, 44, 55};//匿名数组：只使用一次就失效了
    }
    //将数组中每个元素的值扩大两倍
    public static void bigger(int[] arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            arr[i] *= 2;    //每个元素扩大两倍
        }
    }
    //打印数组
    public static void printArray(int[] temp){
        for(int i = 0; i < temp.length; i++)
        {
            System.out.print(temp[i] + " ");
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

5. Java对数组的支持

5.1 排序

java.util.Arrays.sort(数组名称)
支持所有基本数据类型
内部使用双轴排序（了解）

import java.util.Arrays;

public class Arrayss{
    public static void main(String[] args){
        int[] arr1 = new int[]{2, 3, 6, 4, 7};
        char[] arr2 = new char[]{'a', 'v', 'e', 'b'};
        //排序
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        PrintArrays(arr1);
        PrintArrays(arr2);

    }
    //打印数组
    public static void PrintArrays(int[] data){
        for(int x : data)
        {
            System.out.print(x + " ");
        }
        System.out.println();
    }
    public static void PrintArrays(char[] data){
        for(int x : data)
        {
            System.out.print((char)x + " ");
        }
        System.out.println();
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

5.2 数组的拷贝

5.2.1 数组的部分拷贝

System.arraycopy(源数组名称, 源数组开始点, 目标数组名称, 目标数组开始点, 拷贝长度);
源数组data为：1， 2， 3， 4， 5，6
目标数组arr为：11， 22，33，44，55，66，77
经过 System.arraycopy(data, 1, arr, 2, 3); 拷贝后，从data[1]开始完后拷贝3个元素，存放在从arr[2]开始的arr数组中。
部分拷贝后：
目标数组arr为：11，22，2，3，4，66，77

public class Arrayss{
    public static void main(String[] args){
        int[] data = new int[]{1, 2, 3, 4, 5, 6};
        int[] arr = new int[]{11, 22, 33, 44, 55, 66, 77};
        System.out.print("data数组为：");
        printArrays(data);
        System.out.print("arr数组为：");
        printArrays(arr);

        System.arraycopy(data, 1, arr, 2, 3);
        System.out.println("拷贝后两个数组为：");
        System.out.print("data数组为：");
        printArrays(data);
        System.out.print("arr数组为：");
        printArrays(arr);
    }
    public static void printArrays(int[] data){
        for(int x : data)
        {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.2.2 数组全拷贝

需引入java.util.Arrays;
==数组类型[] 目标数组名 == = Arrays.copyOf(源数组名称, 新数组长度);
举例：

import java.util.Arrays;

public class Arrayss{
    public static void main(String[] args){
        int[] data = new int[]{1, 2, 3, 4, 5, 6};
        int arr[] = Arrays.copyOf(data, 3);
        System.out.print("arr数组为：");
        printArrays(arr);
    }
    public static void printArrays(int[] data){
        for(int x : data)
        {
            System.out.print(x + " ");
        }
        System.out.println();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用该方法无需实现使用new关键字对对象进行内存单元的分配。