每日一类-手写ArrayList

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量821 收藏 3
点赞数
分类专栏： 技术杂项 文章标签： java 开发语言 后端 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langfeiyes/article/details/121446166
版权

概述        

        ArrayList是开发中用得相对频繁的一个类，以前侧重业务，在意使用，今天来尝试还原一下ArrayList源码设计，自己DIY一个自己的ArrayList。

        ArrayList定位为动态数组，底层是一个可以自动扩容的数组，用于存储同类型的数据。那么自己DIY的ArrayList就必须满足这些功能操作，结合ArrayList源码，确定手写的MyArraylist的方法有下面几个：  

 构造器

public class App {
    public static void main(String[] args) {
        //使用默认的容积
        ArrayList list = new ArrayList();
        //使用指定容积
        ArrayList list2 = new ArrayList(10);
        //根据传入的集合创建新集合
        ArrayList list3 = new ArrayList(Collections.emptyList());
    }
}

上面代码是JDK版ArrayList的构造器，有3个，一个默认数组大小，一个指定数组大小，一个由传入的其他集合决定，结合这个信息，可以自己yy一下，ArrayList里面必定有1个数组，数组通过构造器进行初始化，初始化方式有3种，对应的MyArrayList可以定义成下面的样子。

public class MyArrayList {

    private int size;  //存放数据大小
    private Object[] elementData;  //存放数据数组

    //模仿ArrayList初始化 2个空数组，执行add时才进行扩容
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //为什么弄2个空数组，官方给出解释：
    // We distinguish this from EMPTY_ELEMENTDATA to know how much to inflate 
    //when first element is added.
    //翻译过来就是：我想知道它啥时候塞值进去
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

   
}

空参数构造器

默认还是使用空数组，当执行add时在扩容

    public MyArrayList(){
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

指定初始化容积构造器

这里3个分支，1>指定初始化值大于0，按照指定大小扩容，如果等于0，默认就是空值，其他情况抛异常

    public MyArrayList(int initialCapacity){
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }

指定集合的构造器

ArrayList中有完整集合体系，可将Collection集合转换成ArrayList元素，而MyArrayList仅仅是模仿，没有继承/实现Collection体系，所以就自己合并自己。


    public MyArrayList(MyArrayList list){
        elementData = list.toArray();
        if ((size = elementData.length) == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

里面涉及到元素的拷贝与合并，多了toArray方法，将集合元素转换成数组

    public Object[] toArray() {
        //借用工具类啦
        return Arrays.copyOf(elementData, size);
    }

添加-add

可变数组(list集合)有2类添加方法，一个还add(element)，一个是add(index, element)

    /**
     * 往数组中添加元素(默认添加到最后)
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(Object element) {
        return false;
    }

    /**
     * 往数组指定位置添加元素(默认添加到最后)
     * @param index 索引
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(int index, Object element) {
        return false;
    }

不过哪一个add方法，都需要考虑一下几个问题：

1>第一次添加时，数组初始化

2>添加的数据超过初始化(默认/指定)长度时，数组如何扩容

add(element) 

    //默认长度
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 往数组中添加元素(默认添加到最后)
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(Object element) {
        if(size == elementData.length){
            this.grow();
        }
        elementData[size++] = element;
        return true;
    }
    //拓展方法
    private void grow() {
        int oldCapacity = elementData.length; //新长度
        int newCapacity;
        if(oldCapacity == 0){
            newCapacity = DEFAULT_CAPACITY;
        }else{
            //扩展增幅是 1.5倍
            newCapacity = oldCapacity + (oldCapacity >> 1);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

第一次添加时需要对数组进行初始化(默认初始化数组长度为10)，当添加数据个数超过数组长度时，也需要拓展，那么统一使用grow方法进行数据拓展。是否拓展，判定标准就是

size == elementData.length

add(index, element)

与add(element)存在不同,add(index, element) 多了index索引校验跟数据移动，

比如下面例子：

 list.add(3, 444)，索引为3， 4， 5位置需要往后挪一位，将所以为3位位置空出来，将444值设置到索引为3的位置。

    /**
     * 往数组指定位置添加元素(默认添加到最后)
     * @param index 索引
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(int index, Object element) {
        //检查索引是否正确
        this.rangeCheck(index);
        if(size == elementData.length){
            this.grow();
        }
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
        return true;
    }

    //检查索引是否正确
    private void rangeCheck(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
    }

这里解析一下：arraycopy方法

System.arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

src：源数组

srcPos：源开始拷贝索引

dest：目标数组

destPos：目标数组开始替换位置

length：拷贝长度

按上面的例子， list.add(3, 444), 则表示，将源数组索引为3， 4， 5索引位置的数据拷贝目标数组(跟源数组一样)索引为4， 5， 6索引位置。

System.arraycopy(elementData, 3, elementData, 3+ 1, 6- 3);

优化：

add(element)  跟 add(index, element)  存在一定代码重复， add(element）等价于add(size, element), 所以可以调用实现。

    /**
     * 往数组中添加元素(默认添加到最后)
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(Object element) {
        this.add(size, element);
        return true;
    }

    /**
     * 往数组指定位置添加元素(默认添加到最后)
     * @param index 索引
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(int index, Object element) {
        //检查索引是否正确
        this.rangeCheck(index);
        if(size == elementData.length){
            this.grow();
        }
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
        return true;
    }

删除-remove/clear

remove操作有2中，一种是根据内容删除， 一种是根据索引删除。根据内容删除这个相对麻烦，需要引入泛型，这里暂时放弃，重点来弄根据索引删除：

remove(index)

    /**
     * 根据指定索引删除数据
     * @param index 索引
     * @return 被删除的数据
     */
    public Object remove(int index){
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        Object old  = elementData[index];
        if(size - 1 > index){
            System.arraycopy(elementData, index + 1, elementData, index, size -1 - index);
        }
        elementData[size-1] = null;
        size --;
        return old;
    }

clear

清除， 将所有数据清空

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

修改-set

list集合的set操作，set(index, element), 因为没有涉及到数据个数变化，操作起来相对简单。

    /**
     * 修改指定位置元素数据
     * @param index 索引
     * @param element 元素
     * @return 返回被改动的数据
     */
    public Object set(int index, Object element) {
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        Object oldValue = elementData[index];
        elementData[index] = element;
        return oldValue;
    }

查询-get

get(index), 这个操作也相对简单

    /**
     * 获取指定索引的数据
     * @param index 索引
     * @return 数据
     */
    public Object get(int index) {
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        return elementData[index];
    }

到这，一个很初级的ArrayList就出现啦。最终代码：

public class MyArrayList {

    private int size;  //存放数据大小
    private Object[] elementData;  //存放数据数组

    //默认长度
    private static final int DEFAULT_CAPACITY = 10;


    //模仿ArrayList初始化 2个空数组，执行add时才进行扩容
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //为什么弄2个空数组，官方给出解释：
    // We distinguish this from EMPTY_ELEMENTDATA to know how much to inflate
    //when first element is added.
    //翻译过来就是：我想知道它啥时候塞值进去
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    public MyArrayList(){
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public MyArrayList(int initialCapacity){
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                    initialCapacity);
        }
    }


    public MyArrayList(MyArrayList list){
        elementData = list.toArray();
        if ((size = elementData.length) == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    public Object[] toArray() {
        //借用工具类啦
        return Arrays.copyOf(elementData, size);
    }


    /**
     * 往数组中添加元素(默认添加到最后)
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(Object element) {
        this.add(size, element);
        return true;
    }
    //拓展方法
    private void grow() {
        int oldCapacity = elementData.length; //新长度
        int newCapacity;
        if(oldCapacity == 0){
            newCapacity = DEFAULT_CAPACITY;
        }else{
            //扩展增幅是 1.5倍
            newCapacity = oldCapacity + (oldCapacity >> 1);
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
     * 往数组指定位置添加元素(默认添加到最后)
     * @param index 索引
     * @param element 元素
     * @return 添加成功返回true， 不成功返回false
     */
    public boolean add(int index, Object element) {
        //检查索引是否正确
        this.rangeCheck(index);
        if(size == elementData.length){
            this.grow();
        }
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
        return true;
    }

    //检查索引是否正确
    private void rangeCheck(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
    }


    /**
     * 根据指定索引删除数据
     * @param index 索引
     * @return 被删除的数据
     */
    public Object remove(int index){
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        Object old  = elementData[index];
        if(size - 1 > index){
            System.arraycopy(elementData, index + 1, elementData, index, size -1 - index);
        }
        elementData[size-1] = null;
        size --;
        return old;
    }
    /**
     * 清空集合元素
     */
    public void clear() {
        for (int i = 0; i < size; i++){
            elementData[i] = null;
        }
        size = 0;
    }


    /**
     * 修改指定位置元素数据
     * @param index 索引
     * @param element 元素
     * @return 返回被改动的数据
     */
    public Object set(int index, Object element) {
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        Object oldValue = elementData[index];
        elementData[index] = element;
        return oldValue;
    }

    /**
     * 获取指定索引的数据
     * @param index 索引
     * @return 数据
     */
    public Object get(int index) {
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
        }
        return elementData[index];
    }
    @Override
    public String toString() {
        return "MyArrayList{" +
                "size=" + size +
                ", elementData=" + Arrays.toString(elementData) +
                '}';
    }
}

浪飞yes
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java提高篇(二一)-----ArrayList.pdf
10-04
ArrayList是Java集合框架中的一种列表实现，它实现了List接口，允许存储包括null在内的所有元素。ArrayList的本质是一个动态数组，其容量可以根据需要自动增长。默认初始容量为10，随着元素的增加，ArrayList会自动...
ArrayList概念及手写代码
逐鹿人生的博客
08-14 2576
一、ArrayList的底层是Object类的数组，默认长度是10,超过10后，长度变为原长度的1.5倍。 二、可以简单的认为是一个动态数组；实际上ArrayList就是用数组实现的，长度不够时，调用Arrays.copyOf方法，拷        贝当前数组到一个新的长度更大的数组。 三、特点：随机访问速度快，插入和移除性能较差(数组的特点)；                   支持nu
手写ArrayList实现基本功能
qq_44752800的博客
07-17 129
手写ArrayList实现基本功能 文章目录手写ArrayList实现基本功能概述手写内容构造器成员变量和常量添加-add方法扩容-ensureExplicitCapacity(size + 1);System.arraycopyrangeCheck(int index)删除元素 removeget() getsize()完整手写源码 概述 List是一种线性的列表结构，继承自Collection接口，是一种有序集合。 ArrayList是用数组来实现的List 随机访问效率高 读快写慢 写的过程涉及元素
java学习(集合ArrayList 定义 添加元素add 取出元素get 返回size 遍历)
weixin_44788497的博客
08-21 959
/* ArrayList集合的方法 add(参数) 向集合中添加元素, 数据存储进去 方法中的参数类型,定义集合对象时的类型是一致的 ArrayList <Integer> array= new ArrayList <Integer>(); array.add(34); get(int index) 取出集合中的元素 size(); 返回集合的长度 集合存储元素的个数 集合的遍历 实现方法也
手写ArrayList java 简单实现add() 、get()、length()
MADMY的博客
05-28 677
package Jobday10_ArrayList;public class MyArrayList {    private Object[] array;    private int size; //主方法测试类： public static void main(String[] args) {        MyArrayList list = new MyArrayList();   ...
Java学习笔记：ArrayList手写实现
菜到不敢run
07-20 601
  本文是对高淇版Java三百集，容器部分ArrayList内容学习的记录。java中ArrayList本质是一个数组，该类中包含两个属性Object[] elementData,int size,恰如字面意思，前一个数组用于存储数据，后者的size记录有多少个数据。 一、ArrayList源码 1.1 add()方法 1.2 remove()方法 1.3 二、自定义实现ArrayList功能 2.1 定义MyArrayList类，简单实现add方法 package cn.edu.ucas.gqlearn;
每日一类-手写ArrayList-泛型
langfeiyes的博客
11-25 591
ArrayList是开发中用得相对频繁的一个类，以前侧重业务，在意使用，今天来尝试还原一下ArrayList源码设计，自己DIY一个自己的ArrayList。
Java-手写ArrayList集合
谢文峰的博客
02-25 684
1.Arraylist数组存储对象实现原理 Jdk1.8源代码中 其实ArrayList是用Object[]数组实现。 这里我们有些轮子也不用完全自己造了，可以参考jdk源码，实现核心代码即可。 2.首先介绍ArrayList中的几个核心方法原理 2.1添加元素 普通添加，list.add(Object)，元素添加在数组的最后 在指定脚标位置添加元素，list.add(ind...
手写ArrayList的实现
飞翔的宇宙
02-15 1511
一.引言 众所周知ArrayList是一种数组的实现方式,也就说明其有序有下标不肯重复,查询快增删慢的特点,今天有时间就研究了一下其实现方法并手写了一些,实现原理草考一下链接 实现原理 二.demo实践 1.首先创建一个NewList接口 package org.ligh.arraylist; /** * Created by ${ligh} on 2019/2/15 上午9:...
ArrayList的add()和get()方法
热门推荐
kai3123919064的博客
05-19 1万+
add()方法 用add()方法,首先判断当前arraylist的数组长度是否需要扩容, 在扩容的方法中 : 初始化的长度是10,以后每次增加是采用size+(size>>1)的方式,然后判断扩容后的长度与数组需要的最小长度对比,如果小于,则把当前最小长度最为新的数组的长度, 如果新的长度大于数组的最大长度,则使用integer的最大值作为长度 然后在数组中添加要添加的元素,返回tr...
JAVA进阶补充
2301_80150315的博客
08-15 873
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 565
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1039
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 341
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 568
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
旅游网站
weixin_43213064的博客
08-16 626
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 989
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 740
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
13-2 arraylist集合应用
03-16
ArrayList集合是Java中常用的一种数据结构，它可以存储任意类型的对象，并且可以动态地扩展容量。在实际应用中，ArrayList集合可以用于存储和操作大量数据，例如存储学生信息、商品信息等。通过ArrayList集合，我们...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浪飞yes

我对钱没兴趣~

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

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

打赏作者

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

抵扣说明：

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

余额充值