java基础-手动实现ArrayList

最新推荐文章于 2025-06-15 17:28:42 发布
最新推荐文章于 2025-06-15 17:28:42 发布
阅读量830 收藏 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动态数组实现----聊聊ArrayList
m0_71685576的博客
01-15 1805
在学习Java 编程中我们遇到最重要的集合框架之一就是用于存储和操作对象的动态数组----ArrayList,今天我们就通过对介绍ArrayList来加强大家对数组实现的认识.ArrayList提供动态调整大小的能力，可灵活管理数据集合，学习方法包括掌握基本概念、熟悉常用方法、实际项目实践以及深入理解Java集合框架。
java集合框架-Collection-List-ArrayList源码分析
xiong_tai的博客
04-13 781
ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添加元素时，如果容量不足，容器会自动增大底层数组的大小。前面已经提过，Java泛型只是编译器提供的语法糖，所以这里的数组是一个Object数组，以便能够容纳任何类型的对象。
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对字符串进行存储和管理
07-14
在Java编程语言中，ArrayList是Java集合框架的一部分，属于List接口的一个实现类。ArrayList主要用于存储和管理一组有序的、可变大小的对象，包括字符串。它提供了动态数组的功能，允许我们在运行时添加、删除和访问...
java基础-java
09-03
7. **集合框架**：Java集合框架包括接口（如List、Set和Map）和实现类（如ArrayList、HashSet、HashMap等），用于存储和操作对象。 8. **输入/输出(I/O)**：Java的I/O流库允许程序读取和写入文件、网络和系统资源。...
Java的ArrayList
matthewchen123的博客
04-16 348
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList 继承了 AbstractList ，并实现了 List 接口。 import java.util.ArrayList; // 引入 ArrayList 类 ArrayList objectName =new ArrayList<>();　 // 初始化 E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。 objectNam
java-手动实现LinedList
qq_29506407的博客
05-11 244
LinkedList底层用双向链表实现的存储，其特点是：查询效率低，增删效率高，线程不安全。 双向链表也叫双链表，是链表的一种，它的每隔数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。 ...
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_61682705的博客
02-12 1441
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。// 引入 ArrayList 类// 初始化E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。objectName: 对象名。ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

云间歌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值