手工实现ArrayList,包含自定义实现ArrayList和ArrayList测试类

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量504 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46444216/article/details/123755254
版权

目录

1、核心原理：数组的动态扩容，当一个数组容量不够的时候，创建一个新的数组，将旧的数组的内容复制到新的数组上。

2、主要实现的功能：元素的增加，删除，修改，查看、判空

3、具体细节：

3.0 定义的一些常量代码段如下：

3.1构造器，两个，一个有参构造，一个无参构造代码段如下：

3.2 add方法：有两种重载形式：一种是在末尾追加，另一种在任意位置添加（区间在size范围内）同时在添加的时候应做两个检查，首先要检查传入的索引是否合法，另一个保证容量足够（不够将进行扩容）

3.3元素的更新操作，在此提供了两种更新的操作，一种是根据元素元素来操作，一种是根据索引来操作

3.4元素的删除操作，两种方式，一种是根据索引来删除（要检查索引的合法性），一种是根据元素来删除。

3.5根据索引查看元素

3.6ArrayList判空，思路为:判定其size是否为0，代码如下

3.7清空元素，思路，仅需把有所有的元素置为null和size=0即可。代码块如下：

3.8 toString()方法

4、测试用例

 5、完整源代码

6、时间复杂度分析

1、核心原理：数组的动态扩容，当一个数组容量不够的时候，创建一个新的数组，将旧的数组的内容复制到新的数组上。

2、主要实现的功能：元素的增加，删除，修改，查看、判空

3、具体细节：

3.0 定义的一些常量代码段如下：


    /**
     * description 元素的个数
     */
    private int size;

    /**
     * description 泛型类数组
     */
    private E[] elements;

    /**
     * description 定义初始化默认容量为10
     */
    private static final int DEFAULT_INITIAL_CAPACITY = 10;

    /**
     * description 元素未找到抛出-1
     */
    private static final int ELEMENT_NOT_FOUND = -1;

    /**
     * description 元素不存在
     */
    private final E ELEMENT_NOT_DOES_EXIST = null;

3.1构造器，两个，一个有参构造，一个无参构造代码段如下：


    /**
     * description 有参构造器，传入的参数小于小于默认值时采用默认值，否则采用传入的值
     *
     * @param capacity 传入的容量值
     */
    public MyArrayList(int capacity) {
        if (capacity >= DEFAULT_INITIAL_CAPACITY) {
            elements = (E[]) new Object[capacity];
        } else {
            elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
        }
    }

    /**
     * description 无参构造器，采用默认值
     */
    public MyArrayList() {
        this(DEFAULT_INITIAL_CAPACITY);
    }

3.2 add方法：有两种重载形式：一种是在末尾追加，另一种在任意位置添加（区间在size范围内）同时在添加的时候应做两个检查，首先要检查传入的索引是否合法，另一个保证容量足够（不够将进行扩容）

检查索引是否合法的方法：


    /**
     * description 检查是否越界
     *
     * @param index 待检测的索引
     */
    private void isOutOfBoundsForAdd(int index) throws IllegalAccessException {
        if (index <= size && index >= 0) return;
        throw new IllegalAccessException("传入的索引越界");
    }

保证容量足够的方法：扩容采用位运算，加快了运算速度，不知道位运算为何物的可参考我的另一篇博客

    /**
     * description 保证容量足够
     */
    private void ensureCapacity() {
        if (size < elements.length) return;
        /*
         * elements.length >> 1，位运算，相当于除以二，加快运算速度
         * 等价于 int C = elements.length *1.5;
         */
        int C = elements.length + (elements.length >> 1);
        E[] newElements = (E[]) new Object[C];
        //数组复制
        for (int i = 0; i < elements.length; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
        System.out.println("已扩容，新容量为：" + elements.length);
    }

在任意位置添加的方法


    /**
     * description 从指定地方添加元素
     *
     * @param index   指定的索引
     * @param element 传入的元素
     * @throws IllegalAccessException 传入的索引越界异常
     */
    public void add(int index, E element) throws IllegalAccessException {
        isOutOfBoundsForAdd(index);
        ensureCapacity();
        for (int i = size; i > index; i--) {
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

在末尾追加的时候只需要调用add(int index, E element)方法即可

代码块如下：


    /**
     * description 添加元素的方法，默认从末尾追加
     *
     * @param element 传入一个添加的元素
     */
    public void add(E element) throws IllegalAccessException {
        add(size, element);
    }

3.3元素的更新操作，在此提供了两种更新的操作，一种是根据元素元素来操作，一种是根据索引来操作

思路，不管是根据元素还是索引，最后都是将对应索引元素进行替换，因此，我们先给出根据索引更新元素的值的方法，同时他应该告诉外界我们更新的元素，这样别人在调用我们的接口的时候会更加方便,注意判定索引是否合法


    /**
     * description 更新指定索引的元素
     *
     * @param index   需要更新元素的索引的值
     * @param element 传入的更新元素
     * @return 更新前的元素
     */
    public E update(int index, E element) {
        if(index>size||index<0)  return ELEMENT_NOT_DOES_EXIST;
        E e = elements[index];
        elements[index] = element;
        return e;
    }

根据元素来更新元素的方法，上文分析到，我们最终是要通过索引来操作，因此，我们可以在此封装一个给一个指定元素返回其索引的方法，代码段如下：


    /**
     * description 根据元素返回其索引,未找到返回-1
     *
     * @param element 需要查找的元素的索引
     * @return 返回索引
     */
    public int returnIndex(E element) {
        for (int i = 0; i < elements.length; i++) {
            if (elements[i].equals(element)) return i;
        }
        return ELEMENT_NOT_FOUND;
    }

然后就可以通过元素来更新元素啦（返回对应元素的索引）！代码块如下：


    /**
     * description 将一个元素替换为另一个元素,并返回被替换元素的索引
     *
     * @param e1 欲替换的元素
     * @param e2 替换后的元素
     * @return
     */
    public int update(E e1, E e2) {
        int index = returnIndex(e1);
        if (index < 0) return index;
        update(index, e2);
        return index;
    }

3.4元素的删除操作，两种方式，一种是根据索引来删除（要检查索引的合法性），一种是根据元素来删除。

根据索引删除（返回对应的元素）


    /**
     * description 根据索引删除元素
     * @param   index 需要删除的元素索引
     * @return 返回被删除的元素
     */
    public E remove(int index) {
        if (index < 0) return ELEMENT_NOT_DOES_EXIST;
        E element = elements[index];
        for (int i = index; i < size; i++) {
            elements[i] = elements[i + 1];
        }
        size--;
        return element;
    }

根据元素删除，在这删除之前调用returnElement（E element）方法

然后再调用根据索引删除的方法


    /**
     * description 按照元素删除指定的元素
     *
     * @param element 传入要删除的元素
     */
    public void remove(E element) {
        int index = returnIndex(element);
        remove(index);
    }

3.5根据索引查看元素


    /**
     * description 根据元素返回其索引,未找到返回-1
     *
     * @param element 需要查找的元素的索引
     * @return 返回索引
     */
    public int returnIndex(E element) {
        for (int i = 0; i < elements.length; i++) {
            if (elements[i].equals(element)) return i;
        }
        return ELEMENT_NOT_FOUND;
    }

3.6ArrayList判空，思路为:判定其size是否为0，代码如下


    /**
     * description 判断是否有元素
     * @return 布尔值
     */
    public boolean isEmpty(){
        return size==0;
    }

3.7清空元素，思路，仅需把有所有的元素置为null和size=0即可。代码块如下：

    /**
     * description 元素清空
     */
    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i]=null;
        }
        size=0;
    }

3.8 toString()方法

    @Override
    public String toString() {
        return "MyArrayList{" +
                "size=" + size +
                ", elements=" + Arrays.toString(elements) +
                '}';
    }

4、测试用例

/**
 * @author Mr.xiong
 * @version v1.0
 * @description ArrayList测试类
 * @time 2022/3/26 12:05
 * @since jdk8
 */
public class MyArrayListTest {
    public static void main(String[] args) throws IllegalAccessException {
        MyArrayList<Integer> myArrayList = new MyArrayList<>();
        for (int i = 0; i < 15; i++) {
            myArrayList.add(i+1);
        }
        myArrayList.add(0,14);
        System.out.println(myArrayList.update(2, (Integer)222));
        System.out.println(myArrayList.update((Integer)13,(Integer)444 ));
        System.out.println(myArrayList);
        System.out.println(myArrayList.returnIndex(15));
        myArrayList.remove((Integer)444);
        System.out.println(myArrayList.remove(2));
        System.out.println(myArrayList);
        myArrayList.clear();
        System.out.println(myArrayList.isEmpty());
        System.out.println(myArrayList);
    }
}

执行的结果如下：

 5、完整源代码

package mylist;

import java.util.Arrays;

/**
 * @author Mr.xiong
 * @version v1.0
 * @description 自定义实现arraylist
 * @time 2022/3/26 11:10
 * @since jdk8
 */
@SuppressWarnings("unchecked")
public class MyArrayList<E> {
    /**
     * description 元素的个数
     */
    private int size;

    /**
     * description 泛型类数组
     */
    private E[] elements;

    /**
     * description 定义初始化默认容量为10
     */
    private static final int DEFAULT_INITIAL_CAPACITY = 10;

    /**
     * description 元素未找到抛出-1
     */
    private static final int ELEMENT_NOT_FOUND = -1;

    /**
     * description 元素不存在
     */
    private final E ELEMENT_NOT_DOES_EXIST = null;

    /**
     * description 有参构造器，传入的参数小于小于默认值时采用默认值，否则采用传入的值
     *
     * @param capacity 传入的容量值
     */
    public MyArrayList(int capacity) {
        if (capacity >= DEFAULT_INITIAL_CAPACITY) {
            elements = (E[]) new Object[capacity];
        } else {
            elements = (E[]) new Object[DEFAULT_INITIAL_CAPACITY];
        }
    }

    /**
     * description 无参构造器，采用默认值
     */
    public MyArrayList() {
        this(DEFAULT_INITIAL_CAPACITY);
    }

    /**
     * description 添加元素的方法，默认从末尾追加
     *
     * @param element 传入一个添加的元素
     */
    public void add(E element) throws IllegalAccessException {
        add(size, element);
    }

    /**
     * description 从指定地方添加元素
     *
     * @param index   指定的索引
     * @param element 传入的元素
     * @throws IllegalAccessException 传入的索引越界异常
     */
    public void add(int index, E element) throws IllegalAccessException {
        isOutOfBoundsForAdd(index);
        ensureCapacity();
        for (int i = size; i > index; i--) {
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

    /**
     * description 保证容量足够
     */
    private void ensureCapacity() {
        if (size < elements.length) return;
        /*
         * elements.length >> 1，位运算，相当于除以二，加快运算速度
         * 等价于 int C = elements.length *1.5;
         */
        int C = elements.length + (elements.length >> 1);
        E[] newElements = (E[]) new Object[C];
        //数组复制
        for (int i = 0; i < elements.length; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
        System.out.println("已扩容，新容量为：" + elements.length);
    }

    /**
     * description 检查是否越界
     *
     * @param index 待检测的索引
     */
    private void isOutOfBoundsForAdd(int index) throws IllegalAccessException {
        if (index <= size && index >= 0) return;
        throw new IllegalAccessException("传入的索引越界");
    }

    /**
     * description 更新指定索引的元素
     *
     * @param index   需要更新元素的索引的值
     * @param element 传入的更新元素
     * @return 更新前的元素
     */
    public E update(int index, E element) {
        if(index>size||index<0)  return ELEMENT_NOT_DOES_EXIST;
        E e = elements[index];
        elements[index] = element;
        return e;
    }

    /**
     * description 将一个元素替换为另一个元素,并返回被替换元素的索引
     *
     * @param e1 欲替换的元素
     * @param e2 替换后的元素
     * @return
     */
    public int update(E e1, E e2) {
        int index = returnIndex(e1);
        if (index < 0) return index;
        update(index, e2);
        return index;
    }

    /**
     * description 根据元素返回其索引,未找到返回-1
     *
     * @param element 需要查找的元素的索引
     * @return 返回索引
     */
    public int returnIndex(E element) {
        for (int i = 0; i < elements.length; i++) {
            if (elements[i].equals(element)) return i;
        }
        return ELEMENT_NOT_FOUND;
    }

    /**
     * description 按照元素删除指定的元素
     *
     * @param element 传入要删除的元素
     */
    public void remove(E element) {
        int index = returnIndex(element);
        remove(index);
    }

    /**
     * description 根据索引删除元素
     * @param   index 需要删除的元素索引
     * @return 返回被删除的元素
     */
    public E remove(int index) {
        if (index < 0) return ELEMENT_NOT_DOES_EXIST;
        E element = elements[index];
        for (int i = index; i < size; i++) {
            elements[i] = elements[i + 1];
        }
        size--;
        return element;
    }

    /**
     * description 判断是否有元素
     * @return 布尔值
     */
    public boolean isEmpty(){
        return size==0;
    }

    /**
     * description 元素清空
     */
    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i]=null;
        }
        size=0;
    }

    @Override
    public String toString() {
        return "MyArrayList{" +
                "size=" + size +
                ", elements=" + Arrays.toString(elements) +
                '}';
    }
}

6、时间复杂度分析

由于数组在内存上地址是连续的

查询复杂度分析：查询的效率是O（1）级别，所以数组查询的效率特别高

添加的复杂度分析：最好O（1），最坏O（2n）,平均O(n)

删除复杂度分析：最好O（1），最坏O（n）,平均O(n)

更新复杂度：最好O（1）所以数组更新的效率特别高

程序员熊熊
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java集合 7】ArrayList的线程安全类CopyOnWriteArrayList
学Java，找哪吒
10-27 1334
CopyOnWriteArrayList是ArrayList的一个线程安全的变体。它是通过在对底层数组进行一次新的复制来实现所有可变操作（如add、set等）的。在遍历时，它不会对任何元素进行修改，因此绝对不会抛出ConcurrentModificationException的异常。这种数据结构适合用在“读多，写少”的并发应用中，因为在这种情况下，读操作远远大于写操作，所以使用这种数据结构可以提高并发性能。
自定义实现一个java中ArrayList类。
m0_46123217的博客
03-03 390
自定义实现一个java中ArrayList类。 文章目录一、顺序表是什么二、ArrayList三、测试总结 一、顺序表是什么 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 二、ArrayList 代码如下： import java.util.Arrays; public class MyArrayList { private int[] elem; private int usedSize; public
数据结构---ArrayList（Java实现）
X_H学Java的博客
06-11 4615
线性表是数据结构很重要的知识，本文对ArrayList进行全方面剖析，举例介绍基本方法的使用，解析底层扩容机制，并对其进行模拟实现
Java-自定义ArrayList类
qq_52998673的博客
08-09 1720
Java-自定义ArrayList类
自定义ArrayList类
Juily家的小蜜果
08-26 2528
自定义动态数组MyArrayList，实现ArrayList的部分方法，理解ArrayList的方法原理。 一，定义MyArrayList //初始数组名 private Object[] array ; //默认容量大小 private static final int defaule_capacity = 10; //MyArrayList中包含的...
Java_简单模拟实现ArrayList_学习ArrayList
weixin_66484088的博客
02-01 1314
/ 新增元素,默认在数组最后新增// 在 pos 位置新增元素//判断是否包含某个元素//查找某一元素的位置//获取pos位置的元素//给pos位置元素设为value//删除第一次出现的关键字key//获取顺序表的长豆//清空顺序表//打印顺序表，注意：该方法不是顺序表的方法，为了方便测试结果给出的MyArrayList要继承上面的接口并实现，现在是框架。
java实现自定义类实现HashMap，Arraylist，Queue数据结构
0bug0warning的博客
12-25 522
                        java实现自定义类HashMap，ArrayList，Queue结构 我们可能了解hashmap的用法，了解过底层的源码，jdk1.7底层采用拉链法实现，jdk1.8中采用红黑树。这里我们用 jdk1.7中的方式实现hashmap数据结构。用结点类实现ArrayList和Queue。 自定义类实现Queue结构： Queue.java: ...
（List集合）ArrayList保存自定义类对象
weixin_46245201的博客
02-02 1408
ArrayList保存自定义类 通过之前的ArrayList分析已经清楚了ArrayList子类的实现原理以及List核心操作，但是在测试的时候的是系统提供的String类，这是一个设计非常完善的类，而对于类集而言也可以实现已定以类对象的保存。 范例：实现自定义类对象的保存 import java.util.ArrayList; import java.util.List; public class ArrayListDemo { public static void main(Stri
手写ArrayList的实现
飞翔的宇宙
02-15 1506
一.引言 众所周知ArrayList是一种数组的实现方式,也就说明其有序有下标不肯重复,查询快增删慢的特点,今天有时间就研究了一下其实现方法并手写了一些,实现原理草考一下链接 实现原理 二.demo实践 1.首先创建一个NewList接口 package org.ligh.arraylist; /** * Created by ${ligh} on 2019/2/15 上午9:...
Java针对ArrayList自定义排序的2种实现方法
weixin_40599844的博客
08-22 660
这篇文章主要介绍了Java针对ArrayList自定义排序的2种实现方法,结合实例形式总结分析了Java操作ArrayList自定义排序的原理与相关实现技巧,下面就和动力节点java学院小编一起来看看吧。 　　Java中实现对list的自定义排序主要通过两种方式 　　（1）让需要进行排序的对象的类实现Comparable接口，重写compareTo(T o)方法，在其中定义排...
深入浅析ArrayList 和 LinkedList的执行效率比较
08-29
以下是一个简单的测试类，用于测试 ArrayList 和 LinkedList 的性能： ```java public class ListPerformance { private static final int REPS = 100; private abstract static class Tester { String name; ...
JAVA LinkedList和ArrayList的使用及性能分析
09-04
在Java编程中，`LinkedList`和`ArrayList`都是`List`接口的实现，它们各自有其独特的特性和适用场景。本文将对这两种数据结构的使用和性能进行详细分析。 首先，`List`是一个接口，继承自`Collection`，用于表示...
模拟arraylist底层实现
05-21
通过模拟ArrayList的底层实现，我们可以更好地理解ArrayList的工作原理和实现机制，从而提高自己的编程能力和技术水平。同时，我们也可以根据需要，自定义集合实现类以满足不同的需求和应用场景。
ArrayList LinkedList Vector性能测试
05-03
在本测试中，可能创建了包含相同数量元素的ArrayList、LinkedList和Vector实例，然后执行一系列随机读取、插入和删除操作，并记录每种操作所需的时间。通过比较这些时间，可以得出哪种数据结构在特定操作上表现最优...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1509
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1226
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 423
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1157
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
模拟ArrayList集合自定义一个集合类MyArrayList<T>，完成添加和删除功能的泛型设计， 定义测试类完成测试。
06-12
在这个例子中，我们定义了一个泛型类MyArrayList，实现了添加和删除元素的功能。在测试类Test中，我们创建了一个MyArrayList对象，并添加了五个元素，然后删除了第三个元素，最后输出删除元素后的列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值