随笔(1)Java中的数组和List集合以及类型强转

谁践踏了优雅 2022-01-30 12:25 1692阅读 0赞

> 在java中,集合操作有两种方式——容器、数组；  
> 容器相比较于数组，多了可扩展性，这里仅以容器的代表List，来对比和数组的关系。

都知道在java引入的泛型和自动拆装箱等语法糖后，集合操作也变得简单安全。  
也都知道其实泛型在到字节码层面上时，会被擦除，虽然字节码中还会保留泛型参数（可以利用反射看到），但对真实的的类并不产生多大影响。

那么，对于List来说，如果泛型存在继承关系，是否可以强行转换呢？

## 一、List泛型类型转换 ##

先看一个关于泛型的代码：

List<Number> numbers=new ArrayList<>();
    
    //无法直接赋值 ：Incompatible types
    //List<Object> objects=numbers;
    
    //无法进行类型转换：Inconvertible types; cannot cast 'java.util.List<java.lang.Number>' to 'java.util.List<java.lang.Object>
    //List<Object> objectss=(List<Object>)numbers;

如果放开注释，编译器会直接报错；错误警告在注释中有标出；

可以看到，虽然泛型参数不会改变List类的类型，但在**有了泛型之后，无法直接赋值，也无法进行类型的强行转换**

那怎么样才能赋值成功呢？

List<Number> numbers=new ArrayList<>();
    List presenter =numbers;
    List<Object> objects=presenter;

只有这样：**先消除泛型处理，然后再直接赋值**

虽然说换了一种方式，但其实代码逻辑与之前错误的那种并无不同，那为什么编译器对上一种操作方式不认可呢？

这个需要继续看接下来的代码：

List<Number> numbers=new ArrayList<>();
    numbers.add(new Integer(200));
    List presenter =numbers;
    List<Date> objects=presenter;
    Date date = objects.get(0);

这里的操作是这样的：

1.  新建List容器，存储**Number类型**
2.  将一个**Integer类型**对象放入
3.  通过去泛型操作将**存储Number类型的List容器**引用赋值给**存储Date类型的List容器**
4.  通过**get方法**获取容器中第一个元素（真实类型为Number），然后强转为Date类型

这段代码完全符合Java语法，但真正运行时就会出现异常：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.util.Date1

由此可见，最开始一段代码中，进行非相同类型相互赋值是很有风险的，因此编译器对此做了特殊处理，Java是一门基于安全的语言，这种很危险的事情当然会有相应的警告，但要是人为使坏（比如**通过反射向容器中添加元素**），那就没办法了。

同样的，除了容器泛型外，数组有时候也需要进行一些类型转换操作，那么数组会和泛型容器一样出现相同的问题么？

## 二、类型数组 ##

Java中枚举类型**enum**继承自**Enum类**，但数组类可**不继承**自Array类，对于容器类来说不允许的操作，数组类确是允许的：

Integer[] integers=new Integer[2];
    Number[] numbers=integers;

如上代码所示，一个**Integer类型数组**，可以直接赋值给**Number类型数组**。

与集合不同的是，**泛型不同的List所对应的class类相同**，**类型数据对应的class类不同**

因此说到底，泛型集合根本不是强制类型转换，因为**表面类型**（和静态分派是所说的类型相似）并没有发生变化。这点可以通过**编译器调试模式REPL**来进行分析；

### 1、基本类型对应的数组 ###

java中虽然说基本类型（如**int**）可以和包装类型（如**Integer**）自动拆装箱，仿佛随时随地可以相互转化，但其实只是表面语法糖而已，同样的，基本类型数组和对象数组也存在不同之处。

先写出一些实例代码用于调试：

int[] a=new int[3];

然后进入调试模式查看**变量a**到底是什么类型：

##### ① 数组类型 #####

![这里写图片描述][70]

![这里写图片描述][70 1]

可以看到，**int\[\]** 对应的类型为 **\[I**

##### ② 类方法、类成员 #####

![这里写图片描述][70 2]

![这里写图片描述][70 3]

这个类型其实是JVM内部自动生成的，在外部无法访问到。

这里我们可以发现，竟然没有任何成员，也没有任何方法。我们平时使用数组的时候，明明是使用了**length属性**的，这里为什么没有显示呢？

看这个代码：

int[] a = new int[3];
    int length = a.length;

生成的字节码是这样的：

...
    5 arraylength
    ...

对于字节码来说，如果length真的是属性，那么应该是通过 **getfield** 命令来获取，这里显然不是这样。

对于数组元素的提取，则是使用了其他的字节码指令（如aastore等）来完成的。因此确实没有length这个成员域。

关于数组为何要使用length属性来获取长度，可以参阅：[**为什么使用length获取Java数组的长度**][length_Java]

##### ③ 接口 #####

![这里写图片描述][70 4]

这里实现了**Cloneable和Serializable**，可以进行序列化和克隆。

##### ④ 父类 #####

![这里写图片描述][70 5]

这里看到，**基本类型数组的父类为Object**，这也符合情况，因为一般来说基本类型数组对象最多也只是将引用赋值给Object类型引用而已。

### 2、引用类型对应的数组 ###

首先来思考一下，引用类型数组和基本类型数组是否基本类似？

使用一下之前的代码：

Integer[] integers = new Integer[5];
    Number[] numbers = integers;
    Integer[] is = (Integer[]) numbers;

这里所有的操作都是有效的，一般而言：

1.  **子类实例同样是父类的实例**
2.  **只有类型见存在继承关系，才能进行强制类型转换，并且只有真实类型为子类时，强转才不会出错**

那么我们有理由推理，Integer\[\] 是Number\[\] 的子类。

和基本类型一样，进行调试测试一下类型到底是什么：

##### ① 引用数组类型 #####

![这里写图片描述][70 6]

改数组类型为: **\[java.lang.Integer**  
格式和基本类型都一致，中括号表示一维，Integer表示类型

##### ② 接口 #####

![这里写图片描述][70 7]

和基本数组类型一样，实现了克隆和序列化接口

##### ③ 父类 #####

![这里写图片描述][70 8]

看到这里，我们发现与我们的推理有些不符合了，Integer\[\] 的父类竟然直接就是Object。

是猜想有问题么？但如果真的 Integer\[\] 和 Number\[\] 都是Object的直接子类，那两者强转肯定会类型转型转换异常的吧。

因此这里我们直接使用java代码去进行测试。

通常我们一般会使用 **instanceof** 操作符来判断继承关系

integers instanceof [java.lang.Integer

这样很明显是不行的，我们根本无法直接表示出数组类来，所以还得使用一般的方式：

integers instanceof Number[]

执行后可以看到，结果为 **true** ，这就很好了，我们完全可以通过 Integer 类的继承关系，找出 Integer\[\] 类的继承关系：

![这里写图片描述][70 9]

### 3、多维数组类型 ###

通过调试模式我们可以验证 一维数组继承关系，但如果现在是多维数组，那么该如何处理呢？

这里我们可以直接看类继承是如何来判断的。

通用的 instanceof 操作符是java语法自带的，根本没法看到具体逻辑，因此我们需要查看继承判断方式的源码：

*  **Class.isInstance()**
 *  **Class.isAssignableFrom()**

两者的判断逻辑其实是一样的：

public boolean isInstance(Object obj) { 
        if (obj == null) { 
            return false;
        }
        return isAssignableFrom(obj.getClass());
    }

**Class.isInstance()** 方法会先判断是否为null，**为null的话直接返回false**；否则调用**Class.isAssignableFrom()**

public boolean isAssignableFrom(Class<?> cls) { 
        if (this == cls) { 
            return true;  // Can always assign to things of the same type.
        } else if (this == Object.class) { 
            return !cls.isPrimitive();  // Can assign any reference to java.lang.Object.
        } else if (isArray()) { 
            return cls.isArray() && componentType.isAssignableFrom(cls.componentType);
        } else if (isInterface()) { 
            // Search iftable which has a flattened and uniqued list of interfaces.
            Object[] iftable = cls.ifTable;
            if (iftable != null) { 
                for (int i = 0; i < iftable.length; i += 2) { 
                    if (iftable[i] == this) { 
                        return true;
                    }
                }
            }
            return false;
        } else { 
            if (!cls.isInterface()) { 
                for (cls = cls.superClass; cls != null; cls = cls.superClass) { 
                    if (cls == this) { 
                        return true;
                    }
                }
            }
            return false;
        }
    }

这里进行的判断逻辑如下：**这里用本类和目标类表示this与cls**

1.  **如果本类和目标类相同，那么返回true**
2.  **如果本类为Object，目标类不是基本数据类型，返回true**
3.  **如果本类为数组，目标类也为数组，则使用本类和目标类的componentType来调用isAssignableFrom进行判断**
4.  **如果本类为接口，则获取目标类所有实现的接口，然后逐个判断是否与 自身相同**
5.  **如果本来为其他一般类，则逐级获取目标类的父类，直到Object，看是否有某一级父类会与自身相同。**

这个逻辑很简单，这里直接看第三步对于数组类型的判断逻辑，其中有提到**componentType**，那么这个是什么存在呢？

/** * For array classes, the component class object for instanceof/checkcast (for String[][][], * this will be String[][]). null for non-array classes. */
    private transient Class<?> componentType;

翻译过来大概意思是：

> 对于数组类型，component 用于在 instanceof 操作或者类型转换时进行判断；对**String\[\]\[\]\[\]类型来说，其component为 String\[\]\[\] ；  
> 对于非数组类型，改字段为null**

也就是说，对于多维数组 **A\[ \]\[ \]\[ \]\[ \]… 和 B\[ \]\[ \]\[ \]\[ \]…** ,只要维度相同，那么两者之间的继承关系可以直接通过 **A 和 B** 类来判断。

至于多维数组内存存储方式，可以参考：[Java中数组在内存中的存放原理][Java]

## 三、List和数组，应该如何选择 ##

在一般写代码时，都习惯性的使用容器类，因为它可以 动态扩容，很方便，那数组还有没有 什么用处呢？

### 1、数组使用场景 ###

对于固定数量的对象，一般使用数组是比较好的，一方面数组占用内存空间肯定要少的多。  
另外一方面，由于多维数组的存在，在操纵一些矩阵 类数据时，总会直观一些。

### 2、ArrayList、LinkList、数组 ###

这个其实 很多人都 已经知道了，ArrayList底层使用的数组 ，在生成实例时，可以传递容量参数。

transient Object[] elementData;1

public ArrayList(int initialCapacity) { 
            if (initialCapacity > 0) { 
                this.elementData = new Object[initialCapacity];
            } else if (initialCapacity == 0) { 
                this.elementData = EMPTY_ELEMENTDATA;
            } else { 
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            }
        }

**elementData** 变量用于存储元素值，Object类型表示ArrayList真实存在的其实类型**很宽**，使用泛型也只是在语法 层面上减少使用出错率。  
**transient**变量则保证了集合中的元素不会存在线程同步的问题。

LinkList 则在底层使用了链表，

private static class Node<E> { 
            E item;
            Node<E> next;
            Node<E> prev;
    
            Node(Node<E> prev, E element, Node<E> next) { 
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }

从代码中可以看到，这还是个**双向链表**。

jdk1.5添加了**增强for循环功能**，对于数组来说，因为无法看到源码，暂时不考虑效率问题。

但从ArrayList和LinkList来看，很明显的**LinkList使用增强for循环会更快一些**，ArrayList由于内部为数组，因此普通的for循环访问速度会更快。

总的来说，由于容器List的出现，数组类使用场景已经没有以前那么多了，但由于容器类的特殊性，是通过JVM自动生成的，因此至少安全和效率会有很大的保证。

[70]: /images/20220130/643d75d3874648269c18512ddfe8c928.png
[70 1]: /images/20220130/770d1f91021343dc9ecbebdef692cf7c.png
[70 2]: /images/20220130/b68c02c960364303bfcf7045c090b8d9.png
[70 3]: /images/20220130/25dd5d7eed2d463081541d85bd1013b2.png
[length_Java]: https://blog.csdn.net/personbing/article/details/51394286
[70 4]: /images/20220130/c72b6a98894743f3a5437dcd413032b4.png
[70 5]: /images/20220130/16c7f8b750f14140a9adb8ca2cf20ecd.png
[70 6]: /images/20220130/06e83eed0d9a4d6287a289495b617e15.png
[70 7]: /images/20220130/92b567be37f74085aaaf9b7afe31d244.png
[70 8]: /images/20220130/62898d3d1961443b9371b10f727a22fa.png
[70 9]: /images/20220130/b22ddb2a13b3408da959322ded4c9127.png
[Java]: https://www.2cto.com/kf/201801/715942.html