一、一维数组
1.定义和初始化数组
（1）只定义不初始化
- 需要new一块空间
int[] arr = new int[10];
（2）定义并初始化
- 类似C的写法（最常用）
int[] arr = {1,2,3,4,5};
- Java中常见写法
int[] arr = new int[]{1,2,3,4,5};
（3）总结点
- 左边得数组类型不能加数字，如：
//int[10] arr = new int[];错误
- Java中一般不允许指定数组大小，除非是未初始化的数组
- 相对for-each的优点：不仅可以遍历数组，还可以拿到数组的下标
2.遍历数组
（1）for循环
- 例如C语言一样，但是需要计算数组长度
- 数组名.length就可以计算数组长度了
int[] arr1 = {5,2,0,1,3,1,4}; for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i]+" "); }
（2）for-each（加强for循环）
- 语法格式：for (定义得变量 : 数组名) {//打印变量即可打印整个数组}
int[] arr1 = {5,2,0,1,3,1,4}; for (int Y:arr1) {//int Y的意思是用数组元素的类型去定义一个变量Y，Y中存放数组的内容 System.out.print(Y+" "); }
- 缺点：只能拿来变量数组
（3）使用方法打印
- 语法格式
int[] arr2 = {9,8,7}; String ret = Arrays.toString(arr2); System.out.println(ret);
3.目前数组常见的异常
（1）数组越界异常
当访问个数大于数组个数时，会报一个数组越界异常
（2）空指针异常
当数组传参的时候，如果不对参数判断（判断数组是否为空）就使用，很有可能触发该异常
4.数组内容拷贝
（1）常规拷贝法：使用for循环
int[] arr = new int[]{1,2,3,4,5}; int[] copy = new int[arr.length]; for (int i = 0; i < arr.length; i++) { copy[i] = arr[i]; } System.out.println(Arrays.toString(copy));
（2） 使用Arrays.copyOf方法拷贝
语法格式： 
int[] arr = new int[]{1,2,3,4,5}; int[] copy = new int[arr.length]; copy = Arrays.copyOf(arr,arr.length-2);//被拷贝的数组名和长度 System.out.println(Arrays.toString(copy));
（3）使用Arrays.copyOf方法拷贝并使目的数组大小扩大两
int[] arr = new int[]{1,2,3,4,5}; arr = Arrays.copyOf(arr,arr.length*2); arr[5]=6; arr[6]=7; arr[7]=8; arr[8]=9; arr[9]=10; System.out.println(Arrays.toString(arr));
（4）System.arraycopyOf方法
- 特点：将指定原数组中的数组从指定位置复制到目标数组的指定位置
int[] dest = new int[arr.length]; System.arraycopy(arr,2,dest,0,arr.length-3);//[2,arr.length-3)55551 System.out.println(Arrays.toString(dest));
- 语法特点：
（5）克隆法：clone()
- 语法特点
int[] arr = new int[]{1,2,3,4,5}; int[] copy1 = arr.clone(); System.out.println(Arrays.toString(copy1));
（6）多指向写法
- 将数组地址赋值给新数组
int[] arr = new int[]{1,2,3,4,5}; int[] copy2 = arr; System.out.println(Arrays.toString(copy2));
（7）Arrays.equals
- 作用：比较两个字符串/数组内容是否相等
- 类型：boolean类型，相等返回true，否则返回false
- 比较字符串：语法特点
public static void main(String[] args) { String arr1 = "abcdef"; String arr2 = "abcd"; String arr3 = "abcdef"; boolean bool = arr1.equals(arr2); System.out.println(bool); bool = arr3.equals(arr1); System.out.println(bool); }
- 比较数组内容
public static void main(String[] args) { int[] arr1 = new int[]{1,2,3,4,5}; int[] arr2 = new int[]{1,2,3,4,5}; boolean bool = Arrays.equals(arr1,arr2); System.out.println(bool); }
（8）Arrays.fill
- 用于填充数组
- 语法特点
public static void main(String[] args) { //1.Arrays.fill，数组局部填充 int[] arr = new int[10]; Arrays.fill(arr,1,5,11);//填充下标[1,5) System.out.println(Arrays.toString(arr))； }
二、二维数组
二维数组是一个特殊的一维数组，每个数组内容是一个一维数组。
1.二维数组的定义和初始化
（1）常规赋值法（最常用）
- 对每行的赋值必须加上花括号
int[][] arr = {{1,2,3},{4,5,6}};
（2）只定义而不初始化
int[][] arr = new int[][]{{},{}};
（3）只定义，省略列的写法
int[][] arr = new int[2][];
（4）不规则定义方式
- 什么叫不规则定义方式，就是每一列的数目可以不一样
- 对每一行单独new
- （整形）数组变量属于引用类型，不初始化值默认为0
public static void main(String[] args) { int[][] arr = new int[3][]; arr[0] = new int[3];//第一行有三列 arr[1] = new int[2];//第二行有两列 arr[2] = new int[4];//第三行有四列 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j]+" "); } System.out.println(); } }
2.二维数组的遍历
（1）两个for循环的常规写法
- 第一层循环：表示行数（一共多个行）
- 第二次循环：表示列数（一列有多少个）
public static void main(String[] args) { int[][] arr1 = new int[][]{{1,2,3},{4,5,6}}; for (int i = 0; i < arr1.length; i++) { for (int j = 0; j < arr1[0].length; j++) { System.out.print(arr1[i][j]+" "); } System.out.println(); } }
（2）两层for-each语句
- 第一层的类型是int[]
- 第二层的类型是int
public static void main(String[] args) { int[][] arr1 = new int[][]{{1,2,3},{4,5,6}}; for (int[] X:arr1) { for (int Y:X) { System.out.print(Y+" "); } System.out.println(); } }
（3）使用方法打印（深度打印）
- 方法：Array.deepToString
public static void main(String[] args) { int[][] arr1 = new int[][]{{1,2,3},{4,5,6}}; String ret = Arrays.deepToString(arr1); System.out.println(ret); }
三、总结
1.数组定义的变量都属于引用类型
- 内存分布大致图
- 数组变量位于栈上，而数组内容位于堆上
- 所谓引用变量，该变量存的是地址（0x7788）；所以称为引用指向对象，这个对象就是new出来的int[ ]{1，2，3}。
- 当引用变量没有指向对象的时候，则指向null，称为空引用（不指向任何对象）
- 在方法内创建的变量（包括引用类型和基本类型）都是局部变量，都需要初始化，否则编译错误
2.引用只能指向一个对象
- 引用只允许指向一个对象，但是一个对象可以被多个引用指向
- 当交换两个值的时候，就需要交换引用
3.地址及内存回收问题
- 数组传参时，若堆上的内容没有指向就返回时，堆上的内容会被销毁回收
