数组复习

1.一维数组

      数组是一个包含相同数据类型的集合。集合里存放的是相同类型的数据，我们把这样一个集合就称为数组。

1.1一维数组定义及初始化

     一维数组的定义有三种方式：

(1)先声明后初始化

    int[ ] arr;

    arr=new int[5];//数组中包含5个元素，每一个元素的初始值都是int类型的默认值0；

(2)声明的同时进行初始化方式

   int[ ] arr=new int[ ]{1,2,3};

(3)先声明后初始化，使用的是系统分配的默认值

   int[ ] arr=new int[5];//系统默认分配了5个Int大小的空间

1.2一维数组的内存结构

1.3一维数组的遍历

  一位数组的遍历有三种方式：

(1)for遍历

public static void main(String[] args){
    int[] arr=new int[]{1,2,3}
    for(int i=0;i<arr.length;i++){
          System.out.println(arr[i]);
      }
}

(2)foreach遍

for(数据类型 变量:数组或者集合){ 变量--->数组中的元素 }

 public static void main(String[] args){
        int[] arr=new int[]{1,2,3};
        for(int n:arr){
            System.out.println(n);
        }
      //String[] str = new String[]{"123", "abc", "dsi13"};
        //for (String  s : str) {
           // System.out.println(s);
        //}
    
}

(3)Arrays.toString()

public static void main(String[] args) {
        String[] str = new String[]{"123", "abc", "dsi13"};
            System.out.println(Arrays.toString(str));

    }

1.4一维数组的拷贝原理。例：数组名.clone()和System.arraycopy()是对一维数组的深拷贝。

public static void main(String[] args){
        int[] arr=new int[]{1,2,3};
        int[] brr=arr.clone();
        arr[0]=99;
        System.out.println("arr[0]被改之后的brr[0]的值为："+brr[0]);
        System.out.println("arr数组名保存："+arr+"brr数组名保存："+brr);
    }
运行结果：
arr[0]被改之后的brr[0]的值为：1
arr数组名保存：[I@f4c7f77brr数组名保存：[I@67446579

2.二维数组

2.1二维数组定义以及初始化方式

       一维数组中每个元素类型不再是一个基本数据类型的元素，而是一个引用数据类型，分布指向一个一维数组堆上存储的地址。

总共有三种初始化方式：

(1)int[][] arr={{1,2,3},{4,5,6},{7,8,9};或者int[][] arr=new int[3][3];//定义三行三列的二维数组。

(2)int[][] arr=new int[3][];//定义二维数组里的行数

         arr[0]=new int[3];//分别定义没一行中的存放的元素类型，也是一个一维数组

         arr[1]=new int[3];

         arr[2]=new int[3]; 

(3)int[][] arr={new int[3],new int[3],new int[3]};

2.2二维数组内存结构

2.3二维数组的遍历

(1)for遍历

public static void main(String[] args){
        int[][] arr=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        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)foreach遍历

public static void main(String[] args){
        int[][] arr=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        for(int[] n:arr){//遍历二位数组的每一个一维数组
            for(int ns:n){//遍历一维数组的每一个元素
                System.out.print(ns+" ");
            }
            System.out.println();
        }
    }

(3)Arrays.toString()遍历

 public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr[i]));
        }
    }
 运行结果：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
            System.out.println(Arrays.deepToString(arr));
        }
运行结果：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

2.4二维数组的拷贝

2.4.1数组名.clone()。

      clone不能直接作用于二维数组。Java中没有二维数组的概念，只有数组中的数组。在二维数组中，一维数组不再是一个基本数据类型，而是一个引用数据类型，分部指向一个一维数组在堆上存储的地址。当数组b对数组a进行克隆时，a中存储的是对一维数组的引用，调用clone函数时，是对引用进行了复制。

public static void main(String[] args){
        int[][] arr=new int[][]{{1,2,3},{4,5,6}};
        int[][] brr=arr.clone();
        System.out.println("arr[0]保存地址："+arr[0]+"arr数组内容"+Arrays.deepToString(arr));
        System.out.println("brr[0]保存地址："+brr[0]+"brr数组内容"+Arrays.deepToString(brr));
        arr[0][0]=99;
        System.out.println("修改arr[0][0]之后"+arr[0][0]+"brr[0][0]的值为是："+brr[0][0]);
        }
运行结果：
arr[0]保存地址：[I@f4c7f77arr数组内容[[1, 2, 3], [4, 5, 6]]
brr[0]保存地址：[I@f4c7f77brr数组内容[[1, 2, 3], [4, 5, 6]]
修改arr[0][0]之后99brr[0][0]的值为是：99

         用clone对二维数组进行复制，要在每一维上调用clone函数。

public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] brr = new int[arr.length][];
        for (int i = 0; i < arr.length; i++) {
            brr[i] = arr[i].clone();
            System.out.println(Arrays.toString(brr[i]));
        }
        brr[0][0]=99;
        System.out.println(brr[0][0]+" "+arr[0][0]+" ");
    }
运行结果：
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
99 1

3.深拷贝和浅拷贝

    深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型。

    在Java中，除了基本数据类型之外，还存在类的实例对象这个引用数据类型。而一般使用=号做赋值操作的时候，对于基本类型数据，实际上是拷贝它的值，但是对于对象而言，其实赋值的只是对象的引用，将原有对象的引用传递过去，他们实际上还是指向的同一对象。

浅拷贝：在拷贝这个对象的时候，只是对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有真实的创建一个新的对象。

Arrays.copyof(arr，arr.length）

底层由System.arraycopy实现。

 public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6}};
        int[][] brr = Arrays.copyOf(arr, arr.length);
        for (int i = 0; i <brr.length; i++) {
            System.out.println(Arrays.toString(brr[i]));
        }
        arr[0][0]=99;
        System.out.println(brr[0][0]+" "+arr[0][0]+" ");
    }
运行结果：
[1, 2, 3]
[4, 5, 6]
99 99 

深拷贝：在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量。

System.arraycopy(object src,int srcPos,Object dest,int destPos,int length)是一个native方法

 public static void main(String[] args) {
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5, 6}};
        int[][] brr = new int[arr.length][arr[0].length];
        //System.arraycopy(arr, 0,brr,0,arr.length);
        for (int i = 0; i < arr.length; i++) {
            brr[i] = new int[arr[i].length];
            System.arraycopy(arr[i], 0, brr[i], 0, arr[i].length);
            System.out.println(Arrays.toString(brr[i]));
        }
        brr[0][0] = 99;
        System.out.println(brr[0][0] + " " + arr[0][0] + " ");
    }
运行结果：
[1, 2, 3]
[4, 5, 6]
99 1