ArrayList的理解(小白版)

已于 2022-04-27 20:05:40 修改
阅读量715 收藏
点赞数
分类专栏： java的知识点 文章标签： java
于 2022-04-21 16:59:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62086657/article/details/124326271
版权

目录

一、属性

二、构造方法

三、基础测试用例

四、add()方法

1.add无参数的方法

2.add有参数的方法

五、grow()方法【扩容】

六、remove()方法

1.删除指定位置上的元素

2.删除指定的元素且索引最小

七、indexOf()和LastIndexOf()方法

1.从前往后遍历indexOf()

2.从后往前遍历lastIndexOf()方法

看到源码时，先看属性，再看构造方法，再看一些基础方法

ArrayList有三种遍历方式：迭代器遍历、索引遍历、for循环遍历ArrayList是基于数组实现的，一个动态数组，其容量能自动扩大，动态扩容

一、属性

 private static final int DEFAULT_CAPACITY = 10;
    //需要存放数据时定义的初始化数组的大小
​
//why要弄两个空数组呢？
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //定义默认空数组
    /*存储数组列表元素的数组缓冲区。ArrayList的容量就是这个数组缓冲区的长度。
    当添加第一个元素时，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空            ArrayList将    被扩展为DEFAULT_CAPACITY。*/
​
    transient Object[] elementData;
    //存储ArrayList内的元素，存放数据的数组（不能被序列化）
    private int size;
    /*数组列表的大小(它包含的元素的数量)。*/

二、构造方法

/*构造一个具有指定初始容量的空列表。
    形参:initialCapacity -列表的初始容量
    抛出:IllegalArgumentException -如果指定的初始容量为负值*/
//有参构造，initialCapacity为传入的数组长度
    public MyArraylist(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
//为什么等于0要单独做个条件语句
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //这是抛出异常机制，用来判断输入的数据是否合理
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }
​
    /*构造一个初始容量为10的空列表。*/
    public MyArraylist() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    /*这是无参构造，如果我们创建ArrayList对象时没有传入参数，
     * 就会调用该方法创建ArrayList对象，这个对象的elementData被初始化为空的Object[]
     * 空的Object[]会给默认容量10，
     * 在第一次调用add时，elementData将会变成默认的长度：10*/

三、基础测试用例

这里我用的是无参构造。有参构造就是直接开辟了一块连续的空间，但增添元素容量不够时，系统会自动扩容

MyArraylist myArraylist = new MyArraylist(13);

传个参数就ok

package com.two.me;
import com.one.www.MyArraylist;
public class Test03 {
    public static void main(String[] args) {
        MyArraylist myArraylist = new MyArraylist();
        myArraylist.add(10);
        myArraylist.add(9);
        myArraylist.add(8);
        myArraylist.add(7);
        myArraylist.add(6);
        myArraylist.add(5);
        myArraylist.add(4);
        myArraylist.add(3);
        myArraylist.add(2);
        myArraylist.add(1);
        myArraylist.add(0);
    }
}

四、add()方法

1.add无参数的方法

直接将元素增至列表末尾，当增加第一个元素时，element容量从0增至默认初始容量10，在扩容时实现扩容实现步骤：

add()——>ensureCapacityInternal()【判断数组容量】——>calculateCapacity()【计算当前数组的容量，并进行恰当的赋值】——>ensureExplicitCapacity()【判断是否需要进行扩容】——>.....

/*将指定的元素追加到列表的末尾。
        形参:e -元素附加到这个列表
        返回值:true (Collection.add来指定*/
    public boolean add(Object e) {//
        //确认list容量，如果不够，容量加1。注意：只加1，保证资源不被浪费
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将元素放在size位置上
        elementData[size++] = e;//先运算后自加
        return true;
    }
​
//确保内部容量足够，检查数组容量，不够就进行扩容
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
​
//主要是第一次无参构造时，将数组默认容量赋为10，返回最小容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //第一次调用add(1)时，elementData为空数组
            return Math.max(DEFAULT_CAPACITY, minCapacity);//这里调用了Math的max方法
        }
        return minCapacity;//返回最小容量
    }
​
//这里就是来判断是否需要扩容的方法
    private void ensureExplicitCapacity(int minCapacity) {
        //
​
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //如果所需的最小容量大于当前数组的长度
            //意思就是，你当前数组长度为0，而最小容量为10，当前数组就需要扩容
    
            grow(minCapacity);
    }

2.add有参数的方法

//add(索引，添加的元素)
    public void add(int index, Object element) {
        rangeCheckForAdd(index);//检查索引是否越界
​
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        /*调用arraycopy方法，将[index,size]的元素均后移一位*/
        elementData[index] = element;//将index上的元素变为element
        size++;//记得将数组的索引加1
    }
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            //如果索引大于数组的索引或者索引小于0，就抛出异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    private String outOfBoundsMsg(int index) {//解释异常原因，方便知道哪错了
        return "Index: "+index+", Size: "+size;
    }

例：抛出异常

基础测试用例+
    myArraylist.print();
myArraylist.add(12,45);
myArraylist.print();

五、grow()方法【扩容】

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//oldCapacity为老数组长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //这个应该是位运算符吧，当当前数组容量为0时，newCapacity也为0？
        //开始扩容了，新的容量=当前容量+当前容量/2，即将当前容量增加一半（当前容量增加1.5倍）
        if (newCapacity - minCapacity < 0)
            //如果扩容后的容量还是小于想要的最小容量
            //将扩容后的容量再次扩容为想要的最小容量
//为什么不直接将数组容量扩到自己想要的容量呢？
            newCapacity = minCapacity;
//int 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);
        //copyOf(原数组，新的数组长度)
    }
​
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            //如果minCapacity小于0，抛出异常
            throw new OutOfMemoryError();
        //如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

  1. 上述例子输出：

  2. 当将扩容方式改为

    int newCapacity = minCapacity;

    输出为：

因此，第一种扩容方式是扩大数组的多少倍，扩大之后还有多，第二种方式是刚好满足需求的。这里暂时不细细理解hugeCapacity()方法。

六、remove()方法

1.删除指定位置上的元素

 //删除指定位置上的元素
    public Object remove(int index) {
        rangeCheck(index);//检查索引是否越界
        Object oldValue = elementData(index);//记下索引上的元素
//既然是记下索引上的元素，为什么不这样呢？
//Object oldValue = elementData[index];
        int numMoved = size - index - 1;
        //记下应该左移的元素个数，size是数组元素个数，而非索引
        if (numMoved > 0)
            //如果需要左移的话
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);//数组左移
        elementData[--size] = null; // clear to let GC do its work
        //size先自减再使用，然后将索引为size-1处的元素置为null。
        // 为了让GC起作用，必须显式的为最后一个位置赋null值
        return oldValue;
        //返回被删除的元素
    }
​
    private void rangeCheck(int index) {
        if (index >= size)
//怎么=也抛错
//因为此时size为数组元素的个数
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    Object elementData(int index) {
        return  elementData[index];
    }

  1. 上述例子输出为：与2相同

  2. 如果是 Object oldValue = elementData[index];

    基础用例+
    System.out.println("原列表：");
    myArraylist.print();
    System.out.println("在某个索引插入某个数：");     
    myArraylist.add(8,45);
    myArraylist.print();
    System.out.println("移除某个索引上的元素：");
    myArraylist.remove(3);
    myArraylist.print();

    输出为：

2.删除指定的元素且索引最小

    //删除指定的元素且索引最小
    public boolean remove(Object o, int a) {
//因为这个方法与上一个remove方法类似，不好区分，于是来个形参a做个区别的标志
        if (o == null) {//如果对象为空
//why还要判断是不是为空？直接循环不就好了，if的意义何在？
//删了这个if条件语句，
            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) {
        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
    }

  1. 上述代码输出：

    基础测试用例+
    System.out.println("原列表：");
    myArraylist.print();
    System.out.println("移除某个元素且其索引最小：");
    myArraylist.remove(4,1);//若将4换成43，列表不变
    myArraylist.print();

    输出为：

  2. 将代码改为下述代码，其结果与1相同

    public boolean remove(Object o, int a) {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    //找到了第一个与之匹配的，就进行删除操作
                    return true;
                    //只执行一个return语句，且执行完return语句后不再执行其他语句
                }
        return false;
    }

七、indexOf()和LastIndexOf()方法

1.从前往后遍历indexOf()

    //从前往后遍历
    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;//如果遍历完数组后都没有发现指定元素，就返回-1
    }
//将上述代码改为下述代码其运行结果一样
    /*public int indexOf(Object o) {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;//返回索引大小
        return -1;//如果遍历完数组后都没有发现指定元素，就返回-1
    }*/
/*测试用例：【将add(8)改为add(4)】
    基础测试用例+
    System.out.println("原列表：");
     myArraylist.print();
     System.out.println("遍历某个元素且其索引最小：");
     System.out.println(myArraylist.indexOf(4));*/

输出为：

2.从后往前遍历lastIndexOf()方法

//这是从后往前遍历，其返回的是最大索引
    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;
    }
//代码可去if条件语句，去了if后的结果一样
/*测试用例：【将add(8)改为add(4)】
    基础测试用例+
    System.out.println("原列表：");
     myArraylist.print();
     System.out.println("遍历某个元素且其索引最大：");
        System.out.println(myArraylist.lastIndexOf(4));*/
//结果为6

冰吃土豆
关注
专栏目录
Java 集合框架：ArrayList 的介绍、使用、原理与源码解析
栗筝i的博客
06-17 5723
本文将从介绍 ArrayList 开始，详细探讨其使用方法、工作原理以及背后的源码实现，帮助读者深入理解并灵活运用 ArrayList，以提升编程效率和代码质量。 在接下来的部分中，我们将首先概述 ArrayList 的基本特性及其在 Java 集合框架中的地位。随后，通过实际代码示例展示如何创建、操作和管理 ArrayList。接着，我们会揭示 ArrayList 的内部工作机制，包括其底层数据结构、扩容策略和性能优化等方面的内容。最后，我们将深入分析 ArrayList 的源码，探讨其设计思想和实现细
ArrayList 作为返回值个人理解
qq_34419418的博客
10-28 1584
ArrayList <E> 作为返回值个人理解 就按照一个题目来解释 1.1 用一个大集合存入15个随机数字，然后筛选其中的偶数元素，放到小集合当中。 要求使用自定义的方法来实现筛选。 需求分析 2.1 需要创建一个大集合，用来存储int数字： 2.2 随机数字就用Random nextInt 2.3 循环15次，把随机数字放入大集合：for循环、add方法 2.4 定义一个方法，用来进行筛选。 2.5 筛选：根据大集合，筛选符合要求的元素，得到小集合。 方法三要素 3.1 返回值类
ArrayList的理解
ZhaFi人
09-26 3476
ArrayList集合是Collection和List接口的实现类，底层的数据结构可变的Object数组，对ArrayList的所有操作都是通过数据来实现的，数据结构特点是增删慢、查询快。// 默认的容量大小（常量）// 定义的空数组（final修饰，大小固定为0）// 定义的默认空容量的数组（final修饰，大小固定为0）// 定义的不可被序列化的数组，实际存储元素的数组// 数组中元素的个数。
深入理解ArrayList
逍遥的博客
11-28 165
什么是ArrayList？ ArrayList的实现原理其实就是数组（动态数组），ArrayList的介绍及简单使用方法 动态数组与一般数组有什么区别？ 与Java中的数组相比，ArrayList的容量能动态地增长 ArrayList效率怎么样？ ArrayList不是线程安全的，所以效率比较高 ，但是只能用于单线程的环境中，那多线程呢？别急，文末会讲到 ArrayList主要继承哪...
对ArrayList的理解
ilyjm的博客
07-29 179
对Arraylist的理解
Arraylist理解
m0_64427851的博客
04-21 132
ArrayList 1、ArrayList的特点 相比之前的LinkedList可以实现动态扩容。 2、成员属性 private static final long serialVersionUID = 8683452581122892189L; //JAVA序列化的机制是通过判断类的serialVersionUID来验证的版本一致的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID于本地相应实体类的serialVersionUID进行比较。如果相同说明是一致的，可以进行反序列化
ArrayList理解
kkkkk777的博客
05-06 117
ArrayList 实现List接口底层为数组，与java中数组相比容量可以动态增加 特点 线程不安全 元素有序 插入元素可为null 查询快，增删满 首先介绍两个常见的方法 Arrays.copyOf() 从源数组中获得指定长度的数组，返回一个新数组 public static <T,U> T[] copyOf(U[] original, int newLength, Class...
Java从小白到大牛精简版-综合文档
05-18
4. **集合框架**：ArrayList、LinkedList、HashSet、HashMap等是Java中常用的集合类，理解它们的特点和使用场景，以及泛型、迭代器、List和Set的区别。 5. **IO流**：输入/输出流是数据传输的关键，包括字符流和...
【集合系列】8. java中的ArrayList集合
kuxiaoyang的博客
01-11 949
java小白对ArrayList集合的整理与理解，对于所有集合的详细整理，之后会更出，希望能帮到大家
安卓开发者必看：Android的数据结构与算法——ArrayList源码解析
最新发布
2401_84121663的博客
04-20 890
跳槽季整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。
ArrayList 理解（笔记）
weixin_43834415的博客
08-20 207
1、是否允许空 允许 2、是否允许重复数据 允许 3、是否有序，有序的意思是读取数据的顺序和存放数据的顺序是否一致 有序 4、是否线程安全 非线程安全 ArrayList是基于数组的一个实现，elementData就是底层的数组，底层默认数组大小10个 注意 ArrayList里面的，size是按照调用add、remove方法的次数进行自增或者自减的，所以add了一个null进入ArrayList，size也会加1 ，可叠加 扩容代码 public void ensureCapacity(int mi
ArrayList简单理解
qq_42314022的博客
02-28 241
ArrayList的底层实现是一个Object类型数组，初始容量为10，扩容时复制当前数组并将数组容量扩展到原来的1.5倍 特点：相对有序，可以通过下角标访问元素，不排重，可以存放null值 transient Object[] elementData; //存放元素的Object 数组 //默认容量空元素数据 private static final Object[] DEFAULTCAPACI...
三：ArrayList的理解
清风竹雨
11-15 298
ArrayList 线程不安全的案例和解决方案 故障现象 public class ContainerDemo { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); Random random = new Random(...
深入理解 ArrayList
hymua的博客
01-08 418
ArrayList是 Java 集合框架中的一个类，它实现了动态数组的数据结构。与普通数组相比，ArrayList具有动态调整大小的能力，使得我们可以轻松地进行元素的插入和删除。
ArrayList深入理解
fordushao的博客
07-24 286
ArrayList深入理解ArrayList是基于数组实现的，可以通过下标索引直接查找到指定位置的元素，因此查找效率高，但每次插入或删除元素，就要大量地移动元素，插入删除元素的效率低。 ArrayList中允许元素为null，在查找给定元素索引值等的方法中，源码都将该元素的值分为null和不为null两种情况处理ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Coll
ArrayList集合的理解
weixin_42698882的博客
08-27 193
  为什么会出现集合类：  *       因为我们学习的Java语言是面相对象的编程语言，  *       而面相对象编程语言对事物的描述都是通过对象来体现的，我们为了  *   方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想  *   对多个对象进行存储，就不能是一个基本的变量，而应该是一个容器类型  *   的变量。  *   到目前为止我们学习过那些容器类型的数据呢？ ...
ArrayList集合的简单理解
c12225657558847的博客
04-15 418
1.数组的长度一经定义后是不可以改变的，但是ArrayList集合的长度是可以改变的 Arraylist list=new ArrayList<>(); 是泛型，什么是泛型，泛型就是装在ArrayList集合中的全部元素都是统一的类型， 泛型只能是引用类型，不能是基本类型 2.下面是几个简单的例子: public static void main(String[] arg...
Java学习进阶：免费下载《从小白到大牛精简版》笔记
3. Java核心API学习：为了更好地理解Java语言，本书讲解了Java标准库中的常用类和接口，包括java.lang、java.util、java.io等包中重要的类和接口，如String、ArrayList、HashMap、IOException等。 4. 高级特性：在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值