文章目录
1. 定义及初始化
1. 1动态初始化（声明并开辟数组）
数组类型[] 数组名 = new 数据类型[数组长度];
其中，数据类型可以是8种基本的数据类型，也可以是引用数据类型。
注意：
- 在给数组命名的时候，一般在数组名后加一个 s 表示这是一个包含多个元素的数组（与单个变量区分）。
- 当数组采用动态初始化开辟空间之后，数组之中的每个元素都是该数据类型的默认值。
| 数据类型 | 默认初始化 |
|---|---|
| byte、short、int、long | 0 |
| foat、double | 0.0 |
| char | 一个空字符，即 ‘\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
- 数组名称.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 静态初始化
简化格式：
数据类型[] 数组名称 = {值, 值, …};
完整格式（推荐）:
数据类型[] 数组名称 = new 数据类型[]{值, 值, …};
注意：
a. 通过数组下标索取来取得元素，下标默认从0开始。数组下标超出数组长度，数组越界异常（运行时异常）。
b. 数组属于引用数据类型，在使用之前一定要开辟空间（实例化），否则就会产生"NullPoninterException"。
int[] arrays = {1, 2, 3, 4, 5};
int[] arrays = new int[]{1, 2, 3, 4, 5};
数组的最大缺陷：长度固定（存在越界问题）。
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]);
}
}
注意： 在数组定义时直接设置内容，根据值的个数确定长度，且长度不可修改。
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();
}
}
}
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();
}
}
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();
}
}
现在数组上发生了引用传递，意味着在接收数组时可以修改数组。
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();
}
}
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();
}
}
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();
}
}
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();
}
}
使用该方法无需实现使用new关键字对对象进行内存单元的分配。