文档章节

关于ArrayList知识的整理

laohng1995
 laohng1995
发布于 2017/07/24 21:31
字数 951
阅读 11
收藏 0

ArrayList 继承 AbstractList<E> 实现:List<E>, RandomAccess, Cloneable, java.io.Serializable

属性:

    private static final int DEFAULT_CAPACITY = 10;   //初始化一个容量大小
   
    private static final Object[] EMPTY_ELEMENTDATA = {};//这是一个空的数组
  
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//这是一个默认大小的空数组
 
    transient Object[] elementData;     //数组引用

    
构造函数

       public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];       //创建一个数组,数组长度initialCapacity
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;                 //引用一个空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


         public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;    //引用默认的数组(默认长度)
    }


         public ArrayList(Collection<? extends E> c) {             //传入的参数是Collection
        elementData = c.toArray();                                 //将c转换为数组类型传入
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

方法:

    public void ensureCapacity(int minCapacity) {                      //指定最小参数 如果数组的初始化没有设定初始值,
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)    //那么数组就是一个空数组,数组长度为0
            // any size if not default element table
            ? 0
            : DEFAULT_CAPACITY;                                       //minExpand为0或者DEFAULT_CAPACITY

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

     private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)                             //判断最小长度大于elementData.length
            grow(minCapacity);                                                //数组长度增加
     }

     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;
    }

    public int size() {
        return size;                                                          //获取数组长度
    }

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

     public boolean contains(Object o) {
        return indexOf(o) >= 0;                                                //判断是否包含o
    }

     public int indexOf(Object o) {                                            
        if (o == null) {                                                       //判断是否存在o
            for (int i = 0; i < size; i++)                                   
                if (elementData[i]==null)
                    return i;                                                  //如果不存在o则返回数组的长度
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))                                  //判断是否包含o
                    return i;                                                  //返回
        }
        return -1;
    }

     public <T> T[] toArray(T[] a) {                                          
        if (a.length < size)
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());      //拷贝一个数组,扩展数组长度为size
        System.arraycopy(elementData, 0, a, 0, size);                         //创建一个数组,把elementData从开始位置复制到 a数组从0位置开始,长度为size
        if (a.length > size)
            a[size] = null;
        return a;
    }

     E elementData(int index) {
        return (E) elementData[index];                                       // 返回一个对象
    }

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(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;
    }
    
    private void ensureCapacityInternal(int minCapacity) {                  //minCapacity=size+1
        if (elementData == DEFAULTCAPACITY_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);
    }

    private void grow(int minCapacity) {                                     //扩展数组
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);                   //1.5oldCapacity 
        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;
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        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);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }


    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
    }


      public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

© 著作权归作者所有

共有 人打赏支持
laohng1995
粉丝 11
博文 36
码字总数 29266
作品 0
南岸
程序员
Java ArrayList知识点整理

Java中的ArrayList内部采用数组实现,其扩容方式可以认为是每次扩容原长度的1/2。 在向一个ArrayList对象添加大量元素的程序中,可使用ensureCapacity方法增加capacity。这可以减少增加重分配...

阿涵89
2017/09/30
0
0
Java和Android基础知识

java基础知识准备: java基础篇,这是我自己整理好的: (1)ArrayList,Vector,LinkedList的区别 (2)设计模式的分类 (3)算法 (4)深入探索Java工作原理:JVM内存回收及其他 (5)架构详...

SRain215
2016/03/09
64
0
2017年小米春招内推面试面经

  首先,我感到很讶异的是,在我投完简历一天后(2017年2月 23日),小米的工作人员就打电话给我,并且敲定了电话面试的日期(2017年2月27日)。当时我还在家里享受着寒假呢,这也许是来自...

大黄有故事
2017/02/27
0
0
java集合介绍

对于高级语言来说,集合(容器)是非常的重要的知识点,也是非常基础的,相信很多刚毕业的同学包括初级程序员和求职的过程中,经常会被问到集合相关的知识。我觉得该文只是对集合的一个简单的...

The_flying_pig
2017/09/18
0
0
Python数据分析(一) 关于pandas和numpy

自己在使用pandas和numpy处理数据的时候,遇到了很多坑,运用不熟练,在探索的过程中找到以下文章,本来自己想整理这些知识点,但是返现,可能自己写出来的效果差不多,并且以下文章整理很全...

致Great
04/14
0
0

没有更多内容

加载失败,请刷新页面

加载更多

职场老人谈:Linux学习分享

随着Linux系统慢慢渗透到生活的方方面面,对Linux的基本操作就越来越必要了。 我是一位软件测试工程师,初次接触Linux主要是因为需要配置Linux服务器。因为Linux系统是一套开源的操作系统,安...

linux-tao
7分钟前
1
0
Oracle chr() ascii()

函数简介 实用函数 chr() 和 ascii() chr() 函数将ASCII码转换为字符: ASCII码 –> 字符; ascii() 函数将字符转换为ASCII码: 字符 –> ASCII码; 在 Oracle 中 chr() 函数和 ascii() 是一对...

taadis
8分钟前
0
0
职场老人谈:Linux学习分享

随着Linux系统慢慢渗透到生活的方方面面,对Linux的基本操作就越来越必要了。 我是一位软件测试工程师,初次接触Linux主要是因为需要配置Linux服务器。因为Linux系统是一套开源的操作系统,安...

linuxprobe16
17分钟前
0
0
Confluence 6 Windows 中以服务方式自动重启的原因

针对长时间使用的 Confluence,我们推荐你配置 Confluence 自动随操作系统重启而启动。针对一些 Windows 的服务器,这意味着需要让 Confluence 以服务的方式运行。 有下面 2 种方式来以服务的...

honeymose
57分钟前
3
0
day93-20180920-英语流利阅读-待学习

时尚之觞:外表光鲜靓丽,其实穷得要命 Lala 2018-09-20 1.今日导读 讲到时尚界,我们脑海里浮现的可能都是模特和设计师光鲜靓丽、从容潇洒的模样。可是,最近在法国出版的一本书却颠覆了我们...

飞鱼说编程
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部