JDK1.7源码分析之ArrayList

最新推荐文章于 2022-05-11 23:53:29 发布
最新推荐文章于 2022-05-11 23:53:29 发布
阅读量88 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/showMeOneDay/blog/898125
版权

   private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 默认的 初始化长度10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空的数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 不可被序列化的存储对象 当为空时 默认第一次添加是自动扩容为10
     */
    private transient Object[] elementData;

    /**
     *数组对象的个数  
     * 
     */
    private int size;

    /**
     * 有参构造 制定数组长度
     *
     */
    public ArrayList(int initialCapacity) {
       //制定小于0抛异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
       //创建一个制定的大小的对象 
        this.elementData = new Object[initialCapacity];
    }

    /**
     * 无参创建一个空的数组此时不指定数组缓冲区长度 当第一次扩容时如果是空 那么就默扩10 
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 创建一个包含collection的Arraylist
     */
    public ArrayList(Collection<? extends E> c) {
       //把collection对象转换成数组 
        elementData = c.toArray();
        //把数组长度赋值
        size = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

    /**
     * 根据实际数字size 来设置缓冲区大小 
     */
        public void trimToSize() {
        //操作数字计数变量
        modCount++;
        //如果当前数组个数小于当前数组缓冲区值
        if (size < elementData.length) {
        //创建新的指定大小数字
        elementData = Arrays.copyOf(elementData, size);
        }
    }

    /**
     * 将集合的容器增加到最小
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != EMPTY_ELEMENTDATA)
            // any size if real element table
            ? 0
            // larger than default for empty table. It's already supposed to be
            // at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    //保证最小值
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //当前的最小值和elementData.length 作比较看是否需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//扩容
    }

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     *扩容方法：从扩容方法可以看到 扩容的原理是copy值到新的数组，这样会消耗性能，最好在使用时能确定大小
     */
    private void grow(int minCapacity) {
        //获取当前数字长度
        int oldCapacity = elementData.length;
        //获取当前长度的1.5倍 oldCapacity>>1 是将oldCapacity右位移1位 相当于oldCapacity/2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //扩容满足不了 就设置需要的长度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //扩容是否超过最大值限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //将原来的数组copy到新的数字中
        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;
    }

    /**
     * 得到数字里的个数
     */
    public int size() {
        return size;
    }

    /**
     * 是否为空 
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 是否包含某个元素 默认调用indexof方法
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     *是否包含某元素 循环比例 有就返回元素所在脚标 没有返回-1
     *
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 某元是最后出现的位置 倒序遍历查找
     */
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 
     */
    public Object clone() {
        try {
            @SuppressWarnings("unchecked")
            //调用父类clone()生成新对象
            ArrayList<E> v = (ArrayList<E>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            //设置操作频率
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

    /**
     *把对象变成array数字 利用Arrayscopy函数
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    /*
     *返回一个包含ArrayList中所有元素的数组
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    //获取某个脚标的元素

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     *得到指定脚标某元素
     */
    public E get(int index) {
        //检查是否索引越界
        rangeCheck(index);
        //获取某个脚标的元素
        return elementData(index);
    }

    /**
     * 制定脚标位置插入值 返回其原来的值
     */
    public E set(int index, E element) {
        //检查索引是否越界
        rangeCheck(index);
        /获取其原来值
        E oldValue = elementData(index);
        //替换成新值
        elementData[index] = element;
        return oldValue;
    }

    /**
     *添加新元素 返回boolean类型
     */
    public boolean add(E e) {
        //判断是否需要扩容
        ensureCapacityInternal(size + 1);  
        //在数组最末尾添加新元素
        elementData[size++] = e;
        return true;
    }

    /**
     * 在指定位置添加元素
     */
    public void add(int index, E element) {
        //检查索引是否越界
        rangeCheckForAdd(index);
        //检查是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    /**
     * 删除指定元素
     */
    public E remove(int index) {
        //检测索引是否越界
        rangeCheck(index);

        modCount++;
        //得到当前脚标元素
        E oldValue = elementData(index);
        
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
        //最后一个元素设置null
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

    /**
     *删除指定某个元素(第一次出现) 循环遍历得到指定元素脚标调用fastRemove() 返回boolean类型;
     */
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    /*
     *快速删除指定元素
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

    /**
     * 清空arrayList 注意 此清空不会改变容量的大小
     */
    public void clear() {
        modCount++;

        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

    /**
     *按照c的迭代器所返回的元素顺序，将c中的所有元素添加到此列表的尾部
     */
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     *指定位置添加 
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    /**
     * 删除fromindex -toindex之间的元素
     */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        //删除后的元素个数
        int numMoved = size - toIndex;
        //将删除索引后面的元素复制到以fromIndex为起始位置的存储空间中去
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);
        int newSize = size - (toIndex-fromIndex);
        
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    /**
     * 检查是否索引越界
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * A version of rangeCheck used by add and addAll.
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    /**
     * 
     */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    /**
     * 清空ArrayList包含collection的元素
     */
    public boolean removeAll(Collection<?> c) {
        return batchRemove(c, false);
    }

    /**
     * 删除ArrayList中除包含在Collection中的元素，和removeAll相反
     */
    public boolean retainAll(Collection<?> c) {
        return batchRemove(c, true);
    }

    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

    /**
     * 将ArrayList的所有元素写入到输出流中 
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    /**
     读取数据
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

    

转载于:https://my.oschina.net/showMeOneDay/blog/898125

chenyu9162
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ArrayList源码解析(基于JDK1.7)
想作会飞的鱼的博客
08-22 1023
一、ArrayList简介ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类。ArrayList的用法和Vector向类似，但是Vector是一个较老的集合，具有很多缺点，不建议使用。另外，ArrayList和Vector的区别是：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序需要手动保证该集合的同步性，而Vector则是线程安全的。
jdk1.7 ArrayList源码学习
weixin_44733528的博客
07-30 287
ArrayLlist简介ArrayLlist简介ArrayList的继承结构ArrayList的属性ArrayList的构造函数ArrayList的普通方法ArrayLlist的迭代器ArrayList的视图SubList ArrayLlist简介 ArrayList位于jak的util包中的一个集合类，他的底层是一个动态数组。和java中的数组相比ArrayList可以动态扩容，其实Array...
集合详解（二）----ArrayList源代码剖析（JDK1.7）
令仔很忙
07-25 2134
ArrayList是List类的一个典型的实现，是基于数组实现的List类，因此，ArrayList封装了一个动态的、可变长度的Object[]数组。ArrayList是通过initialCapacity参数来设置数组长度的，当向ArrayList添加的数据超出了ArrayList的长度之后，initialCapacity会自动增加
jdk1.7--ArrayList
the_spring的博客
07-25 568
java基础之ArrayList
jdk1.7之ArrayList
luppy01的专栏
05-17 694
public class ArrayList extends AbstractList         implements List, RandomAccess, Cloneable, java.io.Serializable { //序列化号     private static final long serialVersionUID = 8683452581122892189L;
jdk1.7源码
02-01
JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。
jdk1.7 jdk1.8源码包
11-09
JDK1.7,JDK1.8源码包 经常需要看JDK的源码，看了一下，别人提供的源码包需要50积分才能下载。本机刚刚好安装了两个版本的源码1.7 和 1.8 就免费共享给大家咯
java jdk 1.7官网免安装版本
10-25
java jdk 1.7官网免安装版本，解压就可以直接使用，不用再官网登录账号就可以直接下载，省去很多麻烦，不用各种等待，直接使用csdn平台就可以直接下载。
JDK1.7源码包
04-11
JDK1.7源码包JDK1.7源码包JDK1.7源码包JDK1.7源码包JDK1.7源码包
JDK1.7源码
11-28
JDK1.7源码，包含com包、java包、javax包、lanuncher包、org包、sun包、sunw包
ArrayList(jdk1.7)了解一下
涛涛之海
03-16 247
文章目录1.基本用法2.ArrayList的主要方法3.add方法和remove方法4.迭代Iterator接口迭代器如何迭代器的好处5.ArrayList 实现的接口6.ArrayList的其他方法7.ArrayList 特点分析8.参考文章 1.基本用法 ArrayList 是一个泛型容器，新建ArrayList需要实例化泛型参数。 ArrayList<Integer> intLi...
Java集合框架（二）：JDK1.7的ArrayList源码解析
GDUT_Trim的博客
06-04 249
ArrayListJDK1.7变量和常量方法构造新增元素add(E e)方法add(int index,E element)方法删除元素修改元素克隆方法 ArrayList JDK1.7 我们首先来看看JDK1.7的ArrayList 可以看到ArrayList继承了AbstractList，同时也实现了List接口，这里的List接口是冗余的了，因为AbstractList也是实现了List接口，所以只需要去继承了AbstractList就好了，作者也承认了这方面问题 所以ArrayList拥有Abs.
java jdk1.7版本的ArrayList原理解析
LZJLZJLZJLZJLZJLZJ的专栏
08-23 1455
上一篇文章中我们了解了LinkedList集合的底层实现原理，这一篇将研究下ArrayList的实现原理。 同样的通过源码解释，我们可以得到以下信息： （1）、ArrayList是一个长度可变的数组集合，创建ArrayList实例时没有指定长度，当添加数据，而且数据个数小于10时，那么默认将会创建一个容量为10的数组存储数据；当数组不够长时，将会默认增长原来容量的一半。如果要自定义ArrayLi
JDK1.7与1.8中ArrayList源码分析
weixin_45949103的博客
01-02 383
JDK1.7和1.8中ArrayList的源码分析
jdk1.7.0_80版本 ArrayList集合解析
Allen的博客
03-06 684
ArrayLIst 集合存在于Java.Util包路径下 重复性 可以存放重复的数值 null值 可以有null值存在 有序性 可以保证元素插入有序 底层数据结构 ArrayList集合底层元素保存在数组中 源码研究 继承关系 public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; implem...
Java中ArrayListJDK1.7和1.8的区别(底层)~ (2022.5.11)
weixin_66262328的博客
05-11 608
坚持就是胜利！加油呀！每天进步一点点！
[JDK1.7源码阅读]ArrayList
代码有毒的博客
07-22 1552
原文：http://www.mrcode.cn/zhuqiang/article/details/39.html 从结构来看 4个顶层接口来看至少有以下功能 实现继承 从功能阅读-简单函数开始 构造函数 add - 将指定的元素添加到此列表的尾部 add - 将指定的元素插入此列表中的指定位置 核心函数1确保足够的列表容量 remove - 按索引移除元素 remove - 移除指定的元素 set
Java集合JDK1.7(源码分析)之ArrayList
Ao_dream的博客
03-27 680
第一部分：ArrayList介绍        ArrayList是一个动态的数组,与java的数组相比较，java数组的长度在定义的时候或者是通过复制形式创建时已经确定了其容器的大小，而ArrayList的容器大小是动态增长的。    查看JDK1.7源码我们知道ArrayList类继承AbstractList这个抽象类，并且还实现了RandomAccess、Cloneable、SerialIz...
Java集合类框架学习 2 —— ArrayList(JDK1.8/JDK1.7/JDK1.6)
十二页的博客
02-25 4285
这一篇开始说ArrayList 参考代码为jdk1.6_45 jdk1.7_80 jdk1.8_111中的源码，对比阅读，发现修改的问题以及改进点 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable 一、基本性质
jdk1.7 .zip
最新发布
11-23
jdk 1.7是Java Development Kit（Java开发工具包）的一个版本，它提供了用于开发和运行Java程序的工具和库。.zip文件是一种常见的压缩文件格式，用于存储和传输文件。因此，jdk1.7 .zip可以理解为jdk 1.7版本的压缩文件。 使用jdk 1.7 .zip文件可以方便地在不同的计算机上安装和部署jdk 1.7。用户可以下载这个压缩文件，然后解压缩到他们的计算机上，从而获取jdk 1.7的所有文件和目录。这样就可以在他们的计算机上开发和运行基于Java的应用程序。 同时，压缩文件还能够有效地减小文件的大小，从而节省存储空间和加快文件传输速度。 总之，jdk 1.7 .zip文件是jdk 1.7版本的压缩文件，可以方便地在多台计算机上安装和部署jdk 1.7，并且可以有效地节省存储空间和加快文件传输速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值