利用Java来手写ArrayList

最新推荐文章于 2022-08-09 21:26:21 发布
最新推荐文章于 2022-08-09 21:26:21 发布
阅读量310 收藏 1
点赞数
分类专栏： Java 后端 文章标签： java arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45747080/article/details/119799621
版权
后端 同时被 2 个专栏收录
24 篇文章 0 订阅
订阅专栏
Java
16 篇文章 0 订阅
订阅专栏

利用Java来手写ArrayList

几乎所有的语言都会有数组，Java也不例外。数组有个特点就是在初始化的时候必须确定长度，即使容量到达了也无法自动扩容，无法满足需求，所以我们可以利用动态数组（ArrayList）来实现可以自动扩容的数组。参考Java官方的ArrayList实现：java.util.ArrayList。ArrayList的底层还是数组，相当于数组的强化版，能够进行自动扩容并且进行数据的增删改查。

注意：

以下利用动态数组来表示ArrayList，利用数组来表示Object[]

私有属性

最起码需要表示动态数组的大小size，存放数据的基本数组elements[]，所以应该有以下属性：

public class ArrayList<E> {

    /**
     * 动态数组大小
     */
    private int size;

    /**
     * 动态数组
     */
    private E[] elements;
    
}

注意这里使用到了泛型，是为了方便顺序存储相似的数据（类型相同的数据）

构造方法

无参构造方法：创建一个默认容量的数组；

有参构造方法：创建一个指定容量的数组。

既然涉及到默认，那我们可以指定一个常量为默认容量，可以按照自己的需求来，随便多少都可以。

    /**
     * 动态数组默认容量
     */
    private static final int DEFAULT_CAPACITY = 10;


    /**
     * 无参构造，创建默认大小的数组
     */
    public ArrayList(){

    }

    /**
     * 有参构造，根据容量创建数组
     * @param capacity      自定义容量
     */
    public ArrayList(int capacity){

    }

注意：

容量（capacity）是指该动态数组能够容纳多少个元素，而不代表它里面已经存了多少个元素，通常情况数组的长度elements.length和他相等。

大小（size）是指该动态数组已经有多少个元素。

无参构造

创建默认容量的Object数组，再强制类型转换。

    public ArrayList(){
        elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

有参构造

创建指定容量的数组，需要控制一下传入的容量大小，不允许为负数。

    public ArrayList(int capacity){
        if (capacity<=0) capacity = DEFAULT_CAPACITY; //如果传入容量不为自然数，则强制为默认容量
        elements = (E[]) new Object[capacity];
    }

基本方法

仿造java.util.ArrayList，得出以下基本方法包含基本的添加删除查询元素等。

public class ArrayList<E> {


    /**
     * 动态数组大小
     * @return      动态数组大小
     */
    public int size(){}

    /**
     * 动态数组是否为空
     * @return      动态数组是否为空
     */
    public Boolean isEmpty(){}

    /**
     * 添加元素
     * @param element   元素
     */
    public void add(E element){}

    /**
     *
     *  0 1 2 3 4 5 6 7 8 9
     *  1 2 3   4 5 6 7 8
     * 向指定位置添加元素
     * @param index     位置
     * @param element   元素
     */
    public void add(int index,E element){}

    /**
     *
     *  0 1 2 3 4 5 6 7 8 9
     *  a b c 1 d e f g h
     * 移除指定位置的元素
     * @param index     位置
     */
    public void remove(int index){}

    /**
     * 删除指定元素
     * @param element   元素
     */
    public void remove(E element){}

    /**
     * 清空动态数组中的元素
     */
    public void clear(){}

    /**
     * 修改指定位置的元素
     * @param index      位置
     * @param element    元素
     */
    public void set(int index,E element){}

    /**
     * 获得指定位置的元素
     * @param index     位置
     * @return          元素
     */
    public E get(int index){}

    /**
     * 判断数组是否包含该元素
     * @param element    元素
     * @return           true包含，false不包含
     */
    public Boolean contains(E element){}

    /**
     * 该元素第一次出现的下标
     * @param element    元素
     * @return           下标
     */
    public int indexOf(E element){}

    @Override
    public String toString() {}
}

size()

返回动态数组的大小

    public int size(){
        return size;
    }

isEmpty()

返回动态数组是否为空，判断size是否为0

    public Boolean isEmpty(){
        return size == 0;
    }

toString()

打印动态数组，这个按照自己的需求来就可以了

    @Override
    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("ArrayList{");
        string.append("size=" + size + ", elements=[");
        for (int i = 0; i < size; i++) {
            string.append(elements[i]);
            if (i != size -1) { //最后一个元素末尾不添加逗号
                string.append(", ");
            }
        }
        string.append("]");
        string.append("}");
        return string.toString();
    }

indexOf()和contains()

indexOf()返回的元素第一次出现的下标（循环数组，如果有该元素则返回下标，下标为-1则表示没有该元素）

    public int indexOf(E element){
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)) return i; //如果element存在返回下标
        }
        return -1;
    }

contains()判断是否存在该元素，利用indexOf()来判断，如果存在下标则说明存在该元素，不存在下标则不存在该元素

    public Boolean contains(E element){
        return indexOf(element) >= 0;
    }

get()

返回指定下标的数组元素

    public E get(int index){
        return elements[index];
    }

set()

向指定下标塞入元素

    public void set(int index,E element){
        elements[index] = element;
    }

add()

添加元素，向动态数组末尾添加元素。

    public void add(E element){
        elements[size] = element;
        size++;
    }

重载方法add(int index, E element)向指定位置添加元素，原来的元素会依次向后挪动。元素挪动的目的是为了空出index下标的元素，所以index下标及其后面的元素都需要依次往后挪动。挪动的顺序应是

在这里插入图片描述

注意第一是先挪动最后一个，如果你从index才是挪动后面的会被覆盖。依次挪动然后index下标处元素就会被空出来，然后塞入要插入的元素即可。

    public void add(int index,E element){
        for (int i = size; i > index ; i--) { //元素依次往后挪动
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

同理，其实add(E element)就是往动态数组末尾添加元素，所以可以直接调用重载方法，指定下标为末尾（size）就可以了。

    public void add(E element){
        add(size,element);
    }

remove()

移除指定位置的元素，移除指定位置的元素之后，指定位置的元素会被删除，然后指定位置后面的元素会依次往前挪动。

在这里插入图片描述

注意，实际上不用硬性删除指定的元素，在Java的特性中，只要某一内存地址没有再被指向那么它就会被垃圾回收掉（视为删除），所以直接用后面的元素直接覆盖掉指定下标的元素，原来的元素的地址就没有被指向了，所以就会被删除，最后再将末尾的一个元素置为null即可。但是需要注意的是删除是先挪动前面再挪动后面，如果从后往前挪会被覆盖掉。

    public void remove(int index){
        for (int i = index; i < size-1 ; i++) { //元素依次往前挪
            elements[i] = elements[i+1];
        }
        elements[size-1] = null; //将数组的最后一个元素置为null
        size--;
    }

clear()

清空动态数组，直接将所有位置置为null即可，那么之前的元素的地址就不没有被指向了，就会被删除。

    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

下标越界

在上述方法传入index的时候，可能会出现index越界的情况，比如为负数或者超出上限，所以需要控制index的有效范围，并且在每次传入进行检查就可以了，错误就抛出异常。

注意

add()和remove()、get()、set()的index范围有所区别。添加元素允许往动态数组的最后一个位置添加元素，所以index是可以访问到size的，但是删除、查询和修改都是在元素已经在动态数组中存在的基础上，所以index是不可以访问到size的，切记！！！

checkIndex()

检查非添加时的下标index，不能小于0或者不能大于等于size（0<index<size）

private void checkIndex(int index){
    if (index<0||index>=size) indexOutOfBoundsException(index);
}

checkIndexAdd()

检查添加时下标index，不能小于0或者不能大于size（0<index ⩽ \leqslant ⩽​size）

private void checkIndexAdd(int index){
    if (index<0||index>size) indexOutOfBoundsException(index);
}

indexOutOfBoundsException()

下标越界时抛出的自定义异常

private void indexOutOfBoundsException(int index){
    throw new IndexOutOfBoundsException("index="+index+", size="+size);
}

动态扩容

动态数组相较于传统数组的优势就是能够动态扩容，但其实底层仍然是利用数组扩容，实质就是利用新的容量的数组来装填原来的数据，这当中会涉及到很多底层的内存消耗以及资源最优化的问题，这里不讲解，主要讲解如何实现。

扩容也只可能会在添加元素的时候发生，并且是添加元素时的动态数组的size也就是元素个数刚好达到容量这个时候就该扩容了：

  1. 判断动态数组元素个数已经达到数组容量，说明已经满了需要扩容了
  2. 新的数组容量为当前数组容量的1.5倍
  3. 以新的数组容量大小创建数组
  4. 旧数组依次向新的数组赋值
  5. 旧数组的指针指向新数组
public void add(int index,E element){
    checkIndexAdd(index);
    if (size == elements.length){ //如果动态数组得大小已经达到数组容量（已满）
        int nowCapacity = elements.length;                  //当前动态数组容量就是数组长度
        int newCapacity = nowCapacity + (nowCapacity >> 1); //扩容至当前容量得1.5倍
        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) { //旧数组依次向新数组中赋值
            newElements[i] = elements[i];
        }
        elements = newElements;     //elements对象指向newElements
        System.out.println(nowCapacity + "扩容至" + newCapacity);
    }
    for (int i = size; i > index ; i--) { //元素依次往后挪动
        elements[i] = elements[i - 1];
    }
    elements[index] = element;
    size++;
}

我们将数组扩容单独提出来（提高可维护性和可读性）

    private void ensureCapacity(){
        if (size == elements.length){ //如果动态数组得大小已经达到数组容量（已满）
            int nowCapacity = elements.length;                  //当前动态数组容量就是数组长度
            int newCapacity = nowCapacity + (nowCapacity >> 1); //扩容至当前容量得1.5倍
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) { //旧数组依次向新数组中赋值
                newElements[i] = elements[i];
            }
            elements = newElements;     //elements对象指向newElements
            System.out.println(nowCapacity + "扩容至" + newCapacity);
        }
    }

综合：

    private void ensureCapacity(){
        if (size == elements.length){ //如果动态数组得大小已经达到数组容量（已满）
            int nowCapacity = elements.length;                  //当前动态数组容量就是数组长度
            int newCapacity = nowCapacity + (nowCapacity >> 1); //扩容至当前容量得1.5倍
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) { //旧数组依次向新数组中赋值
                newElements[i] = elements[i];
            }
            elements = newElements;     //elements对象指向newElements
            System.out.println(nowCapacity + "扩容至" + newCapacity);
        }
    }

    public void add(int index,E element){
        checkIndexAdd(index);
        ensureCapacity();
        for (int i = size; i > index ; i--) { //元素依次往后挪动
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

缩容

在很多时候可能动态数组中没有使用的位置占比较多时，就可以使用缩容来节省空间。比如动态数组容量由于不断add然后扩容到了1000个，但是这个时候只用了100个来装元素，剩下的900个都没用装元素，这个时候其实是浪费的。所以可以考虑采用缩容的方式来节省空间。

remove

如果当前数组大小（元素个数）比当前容量的一半还要小并且当前容量大于默认容量时开始缩容：创建一个新的数组（大小为原容量的一半），然后旧数组依次赋值。

	public void remove(int index){
        checkIndex(index);
        //缩容开始
        int nowCapacity = elements.length;  //当前容量
        if ( size <= nowCapacity>>1 && nowCapacity>DEFAULT_CAPACITY){
            int newCapacity = nowCapacity>>1; //即nowCapacity/2
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) {
                newElements[i] = elements[i];
            }
            elements = newElements;
            System.out.println(nowCapacity + "缩容至" + newCapacity);
        }
        //缩容结束
        for (int i = index; i < size-1 ; i++) { //元素依次往前挪
            elements[i] = elements[i+1];
        }
        elements[size-1] = null; //将数组的最后一个元素置为null
        size--;
    }

即trim()：

	/**
     * 缩容（在动态数组中未使用的部分过大时缩容）
     */
    private void trim(){
        int nowCapacity = elements.length;  //当前容量
        //如果当前数组元素个数比当前容量的一半还要小，并且容量是大于默认容量的则开始缩容
        if ( size <= nowCapacity>>1 && nowCapacity>DEFAULT_CAPACITY){
            int newCapacity = nowCapacity>>1; //即nowCapacity/2
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) {
                newElements[i] = elements[i];
            }
            elements = newElements;
            System.out.println(nowCapacity + "缩容至" + newCapacity);
        }
    }

remove()：

	public void remove(int index){
        checkIndex(index);
        trim();         //缩容
        for (int i = index; i < size-1 ; i++) { //元素依次往前挪
            elements[i] = elements[i+1];
        }
        elements[size-1] = null; //将数组的最后一个元素置为null
        size--;
    }

总结

在解决了动态数组的大小、元素存放的数组等属性和一些基本的添加、删除、修改和查询方法后，以及对下标越界的处理和最核心的动态扩容部分解决后，一个最基本的动态数组ArrayList就大致完成了：


public class ArrayList<E> {

    /**
     * 动态数组大小
     */
    private int size;

    /**
     * 动态数组
     */
    private E[] elements;

    /**
     * 动态数组默认容量
     */
    private static final int DEFAULT_CAPACITY = 10;


    /**
     * 无参构造，创建默认大小的数组
     */
    public ArrayList(){
        elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

    /**
     * 有参构造，根据容量创建数组
     * @param capacity      自定义容量
     */
    public ArrayList(int capacity){
        if (capacity<=0) capacity = DEFAULT_CAPACITY; //如果传入容量不为自然数，则强制为默认容量
        elements = (E[]) new Object[capacity];
    }

    /**
     * 动态数组大小
     * @return      动态数组大小
     */
    public int size(){
        return size;
    }

    /**
     * 动态数组是否为空
     * @return      动态数组是否为空
     */
    public Boolean isEmpty(){
        return size == 0;
    }

    /**
     * 下班超出范围的报错信息
     * @param index
     */
    private void indexOutOfBoundsException(int index){
        throw new IndexOutOfBoundsException("index="+index+", size="+size);
    }

    /**
     * 检查添加元素时候的index
     * @param index
     */
    private void checkIndexForAdd(int index){
        if (index<0||index>size) indexOutOfBoundsException(index);
    }

    /**
     * 检查删改查时的index
     * @param index
     */
    private void checkIndex(int index){
        if (index<0||index>=size) indexOutOfBoundsException(index);
    }

    /**
     * 确保容量（如果动态数组元素大小达到当前动态数组的容量满了则扩容）
     */
    private void ensureCapacity(){
        if (size == elements.length){ //如果动态数组得大小已经达到数组容量（已满）
            int nowCapacity = elements.length;                  //当前动态数组容量就是数组长度
            int newCapacity = nowCapacity + (nowCapacity >> 1); //扩容至当前容量得1.5倍
            E[] newElements = (E[]) new Object[newCapacity];
            for (int i = 0; i < size; i++) { //旧数组依次向新数组中赋值
                newElements[i] = elements[i];
            }
            elements = newElements;     //elements对象指向newElements
            System.out.println(nowCapacity + "扩容至" + newCapacity);
        }
    }

    /**
     * 添加元素
     * @param element   元素
     */
    public void add(E element){
        add(size,element);

    }

    /**
     *
     *  0 1 2 3 4 5 6 7 8 9
     *  1 2 3   4 5 6 7 8
     * 向指定位置添加元素
     * @param index     位置
     * @param element   元素
     */
    public void add(int index,E element){
        if (element == null) throw new NullPointerException("不允许添加null");
        checkIndexForAdd(index);
        ensureCapacity();                     //确保数组容量（如果容量满了则扩容）
        for (int i = size; i > index ; i--) { //元素依次往后挪动
            elements[i] = elements[i - 1];
        }
        elements[index] = element;
        size++;
    }

    /**
     *
     *  0 1 2 3 4 5 6 7 8 9
     *  a b c 1 d e f g h
     * 移除指定位置的元素
     * @param index     位置
     */
    public void remove(int index){
        checkIndex(index);
        for (int i = index; i < size-1 ; i++) { //元素依次往前挪
            elements[i] = elements[i+1];
        }
        elements[size-1] = null; //将数组的最后一个元素置为null
        size--;
    }

    /**
     * 删除指定元素
     * @param element   元素
     */
    public void remove(E element){
        remove(indexOf(element));
    }

    /**
     * 清空动态数组中的元素
     */
    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

    /**
     * 修改指定位置的元素
     * @param index      位置
     * @param element    元素
     */
    public void set(int index,E element){
        checkIndex(index);
        elements[index] = element;
    }

    /**
     * 获得指定位置的元素
     * @param index     位置
     * @return          元素
     */
    public E get(int index){
        checkIndex(index);
        return elements[index];
    }

    /**
     * 判断数组是否包含该元素
     * @param element    元素
     * @return           true包含，false不包含
     */
    public Boolean contains(E element){
        return indexOf(element) >= 0;
    }

    /**
     * 该元素第一次出现的下标
     * @param element    元素
     * @return           下标
     */
    public int indexOf(E element){
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)) return i; //如果element存在返回下标
        }
        return -1;
    }

    @Override
    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("ArrayList{");
        string.append("size=" + size + ", elements=[");
        for (int i = 0; i < size; i++) {
            string.append(elements[i]);
            if (i != size -1) { //最后一个元素末尾不添加逗号
                string.append(", ");
            }
        }
        string.append("]");
        string.append("}");
        return string.toString();
    }
}
F3nGaoXS
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础——ArrayList集合
qq_58390802的博客
03-19 1449
Java基础ArrayList集合的使用
Java集合实现（一） ArrayList源码以及手写ArrayList
m0_46013789的博客
09-07 610
简单来说，它就是一个动态数组 普通的数组一旦长度确认，长度就不再能改变。 而该ArrayList不一样，长度可变，就是一个动态大小的数组。
纯手写arrayList
qq_34051366的博客
06-30 165
list 集合
手写精简版List和ArrayList，适合新手入门学习jdk源码demo
06-04
手写精简版List和ArrayList，适合新手入门学习jdk源码demo，初学易懂
Java-自定义ArrayList类
qq_52998673的博客
08-09 1693
Java-自定义ArrayList类
46-Java知识点 手写ArrayList1
08-08
Java 知识点 手写 ArrayList Java 中最常用的类是 ArrayList，它的实现原理和方法非常重要。在面试中，经常要求手写一个 ArrayList，以考察应聘者对 ArrayList 的熟悉程度。本文将详细介绍如何手写一个 ArrayList，...
java集合-ArrayList的使用
06-14
ArrayList基于数组实现的动态数组，支持快速随机访问和元素的插入、删除操作。 ArrayList基于数组实现的动态数组，支持快速随机访问和元素的插入、删除操作。
Java中Vector与ArrayList的区别详解
09-05
Java中的ArrayList和Vector都是列表（List）接口的实现类，它们在功能上相似，但在细节上存在一些重要的差异。这两个类都是基于数组实现的，但它们的性能特点、线程安全性和扩容策略有所不同。 1. **扩容策略**： ...
Java容器ArrayList原理解析
08-25
ArrayList是Java中最常用的容器之一，它实现了List接口，提供了许多有用的方法来操作集合。下面我们将深入探讨ArrayList的原理和机制。 ArrayList的特点 ArrayList是一种基于数组的实现，它的主要特点有： * ...
java关键字ArrayList详解
07-04
ArrayList是Java中的一种常见的数据结构，它实现了List接口，是线程不安全的动态数组。它的容量可以自动增长，因此可以方便地插入、删除和查找数据，是Java集合框架中广泛使用的一种结构。 ArrayList的优势在于灵活...
简单实现arraylist
05-06
面试遇到的一个小的提问，回答的不是很好，自己回来又写了个
自定义实现的ArrayList
03-03
自定义实现的ArrayList数据结构，有大量注释以及编写思路，帮助新手用Java语言来实现数据结构
用java自己实现的arrayList
07-18
用java自己实现的arrayList，比较详细，有助于初学者理解arrayList的基本概念和基础用法
JAVA（手写）简单实现ArrayList和LinkedList
Simlier的博客
11-08 815
JAVA（手写）简单实现ArrayList和LinkedList 大家都知道在java学习中list类的实现类中有ArrayList 和LinkedList，其中ArrayList是使用数组实现，而LinkedList则是用链表实现的。今天就自己去用java去简单实现一下它们。 1.ArrayList的实现 1.类必须的属性 一个object的数组 list的长度 2.基本代码 `public c...
java手写ArrayList实现
GYJ_HL的博客
05-31 527
使用java实现ArrayList集合。 实现了简单的增删改查功能。 package list; import java.util.Arrays; /** * * @author Grant * * @param <E> 泛型 */ public class ArrayList<E> { // 数组容量； private int capacit...
手写ArrayList java 简单实现add() 、get()、length()
MADMY的博客
05-28 670
package Jobday10_ArrayList;public class MyArrayList {    private Object[] array;    private int size; //主方法测试类： public static void main(String[] args) {        MyArrayList list = new MyArrayList();   ...
JAVA---手写ArrayList
qq_42488087的博客
09-09 167
JAVA—手写ArrayList List接口 public interface List { // 返回线性表的大小，即数据元素的个数。 public int size(); // 返回线性表中序号为 i 的数据元素 public Object get(int i); // 如果线性表为空返回 true，否则返回 false。 public bo...
java ArrayList集合类的书写
wilver的博客
08-30 2517
java中的ArrayList的书写还是比较容易些的，所以就写了一遍import java.util.Arrays; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.NoSuchElementException;public class ArrayListsw
用java实现一个ArrayList
无名丶任性
08-04 730
通过查看ArrayList底层代码发现ArrayList有以下属性： ArayList: 1、ArrayList如果初始化的时候没有指定容量则默认大小为10，如果容量不够则按照“newCapacity=oldCapaCity+(oldCapaCity >> 1)”算法进行扩容（原容量的1.5倍进行扩容）； 2、ArrayList线程不安全，若要实现线程安全可以使用synchronized关键字或Collections.synchronizedList()方法初始化，如下 List lis
java 数组转arraylist
最新发布
11-26
要将Java数组转换为ArrayList，可以使用ArrayList的构造方法或者使用Collections类的addAll方法。 方法一：使用ArrayList的构造方法 可以使用ArrayList的构造方法将数组转换为ArrayList。示例代码如下： ```java ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值