java基础-手动实现ArrayList

最新推荐文章于 2025-06-15 17:28:42 发布
最新推荐文章于 2025-06-15 17:28:42 发布
阅读量829 收藏 3
点赞数 4
CC 4.0 BY-SA版权
分类专栏： JAVA学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lhrm0213/article/details/85317449

        对于java开发者来说，大概用得最多的容器就是ArrayList了。所以掌握ArrayList的底层实现，还是比较重要的。一般面试的时候也是常见的问题。

        废话不多说，直接上代码。注释也很详细。首先是定义一个List接口。这样我们后面可以实现ArrayList，也可以实现LinkedList。

一、定义List接口

package com.zwh.linertable;

/**
 * @Auther: zwh
 * @Date: 2018/12/26 09:39
 * @Description:定义操作列表的接口方法
 * @Version:1.0
 */
@SuppressWarnings("all")
public interface List {
    /**
     * @description : 获取线性表的长度
     * @param:
     * @return: 长度
     * @auther: zwh
     * @date: 2018/12/26 9:39
     */
    public int size();

    /**
     * @description : 获取指定索引的内容
     * @param: 索引位置
     * @return: 指定位置的内容
     * @auther: zwh
     * @date: 2018/12/26 9:40
     */
    public Object get(int index);

    /**
     * @description : 判断当前容器是否为空
     * @param:
     * @return:
     * @auther: zwh
     * @date: 2018/12/26 9:41
     */
    public boolean isEmpty();
    
    /**
     * @description :判断当前容器是否包含当前对象 
     * @param: 
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 9:41
     */
    public boolean contains(Object element);
    
    /**
     * @description :往容器中添加一个对象 
     * @param: 
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 9:41
     */
    public void add(Object element);
    
    /**
     * @description : 
     * @param: 
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 9:42
     */
    public void remove(Object element);
    
    /**
     * @description : 从容器中删除一个对象
     * @param: 要删除对象的索引
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 9:44
     */
    public void remove(int index);
    
    /**
     * @description : 添加一个对象到指定位置
     * @param: i:要添加对象的索引位置，e:要添加的对象
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 9:45
     */
    public void add(int index,Object element);
    
    /**
     * @description : 获取某个对象在容器中的索引
     * @param: 对象
     * @return: 索引值
     * @auther: zwh
     * @date: 2018/12/26 9:45
     */
    public int indexOf(Object elemente);

    /**
     * @description : 在指定对象前添加一个对象
     * @param: obj：添加对象的位置，e:要添加的对象
     * @return:
     * @auther: zwh
     * @date: 2018/12/26 9:46
     */
    public void addBefore(Object obj,Object element);
   
    /**
     * @description : 在指定对象后添加一个对象
     * @param:obj：添加对象的位置，e：要添加的对象
     * @return: 
     * @auther: zwh
     * @date: 2018/12/26 10:01
     */
    public void addAfter(Object obj,Object element);
    
   /**
    * @description : 替换制定位置的对象
    * @param: i：要替换对象的位置，e:要替换的新的对象
    * @return:
    * @auther: zwh
    * @date: 2018/12/26 9:58
    */
    public Object replace(int index,Object element);
}

这个接口中，基本包含了大部分的java.util中List的功能。然后一个一个去实现它。

二、使用ArrayList实现List

1、新建一个ArrayList类，实现List接口。

/**
 * @Auther: zwh
 * @Date: 2018/12/26 10:05
 * @Description: 线性表,底层采用数组，长度可以动态变化
 * @Version:1.0
 */
@SuppressWarnings("all")
public class ArrayList implements List {
}

      2、在这个实现类中，一个一个的去实现接口中定义的方法。ArrayList底层采用数组来实现。所以我们提前定义好成员变量：

    /**
     * 存储当前线性表内容
     */
    private Object[] elementData;
    /**
     * 存储当前线性表长度
     */
    private int size;
    /**
     * 默认的空线性表
     */
    private Object[] DEFAULT_EMPTY_ELEMENTDATA={};
    /**
     * 定义一个List的最大容量
     */
    private int DEFAULT_MAX_CAPACITY=Integer.MAX_VALUE-8;

        3、定义构造方法，用于初始化容器的容量。一般提供两个构造方法，一个为空构造方法，一个提供一个长度参数。

    /**
     * 初始化一个长度为length的ArrayList，注意，这里的length和size无关
     * @param length
     */
    public ArrayList(int length) {
        elementData=new Object[length];
    }

    /**
     * 初始化一个空的ArrayList
     */
    public ArrayList() {
        elementData=DEFAULT_EMPTY_ELEMENTDATA;
    }

4、实现最简单的两个方法，size(),isempty()

    @Override
    public int size() {
        //返回的是元素的个数，而不是数组的长度，所以只有往List中添加了元素之后，size才会增加
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

5、实现add方法

在实现add方法之前，有一点需要注意。我们初始化ArrayList时，数组的长度是固定的。如果容器的size已经超过了初始化的数组的长度，就会引发数组索引越界异常。所以在添加之前，都应该去判断容器的size是否超过了数组的长度。如果size>=elementData.length，则需要对数组进行扩容。所以我们首先把数组扩容的方法实现，添加就变得容易了。关于数组扩容，参照java.util.ArrayList中提供的方法。实现代码如下：

    /**
     * @description : 数组扩容
     * @param:minCapacity：需要扩大的最小容量
     * @return:
     * @auther: zwh
     * @date: 2018/12/28 10:23
     */
    private void grow(int minCapacity){
        //现在的数组的长度
        int oldCapacity=elementData.length;
        //新数组的长度，在现有数组长度的基础上，在增加1/2。这样不至于增加太多，也不至于太少，导致增加次数过多
        int newCapacity=oldCapacity+(oldCapacity>>1);
        //如果新的数组的长度>目前需要的数组长度，则扩大现在需要的数组长度
        if(minCapacity>newCapacity){
            newCapacity=minCapacity;
        }
        //如果新的数组长度大于设定的最大值，则直接去Integer能表示的最大值
        if (newCapacity>DEFAULT_MAX_CAPACITY){
            newCapacity=Integer.MAX_VALUE;
        }
        //通过数组拷贝，将原数组进行扩容。
        elementData=Arrays.copyOf(elementData,newCapacity);
    }

其实这个grow方法还有可以优化的地方，暂时先不考虑。然后再做add，就比较容易了：

    @Override
    public void add(Object e) {
        if(size>=elementData.length){
            grow(size+1);
        }
        elementData[ size++]=e;
    }

6、实现其他带索引位置的add方法。实现了最普通的add方法之后，考虑实现复杂一些的add方法。第一个是add(int index,Object element)。在指定的位置添加一个新的元素。因为其基于数组来实现的原因，在中间添加元素是比较麻烦的一件事情。因为后面的元素全部需要移动一次位置。所以在本次实现中，我主要使用了数组拷贝。当然，也可以使用循环赋值的方式实现，对于初学者来说更容易理解。

    @Override
    public void add(int index, Object element) {
        if(index<0 || index>=size){
            throw new ArrayIndexOutOfBoundsException("IndexOutOfBoundsException! current                    index:"+index+",size:"+size);
        }
        Object[] newElementData=new Object[size+1];
        //将原来数组的index之前的元素复制到新数组
        System.arraycopy(elementData,0,newElementData,0,index);
        //将元素赋值给新数组的第index个元素
        newElementData[index]=element;
        //将原数组的index之后的元素复制到新数组的index元素之后。
        System.arraycopy(elementData,index,newElementData,index+1,size-index);
        //将原来的数组指向新的数组
        elementData = newElementData;
        size++;
    }

接下来addBefore，addAfter就比较容易了。先找到索引位置，调用add（index，element）就ok了。不必再去写同样的代码。

    @Override
    public void addBefore(Object obj, Object element) {
        for(int i=0;i<size;i++){
            if(elementData[i]==obj){
                add(i,element);
                return;
            }
        }
    }

    @Override
    public void addAfter(Object obj, Object element) {
        for(int i=0;i<size;i++){
            if(elementData[i]==obj){
                add(i+1,element);
                return;
            }
        }
    }

7、get方法实现：这个也比较简单了，这是线性表的优势，基于数组的底层实现，对于查询来说非常容易。通过数组的索引即可快速查找对应的元素。

    @Override
    public Object get(int index) {

       if(index<0 || index>=size){
            throw new ArrayIndexOutOfBoundsException("IndexOutOfBoundsException! current index:"+index+",size:"+size);
        }
        return elementData[index];
    }

8、remove方法实现：首先remove(int index)方法，通过索引删除某个元素。这个于add方法中带索引参数类似。需要删除后对后面的元素进行位置的移动。同样使用数组拷贝：注意添加时的size++，删除元素时的size--。

     public void remove(int i) {
        try {
            throwIndexOutOfBoundsException(i);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Object[] newElementData=new Object[size-1];
        /*复制数组，从原数组的下标为0的对象开始，复制长度为i，当i=0时，代表不复制，否则复制长度与i
         *相同下标为i的元素未复制，复制范围：elementData[0,i-1]*/
        System.arraycopy(elementData,0,newElementData,0,i);
        /*复制数组，从原数组的下标为i+1的对象开始，复制长度为size-i-1,下标范围：[i+1,size-1]*/
        System.arraycopy(elementData,i+1,newElementData,i,size-i-1);
        elementData=newElementData;
        size--;
    }

再实现remove的其他方法。就可以调用已经写过的方法了。统一通过索引去删除元素

    @Override
    public void remove(Object e) {
        for (int i=0;i<size;i++ ) {
            if (e==elementData[i]){
                remove(i);
                return;
            }
        }
    }

9、实现其他方法：剩下这些方法都很容易理解，就不多做描述了。

1）indexOf方法：通过遍历去找索引

     @Override
    public int indexOf(Object e) {
        for (int i=0;i<size;i++) {
            if(e==elementData[i]){
                return i;
            }
        }
        return -1;
    }

2）contains方法：一样是通过遍历。

    @Override
    public boolean contains(Object e) {
        for (Object obj:elementData) {
            if(e==obj){
                return true;
            }
        }
        return false;
    }

3）replace方法：真正开发中需要注意i越界的问题。

    @Override
    public Object replace(int i, Object e) {
        elementData[i]=e;
        return e;
    }

三、总结

线性表底层基于数组来实现，目前我们是统一使用Object来作为元素的类型，真正的ArrayList还需要使用泛型，通过泛型可以对元素的数据类型进行指定。

基于数组的底层实现，赋予了ArrayList查询的便利性，并且对于添加元素到最后，删除最后一个元素等方法都非常容易，但对于在List的中间部分添加元素，删除元素等，就显得比较复杂了。这和LinkedList是正好互补。

java-手动实现LinedList
qq_29506407的博客
05-11 244
LinkedList底层用双向链表实现的存储，其特点是：查询效率低，增删效率高，线程不安全。 双向链表也叫双链表，是链表的一种，它的每隔数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。 ...
Java手动实现简单 ArrayList
小城我家
12-03 465
接口package com.ghgcn.chapter03.data;public interface MyList<T> { /** * 是否为空 * @return */ public boolean isEmpty(); /** * 获取大小 * @return */ public int size();
手动实现ArrayList
qq_45829204的博客
08-21 157
List接口常用的实现类有3个：ArrayList、LinkedList和Vector。 我们最常用 ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。 public class Perslist<E> {//原来为Perslist{} private Object[] elementDate;//核心数组是Object数组，数组名为elementDate private int size;//定义数组长度 private stati
ArrayList底层原理、构造函数及数组与List转换详解
最新发布
lssffy的博客
06-15 1034
ArrayList基于动态数组实现，通过扩容、构造函数和高效 API 提供灵活性。数组与List转换通过toArray和实现，需注意类型安全和性能。电商案例验证了查询延迟 0.1ms、添加延迟 5ms 的效果。初始化：预分配容量。转换：使用泛型数组。优化：批量操作，读写分离。安全：同步或并发容器。ArrayList适用于高性能列表操作，未来将在 Java 生态和云原生方向演进。
java arraylist实现_JAVA自己实现ArrayList
weixin_36332394的博客
02-15 133
ArrayList内部用数组存放数据数组的缺点：长度不可变；访问方式单一，只能用下表索引；效率表现：访问任何位置 效率一样，增删数据效率降低内部数组默认的初始容量10；放满之后，容量1.5倍增长；减少数组创建提高效率；package 集合.list.ArrayList;import java.util.Arrays;import java.util.Date;public class MyArry...
用java手动实现ArrayList(java小练习)
Kyrie6c的博客
07-06 233
通过手动实现完成ArrayList更加了解底层源码。 打好java基础，提高java代码能力。 需要实现的方法有： 构造方法MyArrayList() MyArrayList(int capacity) 添加add(E obj) 格式化输出(重写toString)toString() get方法get(int index) set方法set(E element,int index) 检测index是否合理checkRange(int index) 删除元素remove(E element) remove(
Java的ArrayList
matthewchen123的博客
04-16 348
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList 继承了 AbstractList ，并实现了 List 接口。 import java.util.ArrayList; // 引入 ArrayList 类 ArrayList objectName =new ArrayList<>();　 // 初始化 E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。 objectNam
ArrayList的手工实现
qq_57389269的博客
07-11 120
package cn.test; //手工实现Arraylist,参照ArrayList的方法类 public class SxtArrayList<E> { private int size;//包含元素的数量 private Object[] elementData;//目标数组 private static final int DEFAULT_CAPACITY=10; public SxtArrayList(){ elementData
数据结构之手动实现ArrayList
woshicaoxiaojia的博客
02-06 238
这篇文章，我们来一起研究一下Java集合中的ArrayList。 一、回顾List。 1、特点 （1）有序：List中每个元素都有索引标记，可以根据元素的索引标记来精确控制元素。 （2）可重复：List中允许放入重复（e1.equals(e2)即此处的重复）的元素。 2、优点 我们知道，List底层数据结构为数组，数组开辟的空间是连续的，so，遍历元素和随机访问元素的效率较高。 3、缺点 添加和删...
ArrayList手动实现简单底层（一）
秃头小达人
12-20 155
ArrayList手动实现简单底层 ArrayList.add()实现原理 由于ArrayList是由数组来进行存储的，所以要进行数组的创建以及初始化 提供两个构造器供使用者使用。一个默认创建数组长度为10、一个创建数组长度由使用者定义 实现代码： public ArrayListDemo(){ ​ Object[] objects = new Object[10] } public ArrayListDemo(int size){ ​ Object[] objects = new Object[siz
Java_手工实现ArrayList
zlangbao_huishu的博客
12-10 523
手写ArrayList部份功能 //自定义实现ArrayList，体会底层原理 import java.util.Arrays; public class SxtArrayList <E>{ private Object[] elementData; private int size; private static final int DEFAULT_CAPACITY = 10; public SxtArrayList(){ elemen
java ArrayList
m0_37635487的博客
07-22 136
https://blog.youkuaiyun.com/ftell/article/details/80826235
java ArrayList
m0_61682705的博客
02-12 1440
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。// 引入 ArrayList 类// 初始化E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。objectName: 对象名。ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
JavaArrayList
u012289399的博客
09-28 706
ArrayList 是 java 集合框架中常用的数据结构。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 //创建ArrayList变量。ArrayList<Integer> listInt = new ArrayList<>();//这行代码表示创建一个Array
Java ArrayList
qq_25502783的博客
03-10 1059
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：// 引入 ArrayList 类// 初始化ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

云间歌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值