java ArrayList 的实现原理

原创 2016年08月31日 15:55:15

1.ArrayList这是我们经常使用到的类,但是对于他是怎么实现的?我们来看一下:

    /**
     * Constructs a new instance of {@code ArrayList} with the specified
     * initial capacity.
     *
     * @param capacity
     *            the initial capacity of this {@code ArrayList}.
     */
    public ArrayList(int capacity) {
        if (capacity < 0) {
            throw new IllegalArgumentException("capacity < 0: " + capacity);
        }
        array = (capacity == 0 ? EmptyArray.OBJECT : new Object[capacity]);
    }

    /**
     * Constructs a new {@code ArrayList} instance with zero initial capacity.
     */
    public ArrayList() {
        array = EmptyArray.OBJECT;
    }

    /**
     * Constructs a new instance of {@code ArrayList} containing the elements of
     * the specified collection.
     *
     * @param collection
     *            the collection of elements to add.
     */
    public ArrayList(Collection<? extends E> collection) {
        if (collection == null) {
            throw new NullPointerException("collection == null");
        }

        Object[] a = collection.toArray();
        if (a.getClass() != Object[].class) {
            Object[] newArray = new Object[a.length];
            System.arraycopy(a, 0, newArray, 0, a.length);
            a = newArray;
        }
        array = a;
        size = a.length;
    }
这就是他的构造参数,从里面你可以看出,他就是一个数组,而他的重要属性就是这些:

/**
     * The minimum amount by which the capacity of an ArrayList will increase.
     * This tuning parameter controls a time-space tradeoff. This value (12)
     * gives empirically good results and is arguably consistent with the
     * RI's specified default initial capacity of 10: instead of 10, we start
     * with 0 (sans allocation) and jump to 12.
     */
    private static final int MIN_CAPACITY_INCREMENT = 12;

    /**
     * The number of elements in this list.
     */
    int size;

    /**
     * The elements in this list, followed by nulls.
     */
    transient Object[] array;
一个数组,一个大小,一个限定值。既然是一个数组那就我们就可以想象的到他的增删数据都是数组数据的移动,我们来验证一下我们的想法:
/**
     * Adds the specified object at the end of this {@code ArrayList}.
     *
     * @param object
     *            the object to add.
     * @return always true
     */
    @Override public boolean add(E object) {
        Object[] a = array;
        int s = size;
        if (s == a.length) {
            Object[] newArray = new Object[s +
                    (s < (MIN_CAPACITY_INCREMENT / 2) ?
                     MIN_CAPACITY_INCREMENT : s >> 1)];
            System.arraycopy(a, 0, newArray, 0, s);
            array = a = newArray;
        }
        a[s] = object;
        size = s + 1;
        modCount++;
        return true;
    }
果然,新建了一个数组,然后数据拷贝,然后新数据的赋值,在这个类中频繁的使用到了 System.arraycopy,Arrays.fill 数组的拷贝。
    /**
     * Removes the object at the specified location from this list.
     *
     * @param index
     *            the index of the object to remove.
     * @return the removed object.
     * @throws IndexOutOfBoundsException
     *             when {@code location < 0 || location >= size()}
     */
    @Override public E remove(int index) {
        Object[] a = array;
        int s = size;
        if (index >= s) {
            throwIndexOutOfBoundsException(index, s);
        }
        @SuppressWarnings("unchecked") E result = (E) a[index];
        System.arraycopy(a, index + 1, a, index, --s - index);
        a[s] = null;  // Prevent memory leak
        size = s;
        modCount++;
        return result;
    }

这里有一个值得注意的地方就是新数组的大小,怎么进行扩大呢?

    /**
     * This method controls the growth of ArrayList capacities.  It represents
     * a time-space tradeoff: we don't want to grow lists too frequently
     * (which wastes time and fragments storage), but we don't want to waste
     * too much space in unused excess capacity.
     *
     * NOTE: This method is inlined into {@link #add(Object)} for performance.
     * If you change the method, change it there too!
     */
    private static int newCapacity(int currentCapacity) {
        int increment = (currentCapacity < (MIN_CAPACITY_INCREMENT / 2) ?
                MIN_CAPACITY_INCREMENT : currentCapacity >> 1);
        return currentCapacity + increment;
    }
到这里,可以了解到ArrayList 实际就是一个数组,他不能保证线程安全。


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

深入学习java之ArrayList 实现原理(一)

最近有时间整理了一下ArrayLIst的实现原理,因为在开发项目的应用的比较多,比如在处理比较复杂的业务时候,需要遍历来查找数据和操作数据,有些时候还有到数据进行排序等,所以对经常处理业务比较多的童鞋...

【深入理解java集合系列】ArrayList实现原理

1. ArrayList概述:    ArrayList是List接口的可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来...

java集合--ArrayList的实现原理

转载于:http://blog.csdn.net/qq_35101189/article/details/60756478 目录:       一、 ArrayList概述...

Java源代码阅读——ArrayList实现原理

一  概述 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io...

深入Java集合学习系列:ArrayList的实现原理

1. ArrayList概述:    ArrayList是List接口的可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提...

java集合框架学习—ArrayList的实现原理

 转自:http://zhangshixi.iteye.com/blog/6748561. ArrayList概述:   ArrayList是List接口的可变数组的实现。实现了所有可选列表操作,并允...
  • FG2006
  • FG2006
  • 2011年05月06日 16:44
  • 2411

Java集合---ArrayList的实现原理

一、 ArrayList概述:   ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存。       ArrayList...

Java集合学习:ArrayList的实现原理

1.概述         ArrayList是List接口的可变数组的实现,其实现了所有可选列表操作,允许包括null在内的所有元素。基本上等同于Vector,但它只对writeObject()...

Java进阶--深入理解ArrayList实现原理

ArrayList简介ArrayList就是动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了动态的增加和减少元素,实现了Collection和List接口,可以灵活的设置数组的大小。要...

Java ArrayList的实现原理详解

ArrayList是Java List类型的集合类中最长使用的,本文基于Java1.8,对于ArrayList的实现原理做一下详细讲解。 一、ArrayList实现原理总结 ArrayList...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java ArrayList 的实现原理
举报原因:
原因补充:

(最多只允许输入30个字)