Java集合框架剖析(3)——ArrayList

最新推荐文章于 2023-04-04 18:10:32 发布
最新推荐文章于 2023-04-04 18:10:32 发布
阅读量233 收藏
点赞数
分类专栏： Java Collection
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sicofield/article/details/79761643
版权

ArrayList

这里写图片描述
ArrayList继承了AbstractList，实现了List。它是一个数组队列，相当于动态数组。提供了相关的添加、删除、修改和遍历等功能。

ArrayList实现了RandomAccess接口，即提供了随机访问功能。RandomAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号来快速获取元素对象，这就是快速随机访问。下文会比较List的“快速随机访问”和使用“Iterator迭代器访问”的效率。

ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

ArrayList实现了java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

和Vector不同，ArrayList中的操作是非线程安全的。所以建议在单线程中使用ArrayList，在多线程中选择Vector或者CopyOnWriteArrayList。

接口总览

这里写图片描述
ArrayList包含了两个重要的对象：elementData和size。
这里写图片描述
elementData是Object[]类型的数组，它保存了添加到ArrayList中的元素。实际上，elementData是一个动态数组，我们能通过ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity。如果通过不含参数的构造函数来创建ArrayList，则elementData是一个空数组（后面会调整其大小）。elementData数组的大小会根据ArrayList容量的增长而动态的增长。
size则是动态数组实际的大小。

源码解析

属性

这里写图片描述
看transient Object[] elementData 的注释，当一个空的ArrayList加入第一个元素的时候就会将容量扩充到10(DEFAULT_CAPACITY)

构造函数

这里写图片描述

容量相关

这里写图片描述
public的接口可以提供给外部调用
这里写图片描述
当然还有两个内部private的接口用于扩充容量
这里写图片描述
另外要提一下的是ArrayList是有最大长度的，超过这个长度就会有OutOfMemory的Exception
这里写图片描述

搜索相关

这里写图片描述

clone

这里写图片描述

toArray

这里写图片描述

位置操作

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

迭代器

（这边需要重写）

/******************************** Iterators ************************************/  

    /** 
    * 该部分的方法重写了AbstractList抽象类中Iterator部分的方法，因为ArrayList继承 
    * 了AbstractList，基本大同小异，只是这里针对本类的数组，思想与AbstractList一致 
    * 可以参照上一章Collection架构与源码分析的AbatractList部分 
    */  
    public ListIterator<E> listIterator(int index) {  
        if (index < 0 || index > size)  
            throw new IndexOutOfBoundsException("Index: "+index);  
        return new ListItr(index);  
    }  

    public ListIterator<E> listIterator() {  
        return new ListItr(0);  
    }  

    public Iterator<E> iterator() {  
        return new Itr();  
    }  

    private class Itr implements Iterator<E> {  
        int cursor;       // index of next element to return  
        int lastRet = -1; // index of last element returned; -1 if no such  
        int expectedModCount = modCount;  

        public boolean hasNext() {  
            return cursor != size;  
        }  

        @SuppressWarnings("unchecked")  
        public E next() {  
            checkForComodification();  
            int i = cursor;  
            if (i >= size)  
                throw new NoSuchElementException();  
            Object[] elementData = ArrayList.this.elementData;  
            if (i >= elementData.length)  
                throw new ConcurrentModificationException();  
            cursor = i + 1;  
            return (E) elementData[lastRet = i];  
        }  

        public void remove() {  
            if (lastRet < 0)  
                throw new IllegalStateException();  
            checkForComodification();  

            try {  
                ArrayList.this.remove(lastRet);  
                cursor = lastRet;  
                lastRet = -1;  
                expectedModCount = modCount;  
            } catch (IndexOutOfBoundsException ex) {  
                throw new ConcurrentModificationException();  
            }  
        }  

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

    private class ListItr extends Itr implements ListIterator<E> {  
        ListItr(int index) {  
            super();  
            cursor = index;  
        }  

        public boolean hasPrevious() {  
            return cursor != 0;  
        }  

        public int nextIndex() {  
            return cursor;  
        }  

        public int previousIndex() {  
            return cursor - 1;  
        }  

        @SuppressWarnings("unchecked")  
        public E previous() {  
            checkForComodification();  
            int i = cursor - 1;  
            if (i < 0)  
                throw new NoSuchElementException();  
            Object[] elementData = ArrayList.this.elementData;  
            if (i >= elementData.length)  
                throw new ConcurrentModificationException();  
            cursor = i;  
            return (E) elementData[lastRet = i];  
        }  

        public void set(E e) {  
            if (lastRet < 0)  
                throw new IllegalStateException();  
            checkForComodification();  

            try {  
                ArrayList.this.set(lastRet, e);  
            } catch (IndexOutOfBoundsException ex) {  
                throw new ConcurrentModificationException();  
            }  
        }  

        public void add(E e) {  
            checkForComodification();  

            try {  
                int i = cursor;  
                ArrayList.this.add(i, e);  
                cursor = i + 1;  
                lastRet = -1;  
                expectedModCount = modCount;  
            } catch (IndexOutOfBoundsException ex) {  
                throw new ConcurrentModificationException();  
            }  
        }  
    }  

    public List<E> subList(int fromIndex, int toIndex) {  
        subListRangeCheck(fromIndex, toIndex, size);  
        return new SubList(this, 0, fromIndex, toIndex);  
    }  

    static void subListRangeCheck(int fromIndex, int toIndex, int size) {  
        if (fromIndex < 0)  
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);  
        if (toIndex > size)  
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);  
        if (fromIndex > toIndex)  
            throw new IllegalArgumentException("fromIndex(" + fromIndex +  
                                               ") > toIndex(" + toIndex + ")");  
    }  

    private class SubList extends AbstractList<E> implements RandomAccess {  
        private final AbstractList<E> parent;  
        private final int parentOffset;  
        private final int offset;  
        int size;  

        SubList(AbstractList<E> parent,  
                int offset, int fromIndex, int toIndex) {  
            this.parent = parent;  
            this.parentOffset = fromIndex;  
            this.offset = offset + fromIndex;  
            this.size = toIndex - fromIndex;  
            this.modCount = ArrayList.this.modCount;  
        }  

        public E set(int index, E e) {  
            rangeCheck(index);  
            checkForComodification();  
            E oldValue = ArrayList.this.elementData(offset + index);  
            ArrayList.this.elementData[offset + index] = e;  
            return oldValue;  
        }  

        public E get(int index) {  
            rangeCheck(index);  
            checkForComodification();  
            return ArrayList.this.elementData(offset + index);  
        }  

        public int size() {  
            checkForComodification();  
            return this.size;  
        }  

        public void add(int index, E e) {  
            rangeCheckForAdd(index);  
            checkForComodification();  
            parent.add(parentOffset + index, e);  
            this.modCount = parent.modCount;  
            this.size++;  
        }  

        public E remove(int index) {  
            rangeCheck(index);  
            checkForComodification();  
            E result = parent.remove(parentOffset + index);  
            this.modCount = parent.modCount;  
            this.size--;  
            return result;  
        }  

        protected void removeRange(int fromIndex, int toIndex) {  
            checkForComodification();  
            parent.removeRange(parentOffset + fromIndex,  
                               parentOffset + toIndex);  
            this.modCount = parent.modCount;  
            this.size -= toIndex - fromIndex;  
        }  

        public boolean addAll(Collection<? extends E> c) {  
            return addAll(this.size, c);  
        }  

        public boolean addAll(int index, Collection<? extends E> c) {  
            rangeCheckForAdd(index);  
            int cSize = c.size();  
            if (cSize==0)  
                return false;  

            checkForComodification();  
            parent.addAll(parentOffset + index, c);  
            this.modCount = parent.modCount;  
            this.size += cSize;  
            return true;  
        }  

        public Iterator<E> iterator() {  
            return listIterator();  
        }  

        public ListIterator<E> listIterator(final int index) {  
            checkForComodification();  
            rangeCheckForAdd(index);  
            final int offset = this.offset;  

            return new ListIterator<E>() {  
                int cursor = index;  
                int lastRet = -1;  
                int expectedModCount = ArrayList.this.modCount;  

                public boolean hasNext() {  
                    return cursor != SubList.this.size;  
                }  

                @SuppressWarnings("unchecked")  
                public E next() {  
                    checkForComodification();  
                    int i = cursor;  
                    if (i >= SubList.this.size)  
                        throw new NoSuchElementException();  
                    Object[] elementData = ArrayList.this.elementData;  
                    if (offset + i >= elementData.length)  
                        throw new ConcurrentModificationException();  
                    cursor = i + 1;  
                    return (E) elementData[offset + (lastRet = i)];  
                }  

                public boolean hasPrevious() {  
                    return cursor != 0;  
                }  

                @SuppressWarnings("unchecked")  
                public E previous() {  
                    checkForComodification();  
                    int i = cursor - 1;  
                    if (i < 0)  
                        throw new NoSuchElementException();  
                    Object[] elementData = ArrayList.this.elementData;  
                    if (offset + i >= elementData.length)  
                        throw new ConcurrentModificationException();  
                    cursor = i;  
                    return (E) elementData[offset + (lastRet = i)];  
                }  

                public int nextIndex() {  
                    return cursor;  
                }  

                public int previousIndex() {  
                    return cursor - 1;  
                }  

                public void remove() {  
                    if (lastRet < 0)  
                        throw new IllegalStateException();  
                    checkForComodification();  

                    try {  
                        SubList.this.remove(lastRet);  
                        cursor = lastRet;  
                        lastRet = -1;  
                        expectedModCount = ArrayList.this.modCount;  
                    } catch (IndexOutOfBoundsException ex) {  
                        throw new ConcurrentModificationException();  
                    }  
                }  

                public void set(E e) {  
                    if (lastRet < 0)  
                        throw new IllegalStateException();  
                    checkForComodification();  

                    try {  
                        ArrayList.this.set(offset + lastRet, e);  
                    } catch (IndexOutOfBoundsException ex) {  
                        throw new ConcurrentModificationException();  
                    }  
                }  

                public void add(E e) {  
                    checkForComodification();  

                    try {  
                        int i = cursor;  
                        SubList.this.add(i, e);  
                        cursor = i + 1;  
                        lastRet = -1;  
                        expectedModCount = ArrayList.this.modCount;  
                    } catch (IndexOutOfBoundsException ex) {  
                        throw new ConcurrentModificationException();  
                    }  
                }  

                final void checkForComodification() {  
                    if (expectedModCount != ArrayList.this.modCount)  
                        throw new ConcurrentModificationException();  
                }  
            };  
        }  

        public List<E> subList(int fromIndex, int toIndex) {  
            subListRangeCheck(fromIndex, toIndex, size);  
            return new SubList(this, offset, fromIndex, toIndex);  
        }  

        private void rangeCheck(int index) {  
            if (index < 0 || index >= this.size)  
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
        }  

        private void rangeCheckForAdd(int index) {  
            if (index < 0 || index > this.size)  
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
        }  

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

        private void checkForComodification() {  
            if (ArrayList.this.modCount != this.modCount)  
                throw new ConcurrentModificationException();  
        }  
    }  
}

总结

  1. ArrayList实际上是通过一个数组去保存数据的，当我们构造ArrayList时，如果使用默认构造函数，最后ArrayList的默认容量大小是10。
  2. 当ArrayList容量不足以容纳全部元素时，ArrayList会自动扩张容量，新的容量 = 原始容量 + 原始容量 / 2。
  3. ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
  4. ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写出“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

ArrayList遍历方式

ArrayList支持三种遍历方式
这里写图片描述
猜猜哪个效率最高！！
其实应该是随机访问效率最高， 因为ArrayList内部的存储就是个数组，直接用内存地址偏移寻址肯定要比迭代器快。
可以做个试验：

import java.util.*;  

/* 
 * @description ArrayList三种遍历方式效率的测试 
 * @author eson_15 
 */  
public class ArrayListRandomAccessTest {  

    public static void main(String[] args) {  
        List<Integer> list = new ArrayList<Integer>();  
        for (int i=0; i<500000; i++)  
            list.add(i);  
        isRandomAccessSupported(list);//判断是否支持RandomAccess  
        iteratorThroughRandomAccess(list) ;  
        iteratorThroughIterator(list) ;  
        iteratorThroughFor(list) ;  

    }  

    private static void isRandomAccessSupported(List<Integer> list) {  
        if (list instanceof RandomAccess) {  
            System.out.println("RandomAccess implemented!");  
        } else {  
            System.out.println("RandomAccess not implemented!");  
        }  

    }  

    public static void iteratorThroughRandomAccess(List<Integer> list) {  

        long startTime;  
        long endTime;  
        startTime = System.currentTimeMillis();  
        for (int i=0; i<list.size(); i++) {  
            list.get(i);  
        }  
        endTime = System.currentTimeMillis();  
        long interval = endTime - startTime;  
        System.out.println("RandomAccess遍历时间：" + interval+" ms");  
    }  

    public static void iteratorThroughIterator(List<Integer> list) {  

        long startTime;  
        long endTime;  
        startTime = System.currentTimeMillis();  
        for(Iterator<Integer> it = list.iterator(); it.hasNext(); ) {  
            it.next();  
        }  
        endTime = System.currentTimeMillis();  
        long interval = endTime - startTime;  
        System.out.println("Iterator遍历时间：" + interval+" ms");  
    }  


    @SuppressWarnings("unused")  
    public static void iteratorThroughFor(List<Integer> list) {  

        long startTime;  
        long endTime;  
        startTime = System.currentTimeMillis();  
        for(Object obj : list)  
            ;  
        endTime = System.currentTimeMillis();  
        long interval = endTime - startTime;  
        System.out.println("For循环遍历时间：" + interval+" ms");  
    }  
}

测试结果（多次平均值）：

RandomAccess(ms)Iterator(ms)For(ms)
4.97.17.4
sicofield
关注
专栏目录
Java 集合框架源码分析(一)——ArrayList
BridgeGeorge
08-08 1308
简介ArrayList中是平常比较常用的一个集合类，经常帮助我们封装一些实体Bean的List集合。典型使用场景如下： List<Book> bookList=new ArrayList<Book>(); bookList.add(book1); bookList.add(book2); ...ArrayList位于java.util 属于Java集合框架的一部分。层次关系如下。
Java集合框架源码解读(1)——ArrayList、LinkedList和Vector
liinux-Talk is cheap,show me the code.
05-02 268
java.util.List接口是Java Collections Framework的一个重要组成部分，List接口的架构图如下： 本文将通过剖析List接口的三个实现类——ArrayList、LinkedList和Vector的源码，带你走近List的世界。 ArrayList ArrayList是List接口可调整数组大小的实现。实现所有可选列表操作，并允许放入包括空值在内的所有元...
JAVA基础08-集合框架（三）ArrayList
qq_36675851的博客
11-28 136
（1）ArrayList简介 ArrayList是一个动态数组，它的容量能够动态增长，它继承于AbstractList，实现了List,RandomAccess, Cloneable, java.io.Serializable这些接口。 ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。 ArrayList 实现了Ran...
集合框架专题3—ArrayList
xanaduliu的专栏
09-29 249
ArrayList         前言： 本文所采用的jdk版本为：jdk1.8.0_111。         一、首先我们来看一下ArrayList的成员变量 private static final int DEFAULT_CAPACITY = 10; private static final Object[] EMPTY_ELEMENTDATA =
java添加项目_如何实例化ArrayList <?>并通过Java反射添加项目？
weixin_31942999的博客
02-21 152
我正在编写一个将xml转换为Java对象的反序列化方法。我想动态地做到这一点，并避免编写特定类型的硬编码引用。如何实例化ArrayList >并通过Java反射添加项目？例如，这是我的一个类的简化版本。public class MyObject {public ArrayList SubObjects = new ArrayList();}下面是该方法的一个精简版：public class ...
ArrayList的多态性
leafinsnowfield的专栏
08-16 1264
import java.util.*; public class TestGenerics3 { public static void main(String [] args) { new TestGenerics3().go(); } public void go() { ArrayList animals=new ArrayList(); animals.add(new
关于ArrayList源码的一些自我理解以及解析（五）：sublist方法原来如此
GhostPaints的博客
02-15 475
之前了解了ArrayList的一个内部类Itr，在看了Itr的源码之后，知道它是如何工作的，以及知道并了解了cursor和lastRet之间的关系。在后面发现了Itr的子类： /** * An optimized version of AbstractList.ListItr */ private class ListItr extends Itr impl...
Java集合框架系列之——ArrayList
weixin_45548936的博客
02-15 180
ArrayList类全解析，包含方法函数与扩容策略
Java集合框架——ArrayList源码实现分析
三冬暖
04-04 364
首先看源码的简介分析List 接口的可调整大小数组实现。实现所有可选的列表操作，并允许所有元素，包括 null。除了实现 List 接口之外，此类还提供了操作内部用于存储列表的数组大小的方法。（此类大致等同于 Vector，只是它是不同步的。ArrayList可以看成是一个动态数组，它是基于数组实现的。因为底层是数组，所以ArratList也是查询速度快，插入，删除效率相对低的特点。
java集合框架05——ArrayList和LinkedList的区别
热门推荐
武哥聊编程
04-13 10万+
前面已经学习完了List部分的源码，主要是ArrayList和LinkedList两部分内容，这一节主要总结下List部分的内容。 List概括 先来回顾一下List在Collection中的的框架图： 从图中我们可以看出： 1. List是一个接口，它继承与Collection接口，代表有序的队列。 2. AbstractList是一个抽象类，它继承与AbstractColle
学习JAVA编程，完成作业——编一个控制台梭哈游戏.zip
12-17
此外，Java集合框架如ArrayList、LinkedList、HashMap等也是编程过程中经常用到的数据结构。 在游戏开发中，面向对象编程（OOP）是非常关键的。在这个梭哈游戏中，可以预见到类的使用，如Player、Card、Deck等。...
Java大作业安卓开发——Word-Ocean Dictionary(词海).zip
06-15
- **集合框架**：在处理大量数据时，如单词和它们的解释，Java集合框架（如ArrayList、HashMap）是非常有用的工具。 **Android开发基础知识** - **Activity与Intent**：Activity是Android应用的基本单元，用于展示...
Java集合框架——List集合练习
kingdom_C的博客
02-14 537
Java集合框架——List集合练习 练习一：随机生成10个1~20的随机数，要求不能重复 练习二：键盘录入多个整数并以0结束，求录入数据中的最大值
面向多场景应用的光网络通感一体化架构和关键技术方案研究.pdf
09-28
面向多场景应用的光网络通感一体化架构和关键技术方案研究
基于Vue框架的Digital Twin开发设计源码
09-28
该项目是基于Vue框架的Digital Twin开发设计源码，由38个文件组成，涉及TypeScript、JavaScript、Vue、CSS、HTML等多种编程语言，包括9个TypeScript文件、6个JavaScript文件、5个JSON文件、5个Vue文件、3个SVG文件、2个Markdown文件、2个WebAssembly文件、1个Git忽略文件、1个HTML文件和1个CSS文件。该源码旨在提供大学生在线学术交流的平台，助力学术创新与协作。
基于Java和C++技术的易涂鸦设计源码
09-28
该项目是一款基于Java和C++技术的易涂鸦设计平台源码，包含487个文件，其中Java源文件226个，PNG图片文件135个，XML配置文件88个，其他类型文件包括brush文件7个，gradle文件4个，jpg文件4个，gitignore文件3个，properties文件3个，md文件2个，txt文件2个。该平台专注于涂鸦功能，为用户提供便捷的设计与绘图体验。
基于HTML/CSS/JavaScript的多人在线知识交流平台博客项目设计源码
09-28
该项目是一款基于HTML、CSS和JavaScript的多人在线知识交流平台博客，设计源码包含451个文件，其中包括149个Java文件、89个JavaScript文件、60个CSS文件、42个Class文件、23个PNG图片文件、20个XML文件、17个HTML文件、12个JPG文件、6个JSON文件、5个Map文件，旨在为用户提供一个互动的知识分享与交流空间。
开关电源工作原理及电路图技术资料开发设计用的重要资料.zip
09-28
开关电源工作原理及电路图技术资料开发设计用的重要资料.zip
基于Plpgsql与Java的学生管理系统设计源码
最新发布
09-28
该项目是一款基于Plpgsql与Java开发的学生管理系统源码，总计包含190个文件。其中，165个为Java源文件，11个为XML配置文件，4个为YAML配置文件，2个为Git忽略文件，1个为Dockerfile，1个为LICENSE文件，1个为Markdown文件，1个为JSON文件，1个为Maven命令行脚本，以及1个为Windows命令文件。该系统旨在提供全面的学生信息管理功能。
Java集合框架深度解析：Map、Set、List源码探秘
Map、Set和List是Java集合框架的三大基本接口，它们各自有不同的特性和用途。 Map接口提供了一种通过键（Key）来查找对应的值（Value）的数据结构。文档中提到的Map底层原理分析，可能涵盖了HashMap、TreeMap等实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值