文档章节

关于ArrayList知识的整理

laohng1995
 laohng1995
发布于 2017/07/24 21:31
字数 951
阅读 11
收藏 0
点赞 0
评论 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
粉丝 10
博文 32
码字总数 27788
作品 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
Android源码解析四大组件系列(六)---广播的处理过程

这篇文章紧接着上篇分析广播的发送过程,发送广播都是调用ContextImpl的接口去实现的,总共有二十多个,最终都是调用到AMS的broadcastIntent。主要分成下面九小节来说明。 1、设置Flag 2、检...

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

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

致Great
04/14
0
0
Java集合框架:总结

最近博主对于Java集合框架这个系列做了一个整理,主要包括: Map系:HashMap, LinkedHashMap, TreeMap, WeakHashMap, EnumMap; List系:ArrayList, LinkedList, Vector, Stack; Set系:HashS...

u013256816
2016/03/18
0
0
Android基础巩固进阶

如何创建完美的单例模式? 设计模式在软件开发者中十分受欢迎。设计模式是对于常见软件问题的良好解决方案。单例模式是 Java 中创建型设计模式的一种。 单例类的目的是控制对象创建,约束对象...

掘金官方
2017/12/26
0
0
程序员必备,快速学习 Python 的全套14张思维导图(附高清版下载)

后台回复关键词 思维导图 可获取本文中的高清思维导图(PDF版) ML & AI∣一个有用的公众号 长按,识别二维码,加关注 获取更多精彩文章

micf435p6d221ssdld2
05/23
0
0
2018年五一假期框架知识整理之Android AOP编程思想

开篇废话 真心非常感谢有这么一个五一假期,自己能够挪出来这么一大块的时间来好好学习,感觉无比幸福 近期,由于一个人的时间毕竟有限,工作上,学习上,生活上,都占用了太多时间,实在是没...

进击的欧阳
05/01
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

OSChina 周六乱弹 —— 妹子和游戏哪个更好玩

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @andonny :分享唐朝乐队的单曲《国际歌》 《国际歌》- 唐朝乐队 手机党少年们想听歌,请使劲儿戳(这里) @举个栗子- :日常祈雨 邪恶的大祭...

小小编辑
23分钟前
47
4
流利阅读笔记32-20180721待学习

“人工智能”造假:只有人工,没有智能 Lala 2018-07-21 1.今日导读 当今社会,擅长单个方面的人工智能已经盛行,手机借助 AI 智慧防抖技术帮助大家拍出清晰照片,谷歌研发的 AI 助手将可以帮...

aibinxiao
今天
1
0
我的成长记录(一)

今天突然精神抖擞,在我的博客下新开一项分类>成长记录,专门记录每隔一段时间我的一点感悟吧。因为今天才专门花时间新开这样一个分类,所以以前有过的一些感悟没有记录下来,现在已经想不起...

dtqq
今天
0
0
机器学习管理平台 MLFlow

最近工作很忙,博客一直都没有更新。抽时间给大家介绍一下Databrick开源的机器学习管理平台-MLFlow。 谈起Databrick,相信即使是不熟悉机器学习和大数据的工程湿们也都有所了解,它由Spark的...

naughty
今天
0
0
idea tomcat 远程调试

tomcat 配置 编辑文件${tomcat_home}/bin/catalina.sh,在文件开头添加如下代码。    CATALINA_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=7829" Idea端配......

qwfys
今天
1
0
遍历目录下的文件每250M打包一个文件

#!/usr/bin/env python # -*- utf-8 -*- # @Time : 2018/7/20 0020 下午 10:16 # @Author : 陈元 # @Email : abcmeabc@163.com # @file : tarFile.py import os import tarfile import thr......

寻爱的小草
今天
1
0
expect同步文件&expect指定host和要同步的文件&构建文件分发系统&批量远程执行命令

20.31 expect脚本同步文件 expect通过与rsync结合,可以在一台机器上把文件自动同步到多台机器上 编写脚本 [root@linux-5 ~]# cd /usr/local/sbin[root@linux-5 sbin]# vim 4.expect#!/...

影夜Linux
今天
1
0
SpringBoot | 第九章:Mybatis-plus的集成和使用

前言 本章节开始介绍数据访问方面的相关知识点。对于后端开发者而言,和数据库打交道是每天都在进行的,所以一个好用的ORM框架是很有必要的。目前,绝大部分公司都选择MyBatis框架作为底层数...

oKong
今天
13
0
win10 上安装解压版mysql

1.效果 2. 下载MySQL 压缩版 下载地址: https://downloads.mysql.com/archives/community/ 3. 配置 3.1 将下载的文件解压到合适的位置 我最终将myql文件 放在:D:\develop\mysql 最终放的位...

Lucky_Me
今天
2
0
linux服务器修改mtu值优化cpu

一、jumbo frames 相关 1、什么是jumbo frames Jumbo frames 是指比标准Ethernet Frames长的frame,即比1518/1522 bit大的frames,Jumbo frame的大小是每个设备厂商规定的,不属于IEEE标准;...

问题终结者
今天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部