详解 普通数组 —— Arrays类 与 浅克隆

Posted 2020-11-26 codderyouzg

目录

• 基本应用：
• Arrays类：
• 浅克隆：

我们在C语言中，编一些代码量规模比较大的程序，几乎都会用到 “数组” 或 “链表” ，但是，在本人之前的博文中，却对这两个知识点从未提到过，那么，本人将通过这篇博文，来为同学们讲述这两个知识点。

---

---

首先，本人来带同学们重温下普通数组的基本知识点：

基本应用：

那么，现在，本人来通过一段代码来为同学们展示 一维数组的定义和初始化 过程：

package com.mec.study;

import com.mec.study.complex.Complex;

public class AboutArray {
    
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        System.out.println(array1.getClass());  //第一种数组的定义
        
        double[] array2 = new double[10];
        System.out.println(array2.getClass());  //第二种数组的定义
        
        Complex array3[];
        array3 = new Complex[5];
        System.out.println(array3.getClass());  //第三种数组的定义
    }
    
}

本人先对 .getClass() 这一句做一下解释：
这个方法，返回值是 “.” 之前的对象的类名称。
从上图的输出结果来看，数组的确被当做一个“类”来对待，这就应证了本人上面对数组的描述

那么，现在，本人在来讲解一下二维数组，来展示下多维数组的初始化方法：
现在，本人来通过一段代码来为同学们展示 二维数组的定义和初始化 过程：

import com.mec.study.complex.Complex;

public class AboutArray {
    
    public static void main(String[] args) {
        int[][] matrix1 = {{1, 2}, {1, 2, 3}, {1, 2, 3, 4}};    //第一种初始化方式：直接赋初值
        
        int[][] matrix2 = new int[3][2];    //第二种初始化方式：通过new来确定行、列数，但并未赋值
        
        int[][] matrix3 = new int[2][];     //第三种初始化方式：先初始化行，在初始化列
        for(int i = 0; i < matrix3.length; i++) {
            matrix3[i] = new int[2];
        }
    }
    
}

那么，现在来看一个十分奇怪的例子：

package com.mec.study;

public class AboutMatrix {
    public static void main(String[] args) {
        int[][] matrix = new int[3][];  
        for(int i = 0; i < matrix.length; i++) {
            matrix[i] = new int[i+3];
        }
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[i].length; j++) {
                System.out.print((j == 0 ? "" : ", ") + matrix[i][j]);
            }
            System.out.println();
        }
    }
    
}

这里来解释下：
因为二维数组的每一个元素是一维数组的对象，该对象需要申请一维数组空间，而申请空间时，完全可以给不同长度，所以，在Java语言中，可以做到二维数组的各行长度可以是不同，
。
所以，我们对于二维以上的数组遍历时，也可以用如下方式：

j < matrix[j].length

这样的条件判断，这样才能遍历完二维以上的数组！

那么，在C语言中，我们未对一个定义的变量赋初值，那么这个变量内存储的是“垃圾数据”，这一点，在Java中是否也一样呢？
我们通过一段代码来探索下：

package com.mec.study;

import com.mec.study.complex.Complex;

public class AboutArray {
    
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        for(int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");
        }
        System.out.println();
        
        double[] array2 = new double[10];
        for(int i = 0; i < array2.length; i++) {
            System.out.print(array2[i]);
        }
        System.out.println();
        
        Complex array3[];
        array3 = new Complex[5];
        for(int i = 0; i < array3.length; i++) {
            System.out.print(array3[i] + " ");
        }
        System.out.println();
    }
    
}

我们上述代码运用了.length方法，这个方法的功能是，返回该数组 或 该链表的长度
我们能够得出一个结论：
当我们定义了一个数组时，系统将自动为其各成员赋值为：0、0.0、flase 和 null

---

那么，谈及数组，本人就不得不来讲解下八大排序了：
请观看本人博文——《Java数组 —— 八大排序》

---

那么，数组的基本初始化方法我们就讲解完了。

数组在Java中也是 “类”，并且 这与C语言中的数组有非常大的差别。
Java语言对于数组有专门封装好的类——Arrays类

---

现在，本人就来讲解下Arrays类：

Arrays类：

请观看本人博文——《详解 Arrays类》

---

接下来，本人来介绍一下数组的 clone() 与 “浅克隆”

数组类 中提供了一个clone()方法，顾名思义：克隆。
但是，这里的克隆 是 “浅克隆”，那么，什么是“浅克隆”呢？

浅克隆：

首先，本人先来介绍一下浅克隆的几个注意点：

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口;
2. Cloneable接口只不过是一个标识接口而已，没有任何方法;
3. 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份;
4. 对象的浅克隆也不会调用到构造方法。
5. 浅克隆 在数组中的应用可理解为 只克隆数组元素的值。

相信看到上述解释的大多数同学并没有理解什么是“浅克隆”，那么，现在，本人通过一段代码来让同学们了解下 浅克隆 的本质：

package com.mec.study;

import com.mec.study.complex.Complex;

public class AboutArray {
    
    public static void main(String[] args) {
        Complex array[] = new Complex[5];
        for(int i = 0; i < array.length; i++) {
            array[i] = new Complex(i, 0);
        }
        System.out.println("array 克隆前各元素的值： ");
        for(int i = 0; i < array.length; i++) {
            System.out.print((i == 0 ? "" : ",") + array[i]);
        }
        System.out.println();
        
        Complex arr[] = array.clone();
        System.out.println("arr 是 array 克隆结果： ");
        for(int i = 0; i < array.length; i++) {
            System.out.print((i == 0 ? "" : ",") + arr[i]);
        }
        System.out.println();
        
        array[0].setReal(100);
        System.out.println("array 更改后的结果： ");
        for(int i = 0; i < array.length; i++) {
            System.out.print((i == 0 ? "" : ",") + array[i]);
        }
        System.out.println();
        
        System.out.println("arr 竟然也变化了： ");
        for(int i = 0; i < array.length; i++) {
            System.out.print((i == 0 ? "" : ",") + arr[i]);
        }
        System.out.println();
    }
    
}

可以看到，我明明重新申请了一个arr[]，但是改变array[]数组的值，arr[]数组中的值也会发生改变。
这就是“浅克隆”。

array初始化时，对每一个Complex对象申请了实例空间，而每一个Complex对象就是申请的实例空间的首地址；clone()方法 “克隆”的只是array数组的每一个元素本身的值（即 一个对象的首地址值），所以，克隆出的arr数组，表面上是独立于array数组，但其元素却指向array各元素所指向的同一Complex实例空间。这就是“浅克隆”。
尤其是当我们定义了一个二维数组时，我们在使用clone()时小心啦！！！

那么，关于数组的基本知识点就讲解完成了，可见，Java中的数组，和C语言中的数组，还是有很大差别的。有封装好的工具类使用起来真的比较方便。

若是对上述知识点或代码有任何疑惑、意见或者建议，请在下方评论区提出，本人将尽早予以答复，觉得有所帮助的同学请留下小赞赞，谢谢！！！