Java数组特性详解-优快云博客

转载：http://blog.youkuaiyun.com/zhangjg_blog/article/details/16116613

前言

数组是基本上所有语言都会有的一种数据类型，它表示一组相同类型的数据的集合，具有固定的长度，并且在内存中占据连续的空间。在C，C++等语言中，数组的定义简洁清晰，而在java中确有一些会让人迷惑的特性。本文就尝试分析这些特性。

Java中数组是对象吗

Java和C++都是面向对象的语言。在使用这些语言的时候，我们可以直接使用标准的类库，也可以使用组合和继承等面向对象的特性构建自己的类，并且根据自己构建的类创建对象。那么，我们是不是应该考虑这样一个问题：在面向对象的语言中，数组是对象吗？

要判断数组是不是对象，那么首先明确什么是对象，也就是对象的定义。在较高的层面上，对象是根据某个类创建出来的一个实例，表示某类事物中一个具体的个体。对象具有各种属性，并且具有一些特定的行为。而在较低的层面上，站在计算机的角度，对象就是内存中的一个内存块，在这个内存块封装了一些数据，也就是类中定义的各个属性，所以，对象是用来封装数据的。

在较高的层面上，数组不是某类事物中的一个具体的个体，而是多个个体的集合。那么它应该不是对象。而在计算机的角度，数组也是一个内存块，也封装了一些数据，这样的话也可以称之为对象。

这样的话，数组既可以是对象，也可以不是对象。至于到底是不是把数组当做对象，全凭Java的设计者决定。数组到底是不是对象，通过代码验证：

    @Test
    public void array() {
        int[] a = new int[4];  
        //a.length;  //对属性的引用不能当成语句  
        int len = a.length;  //数组中保存一个字段, 表示数组的长度  
          System.out.println(len);
        //以下方法说明数组可以调用方法,java中的数组是对象.这些方法是Object中的方法,所以可以肯定,数组的最顶层父类也是Object  
        a.clone();  
        a.toString();  
    }

在数组a上，可以访问他的属性，也可以调用一些方法。这基本上可以认定，java中的数组也是对象，它具有java中其他对象的一些基本特点：封装了一些数据，可以访问属性，也可以调用方法。所以，数组是对象。

而在C++中，数组虽然封装了数据，但数组名只是一个指针，指向数组中的首个元素，既没有属性，也没有方法可以调用。如下代码所示：

int main(){  
    int a[] = {1, 2, 3, 4};  
    int* pa = a;  
    //无法访问属性，也不能调用方法。  
    return 0;  
}

Java中数组的类型

Java是一种强类型的语言。既然是对象，那么就必须属于一个类型，比如根据Person类创建一个对象，这个对象的类型就是Person。那么数组的类型是什么呢？看下面的代码：

    @Test
    public void test() {
        int[] a1 = {1, 2, 3, 4};  
        System.out.println(a1.getClass().getName());  
        //打印出的数组类的名字为[I  

        String[] s = new String[2];  
        System.out.println(s.getClass().getName());  
        //打印出的数组类的名字为  [Ljava.lang.String;  

        String[][] ss = new String[2][3];  
        System.out.println(ss.getClass().getName());  
    }

输出结果：

[I
[Ljava.lang.String;
[[Ljava.lang.String;

打印出a1的类型为[ I ，s 的类型是[Ljava.lang.String; , ss的类型是[[Ljava.lang.String;

所以，数组也是有类型的。只是这个类型显得比较奇怪。你可以说a1的类型是int[]，这也无可厚非。但是我们没有自己创建这个类，也没有在Java的标准库中找到这个类。也就是说不管是我们自己的代码，还是在JDK中。

这只能有一个解释，那就是虚拟机自动创建了数组类型，可以把数组类型和8种基本数据类型一样，当做java的内建类型。这种类型的命名规则是这样的：

每一维度用一个[表示；开头两个[，就代表是二维数组。
[后面是数组中元素的类型(包括基本数据类型和引用数据类型)

在java语言层面上,s是数组,也是一个对象,那么他的类型应该是String[]，这样说是合理的。但是在JVM中，他的类型为[java.lang.String。顺便说一句普通的类在JVM里的类型为包名+类名，也就是全限定名。同一个类型在java语言中和在虚拟机中的表示可能是不一样的。

Java中数组的继承关系

上面已经验证了，数组是对象，也就是说可以以操作对象的方式来操作数组。并且数组在虚拟机中有它特别的类型。既然是对象，遵循Java语言中的规则 – Object是上帝，也就是说所有类的顶层父类都是Object。数组的顶层父类也必须是Object，这就说明数组对象可以向上直接转型到Object，也可以向下强制类型转换，也可以使用instanceof关键字做类型判定。这一切都和普通对象一样。如下代码所示：

    @Test
    public void typeTest() {
        //1     在test1()中已经测试得到以下结论: 数组也是对象, 数组的顶层父类是Object, 所以可以向上转型  
        int[] a = new int[8];  
        Object obj = a ; //数组的父类也是Object,可以将a向上转型到Object  

        //2     那么能向下转型吗?  
        int[] b = (int[])obj;  //可以进行向下转型  

        //3     能使用instanceof关键字判定吗?  
        if(obj instanceof int[]){  //可以用instanceof关键字进行类型判定  
            System.out.println("obj的真实类型是int[]");  
        }

Object[]类型的引用可以指向String[]类型的数组对象？由上文的验证可以得知数组类型的顶层父类一定是Object，那么上面代码中s的直接父类是谁呢？难道说String[]继承自Object[]，而Object[]又继承自Object? 让我们通过反射的方式来验证这个问题：

    @Test
    public void extendsTest() {
        String[] s = new String[5];  
        Object[] obja = s;   //成立,说明可以用Object[]的引用来接收String[]的对象  
        /*
         * 由代码可知，String[]的直接父类就是Object而不是Object[]。可是Object[]的引用明明可以指向String[]类型的对象。
         *  
         *
         *这个看起来是违反了Java单继承的原则。
         *
         *  数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。
         * Ojbect[]的引用能够指向String[]类型的对象 这就是Java把数组设计成了协变
         * 至于为什么把数组设计为协变的，这个问题也是值得我们研究的
         * 
         * */
        System.out.println(s.getClass().getSuperclass().getName());
        //Arrays.equals(a, a2)

    }

由代码可知，String[]的直接父类就是Object而不是Object[]。可是Object[]的引用明明可以指向String[]类型的对象。

这样的话就违背了Java单继承的原则。String[]不可能即继承Object，又继承Object[]。上面的类图肯定是错误的。那么只能这样解释：数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。

其实这种关系可以这样表述：如果有两个类A和B，如果B继承（extends）了A，那么A[]类型的引用就可以指向B[]类型的对象。这就是所谓的协变，关于协变，下面会讲到。

注意：数组的这种用法不能作用于基本类型数据。

Java中数组是协变的

上面我们已经证明了Java中的数组是协变的，但是Java为什么要把数组设计成协变的呢？

这是原文并没有很好的给出解释的，我们需要自己去继续寻找答案。

下面转一个知乎上的答案：https://www.zhihu.com/question/21394322

因为在SE5之前，Java中还没有泛型，但很多代码波切需要泛型来解决问题。、、

For Example:比较两个素质是否”值相等的”Arrays.equals()方法，因为底层实现调用的是Object.equals()方法,和数组中具体元素类型无关。所以不想让每个类型都要重新定义Arrays.equals()方法。而是”泛化“地接受任何元素类型的数组为参数。要让Object[]能接受所有的数组类型，那个时候有有没有泛型，最简单的方法就是让数组接受协变。把String[],Integer[]都定义成Object的派生类，然后多态就起作用了。

那么为什么数组可以设计成协变的呢

这是因为数组有一个独有特性：

数组记得它内部元素的具体类型，并且会在运行时做类型检查

而且这句话也是为什么不能创建泛型数组的原因，数组创建时必须知道确切类型。

所以下面这段代码可以通过编译，但是运行报错：

    @Test
    public void covariant() {
        Number[] num = new Integer[10]; 
        //java.lang.ArrayStoreException: java.lang.Double


        num[0] = 2.1;
    //List<Integer> integerList=new ArrayList<Integer>();
    //List<Number> num1=integerList;
    }

会报java.lang.ArrayStoreException: java.lang.Double错误

num变量记得它内部元素是Integer.所以运行时给它插入double类型的时候不让执行。

这恰恰是数组的有点，也是当初”敢于“把数组设计成协变的原因。

虽然向上转型后，编译期类型检查放松了，但因为数组运行时对内部元素类型看的紧，不匹配的类型还是插不进去的。

这同样也是为什么容器Collection不能设计为协变的原因。Collection不做运行时类型检查。

如果Collection接受协变，List<Integer>的引用能够传给List<Number>:

    //List<Integer> integerList=new ArrayList<Integer>();
    //List<Number> num1=integerList; //假设接受协变

这时候我想往List<Number>里插入一个Double。它不会像数组这样拒绝，而是会选择默默承受。

num.add(new Double(2.1));

然后当我们从原先的integerList里面取东西，才会发现出问题了。虽然看上去从integerList里取Integer，我们的操作无可指责。但取出来的却是Double型。

Integer itg=integerList.get(0);    //BOOM！

与其等到拿出来之后才发现不对，那还不如当初就不让插入，这就是数组的好处。

而且，在引入了通配符(Wildcard)之后，协变的功能也已经被实现了。而且配合通配符的”上界“和”下界“一起用，容器内元素的类型还是受到严格控制的，虽然有点复杂。

关于泛型通配符，会有专门的文章介绍。

所以总的来说，虽然数组的协变不是一个完美的设计，但也不能算非常烂。起码还能用，没有捅出大篓子。而且数组又不支持泛型，底层类库到处是Object[]，现在也不可能改了。

数组Array

前言

Java中数组是对象吗

Java中数组的类型

Java中数组的继承关系

Java中数组是协变的