Java集合之List---ArrayList解析

本章节主要讲述ArrayList集合知识,主要包括ArrayList结构类型,集合特点,源码解析等。

欢迎持续关注阅读,一起学习,共同交流(477819525君羊)。

1 ArrayList类层次结构:

2 ArrayList特性:

a) ArrayList是基于数组实现的,是一个动态数组,可以动态的增加和减少元素,灵活的设置数组大小。

b) ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的CopyOnWriteArrayList类。 
注:concurrent并发工具包相关类,会在之后文章中做具体讲解,本文不做赘述,如需了解请查阅相关文章。

c) 每个ArrayList实例都有一个容量(初始容量默认为10)。随着向ArrayList中不断添加元素,其容量也自动增长。 
注:此实现不是同步的。如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。

d) 对于ArrayList而言,它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。

e) 注意扩充容量的方法ensureCapacityInternal。ArrayList在每次增加元素(可能是1个,也可能是一组)时,都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时,就设置新的容量为旧的容量的右移一位+旧容量,如果设置后的新容量还不够,则直接新容量设置为传入的参数(也就是所需的容量),而后用Arrays.copyof()方法将元素拷贝到新的数组。从中可以看出,当容量不够时,每次增加元素,都要将原来的元素拷贝到一个新的数组中,非常之耗时,也因此建议在事先能确定元素数量的情况下,才使用ArrayList,否则建议使用LinkedList。

f) ArrayList是稳定,无序的。稳定性(Order)指集合每次遍历的元素次序是一定的。有序性(Sort)是指遍历的结果按某种比较规则依次排序的。

3 ArrayList源码分析(不同jdk版本源码结构有所不同,本文参考jdk7):

a) ArrayList类 
ArrayList类实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了RandomAccess接口(接口没有定义任何内容),支持快速随机访问,实际上就是通过下标序号进行快速访问,实现了Cloneable接口,能被克隆。

public class ArrayList<E> extends AbstractList<E>        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{123123

b) 私有属性: 
ArrayList只定义两个私有属性:elementData存储ArrayList内的元素,size表示它包含的元素的数量。

    private transient Object[] elementData;    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;1234567812345678

有个关键字需要解释:transient。 
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。(比如,保存用户对象信息,用户包括name,age,sex属性信息,如果不想保存age到数据库,可以对age加上关键字transient, 被标记为transient的属性在对象被序列化的时候不会被保存)。

c) 构造方法: 
ArrayList提供了三种方式的构造器,第一个构造方法使用initialCapacity初始化elementData数组的大小,第二个构造方法,可以构造一个默认初始容量为10的空列表,第三个构造方法则将提供的集合转成数组返回给elementData(返回若不是Object[]将调用Arrays.copyOf方法将其转为Object[])。

    public ArrayList(int initialCapacity) {        super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);        this.elementData = new Object[initialCapacity];
    }    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {        super();        this.elementData = EMPTY_ELEMENTDATA;
    }    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection‘s
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }1234567891011121314151617181920212223242526272829303112345678910111213141516171819202122232425262728293031

d) 重点看一下add(E e)方法:

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;        return true;
    }1234512345

可以看到,add方法,先调用一个确保(调整)内部容量的方法,之后将元素赋给elementData数组,然后size自增,将元素赋给elementData[size]不是会出现下标越界吗,关键就在ensureCapacityInternal(size + 1)中。

    private void ensureCapacityInternal(int minCapacity) {        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }123456789101112131415123456789101112131415

在ensureCapacityInternal方法中判断elementData数组是否为空数组,如果为空,根据Max.max()得到初始容量和当前size两者之间的最大值。 
在ensureExplicitCapacity方法对modCount自增,modCount是记录list结构被改变的次数(每次调用ensureExplicitCapacity方法,modCount的值都将增加,但未必数组结构会改变,所以感觉对modCount的解释不是很到位)。如果添加新元素后,当前size+1大于数组容量,就执行grow方法。

在grow方法中,具体完成扩容实现和数组的copy,可以看出容量扩充的方式是数组容量+数组容量右移一位,基本上等于扩容为原来的1.5倍。数组容量的极限是Integer.MAX_VALUE。

    private void grow(int minCapacity) {        // overflow-conscious code
        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }    private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }1234567891011121314151617181912345678910111213141516171819

数组拷贝通过Arrays.copyof()和System.arraycopy()方法完成。 
首先来看Arrays.copyof()方法。它有很多个重载的方法,但实现思路都是一样的,我们来看泛型版本的源码:

    public static <T> T[] copyOf(T[] original, int newLength) {        return (T[]) copyOf(original, newLength, original.getClass());
    }123123

很明显调用了另一个copyof方法,该方法有三个参数,最后一个参数指明要转换的数据的类型,实现如下:

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));        return copy;
    }1234567812345678

这里可以很明显地看出,该方法实际上是在其内部又创建了一个长度为newlength的数组,调用System.arraycopy()方法,将原来数组中的元素复制到了新的数组中。 
下面来看System.arraycopy()方法。

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,                                        int length);123123

该方法被标记了native,调用了系统的C/C++代码,在JDK中是看不到的,但在openJDK中可以看到其源码。该函数实际上最终调用了C语言的memmove()函数,因此它可以保证同一个数组内元素的正确复制和移动,比一般的复制方法的实现效率要高很多,很适合用来批量处理数组。Java强烈推荐在复制大量数组元素时用该方法,以取得更高的效率。

时间: 2024-10-14 09:04:05

Java集合之List---ArrayList解析的相关文章

Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例

java 集合系列目录: Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例 概要 上一章,我们学习了Collection的架构.这一章开始,我们对Collection的具体实现类进行讲解:首先,讲解List,而List中ArrayList又最为常用.因此,本章我们讲解ArrayList.先对ArrayLis

Java 集合系列: ArrayList详细介绍(源码解析)和使用示例

概要 上一章,我们学习了Collection的架构.这一章开始,我们对Collection的具体实现类进行讲解:首先,讲解List,而List中ArrayList又最为常用.因此,本章我们讲解ArrayList.先对ArrayList有个整体认识,再学习它的源码,最后再通过例子来学习如何使用它. 第1部分 ArrayList介绍 ArrayList简介 ArrayList 是一个数组队列,相当于 动态数组.与Java中的数组相比,它的容量能动态增长.它继承于AbstractList,实现了Lis

Java集合框架:ArrayList

ArrayList定义 package java.util; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{ private static final int DEFAULT_CAPACITY = 10; private static final Object[] EMPTY_ELEME

java集合系列之三(ArrayList)

上一章,我们学习了Collection的架构.这一章开始,我们对Collection的具体实现类进行讲解:首先,讲解List,而List中ArrayList又最为常用.因此,本章我们讲解ArrayList.先对ArrayList有个整体认识,再学习它的源码,最后再通过例子来学习如何使用它.内容包括:第1部分 ArrayList简介第2部分 ArrayList数据结构第3部分 ArrayList源码解析(基于JDK1.6.0_45)第4部分 ArrayList遍历方式第5部分 toArray()异

Java集合---LinkedList源码解析

一.源码解析1. LinkedList类定义2.LinkedList数据结构原理3.私有属性4.构造方法5.元素添加add()及原理6.删除数据remove()7.数据获取get()8.数据复制clone()与toArray()9.遍历数据:Iterator()二.ListItr 一.源码解析 1. LinkedList类定义. public class LinkedList<E> extends AbstractSequentialList<E> implements List&

Java集合系列之ArrayList源码分析

一.ArrayList简介 ArrayList是可以动态增长和缩减的索引序列,它是基于数组实现的List类. 该类封装了一个动态再分配的Object[]数组,每一个类对象都有一个capacity属性,表示它们所封装的Object[]数组的长度,当向ArrayList中添加元素时,该属性值会自动增加.如果想ArrayList中添加大量元素,可使用ensureCapacity方法一次性增加capacity,可以减少增加重分配的次数提高性能. ArrayList的用法和Vector向类似,但是Vect

java集合 collection-list-ArrayList 去除ArrayList集合中的重复元素。

import java.util.*; /* 去除ArrayList集合中的重复元素. */ class ArrayListTest { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02&q

深入理解java集合框架之---------Arraylist集合 -----添加方法

Arraylist集合 -----添加方法 1.add(E e) 向集合中添加元素 /** * 检查数组容量是否够用 * @param minCapacity */ public void ensureCapacity(int minCapacity){ modCount++; int oldCapacity = elementData.length; if(minCapacity > oldCapacity){ Object oldData[] = elementData; int newCa

Java集合框架之ArrayList类

ArrayList是一个泛型数据结构,即对象/引用类型是在<E>里进行确定的(E中定义的必须是对象/引用).例如,定义一个字符串类型的ArrayList为如下格式: ArrayList<String> test = new ArrayList<String>(); 我们可以看出,ArrayList<String>被看成了一个整体. 下面我们看一个简单的例子.代码如下: import java.util.ArrayList; public class Arra

Java集合 之List(ArrayList、LinkedList、Vector、Stack)理解(new)

一. ArrayList底层实现原理 对比 和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList. 总结:(01) ArrayList 实际上是通过一个数组去保存数据的.当我们构造ArrayList时:若使用默认构造函数,则ArrayList的默认容量大小是10.(02) 当ArrayList容量不足以容纳全部元素时,ArrayList会重新设置容量:新的容量="(