文档章节

关于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
博文 37
码字总数 30590
作品 0
杭州
程序员
私信 提问
Java ArrayList知识点整理

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

阿涵89
2017/09/30
0
0
java集合介绍

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

The_flying_pig
2017/09/18
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
ArrayList、linklist、list的区别

List是一个接口,ArrayList和LinkedList是两个实现类,他们实现的方式不一样,其实LinkedList才是真正的链表(如果不清楚什么是链表,需要了解一下相关数据结构的知识,这不是一两句话能说清楚...

随智阔
2014/03/04
0
0

没有更多内容

加载失败,请刷新页面

加载更多

结合lucene谈谈日期的压缩问题

说起日期值的压缩,一般容易想到的办法是将日期转化成long类型,然后再通过变长整形进行压缩,我算了一下按照毫秒来算最多占用5个字节(可以通过“谈谈变长整型”中的表查看),确实节省了部...

FAT_mt
46分钟前
0
0
导出私有函数与私有变量

在Go语言中, package中包含函数与变量通过identifier的首字母是否大写来决定它是否可以被其它package所访问。当一个函数或变量名称为小写字母时,默认是无法被其他package引用的. 有没有办法...

xtof
46分钟前
1
0
new Date() 在Safari下的 Invalid Date问题

问题复现 var timeStr = '2018-11-11 00:00:00';var time = new Date(timeStr);// error: Invalid Date... 在safari浏览器下,time为Invalid Date, 导致后面代码执行错误; 其他浏览器诸...

会写代码的husky
51分钟前
2
0
0009-如何升级Cloudera Manager和CDH

1.文档编写目的 本文档讲述如何升级Cloudera Manager和CDH,通过本文档,您将学习到以下知识: 1.如何对Cloudera Manager进行停机升级 2.如何对CDH进行停机升级 3.如何在不影响集群作业的情况...

Hadoop实操
今天
1
0
vue2中引用 better-scroll的方法

文章主要介绍了vue2中引用better-scroll和使用 better-scroll的方法,使用时有三个要点及注意事项在文中给大家详细介绍 ,需要的朋友可以参考下 使用时有三个要点: 一:html部分 <div class...

前端攻城老湿
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部