Java中的数组，你知道多少细节？

 这是本节内容的思维导图

目录

一、一维数组

1.定义和初始化数组

2.遍历数组

3.目前数组常见的异常

4.数组内容拷贝

二、二维数组

1.二维数组的定义和初始化

2.二维数组的遍历

三、总结

1.数组定义的变量都属于引用类型

2.引用只能指向一个对象

3.地址及内存回收问题

---

一、一维数组

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.地址及内存回收问题

• 数组传参时，若堆上的内容没有指向就返回时，堆上的内容会被销毁回收