看过源码了，那来手写一个ArrayList吧

已于 2022-04-16 19:35:59 修改
阅读量1k 收藏 7
点赞数 12
分类专栏： Java基础 文章标签： list java
于 2022-04-15 11:45:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50546235/article/details/124191438
版权

ArrayList

大家好，我是路不停_。

今天来分享一下手写一个小小ArrayList，希望对再看的小伙伴有所帮助！

希望大家一起不断成长。

ArrayList

数组是一种顺序存储的线性表，存储的地址是连续的。数组的一大缺点就是无法动态修改容量。

Java提供的包下的ArrayList，是为了弥补数组这一缺陷，我们也将ArrayList称为动态数组

相关接口

本文中，我实现了部分常用接口，ArrayList源码设计的比较庞大，继承了父类以及实现了很多接口。我们就不用这么麻烦了，手写一部分常用的方法逻辑以作学习。

  • int size(); // 元素的数量
  • boolean isEmpty(); // 是否为空
  • boolean contains(E element); // 是否包含某个元素
  • void add(E element); // 添加元素到最后面
  • E get(int index); // 返回index位置对应的元素
  • E set(int index, E element); // 设置index位置的元素
  • void add(int index, E element); // 往index位置添加元素
  • E remove(int index); // 删除index位置对应的元素
  • int indexOf(E element); // 查看元素的位置
  • void clear(); // 清除所有元素

实现之前，我们来说一说作为一个类来说，ArrayList内部需要的一些属性。

首先我们需要一个内部的数组，来存储数据。为了满足容量，以及遍历的操作，我们提供一个叫size的属性来描述，数组中有多少数据。

我们使用了泛型

public class ArrayList<E> {    
	private E[] element;
    private int size;
    //...接口
}

对于一个类来说，构造函数是必不可少的。我们也提供两个构造函数。当数量小于10的时候，默认设置数组大小为10，如果大于10就按照传入值设置大小

这里我们要注意，使用泛型的时候写成element = new E[capacity]；这样是不可取的，编译的时候不会通过，因为编译器无法获取到E的确定类型。

已知所有数据类型都可以放置在Object类型的数组中，这里发生是向上转型。基本数据类型的包装类是继承了Object的，而我们自己定义的一些类，默认也是继承Object的

public class ArrayList {    
	private int[] element;
    private int size;
    private static final int Default_Capacity = 10;
	public ArrayList(int capacity){
        capacity = (capacity > Default_Capacity ? capacity : Default_Capacity);
        element = (E[]) new Object[capacity];
    }
    public ArrayList(){
        this(Default_Capacity);
    }
    //...接口
}

那接下来，我们开始实现接口吧！

int size() 获取元素数量

public int size(){
        return size;
}

boolean isEmpty(); // 是否为空

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

boolean contains(E element); // 是否包含某个元素

public boolean contains(E value){
    return indexOf(value) != -1;
}

void add(E element); // 添加元素到最后面

  • 这里我们实现了复用接口
public void add(E value){
    /*element[size] = value;
    size++;*/
    add(size, value);
}

void add(int index, E element); // 往index位置添加元素

  • 对于下标不合法的情况，我们要抛出错误

  • add操作本质就是移位

    image-20220415111757742

  • 在添加元素之前，我们需要判定数组element空间是否足够，不够就需要扩容。创建一个新数组，将element的数据拷贝过去，然后就将element指向到这份新数组上

//保证容量
    public void addCapcity(int capacity){
        if(element.length >= capacity){
            return;
        }else{
            int newCapcity = element.length * 2;
            E[] newElement = (E[]) new Object[newCapcity];
            for(int i = 0; i < size; i++){
                newElement[i] = element[i];
            }
            element = newElement;
        }
    }
public void add(int index, E value){
    if(index < 0 || index > size){
        throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
    }
    addCapcity(size + 1);
    for(int i = size - 1; i >=index; i--){
        element[i+1] = element[i];
    }
    element[index] = value;
    size++;
}

E remove(int index); // 删除index位置对应的元素

  • 删除元素同样需要判断下标是否合理，删除的逻辑与添加的逻辑相似，也需要挪动数据

    image-20220415111156302

public E remove(int index){
    if(index < 0 || index >= size){
        throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
    }
    E tmp = element[index];
    for(int i = index + 1; i < size; i++){
        element[i - 1] = element[i];
    }
    size--;
    element[size] = null;
    return tmp;
}

int indexOf(E element); // 查看元素的位置

  • 注意我们这里使用equals，不使用==，使用==的时候，对于引用类型，判断的是地址是否相同，这样太狭隘了。我们一般会重写对象的equals。

    这里是我自定义类Person中的重写

    image-20220415113406098

  • 另外，这里我们少做了一些判断，当element中有null的时候，调用equals会判错。

    看看源码的写法：库中是对null进行了专门处理的。只能说太面面俱到了

    image-20220415113512713

public int indexOf(E value){
    for(int i = 0; i < size; i++){
        if(element[i].equals(value)) return i;
    }
    return -1;
}

E get(int index); // 返回index位置对应的元素

public E get(int index){
    if(index < 0 || index >= size){
        throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
    }
    return element[index];
}

E set(int index, E element); // 设置index位置的元素

public E set(int index, E value){
    if(index < 0 || index >= size){
        throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
    }
    E tmp = element[index];
    element[index] = value;
    return tmp;
}

void clear(); // 清除所有元素

  • 对于基本数据类型，我们当然可以直接size=0，但是ArrayList不仅仅需要存储基本数据类型，还需要存储引用数据类型，当存储引用数据类型的时候，数组中存储的实际是一个个地址值，然后指向堆空间的数据，我们要手动释放这些对象的空间，否则最终释放他们的时候，会是在程序结束以后。

    我们可以通过对象的finalize()方法确定这些堆空间内存确实被释放了

    image-20220415112431700

    如果我们采用size=0,就可以看到，不会打印Person销毁，也就是内存并不是我们手动释放的

  • 为什么不使用element = null呢？element=null是将ArrayList置空，那么我们再次使用一个ArrayList的时候就需要重新调用构造函数，申请空间。能重复利用为什么不用呢？

    当element=null的时候，我们将红线断开了，红线都断开了，更别说是黑线了，那么element和堆空间都不会通过arr找到，但是我们在程序后续还要使用arr的时候，就需要重新为element开辟空间。这样性能就不好了，所以我们采用将element中的每一个元素置空。当再次使用arr的时候，直接将element[i]指向对应地址即可

    image-20220415112909877

public void clear(){
    //销毁指向的引用数据变量
    for(int i = 0; i < element.length; i++){
        element[i] = null;
    }
    size = 0;
}

最后，为了实现打印，我们实现一个toString方法

public String toString(){
        StringBuffer string = new StringBuffer();
        string.append("size=").append(size).append(",[");
        for(int i = 0; i < size; i++){
            if(i != 0){
                string.append(",");
            }
            string.append(element[i]);
        }
        string.append("]");
        return string.toString();
    }

源码中的toString写在了继承的父类中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPvijwjf-1649994026251)(C:/Users/zzzy0/AppData/Roaming/Typora/typora-user-images/image-20220415105904831.png)]

代码

public class ArrayList<E> {
    private E[] element;
    private int size;
    private static final int Default_Capacity = 10;
    public ArrayList(int capacity){
        capacity = (capacity > Default_Capacity ? capacity : Default_Capacity);
        element = (E[]) new Object[capacity];
    }
    public ArrayList(){
        this(Default_Capacity);
    }
    public int indexOf(E value){
        for(int i = 0; i < size; i++){
            if(element[i].equals(value)) return i;
        }
        return -1;
    }

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

    public boolean contains(E value){
        return indexOf(value) != -1;
    }
    public int size(){
        return size;
    }
    public void add(E value){
        /*element[size] = value;
        size++;*/
        add(size, value);
    }
    public void addCapcity(int capacity){
        if(element.length >= capacity){
            return;
        }else{
            int newCapcity = element.length * 2;
            E[] newElement = (E[]) new Object[newCapcity];
            for(int i = 0; i < size; i++){
                newElement[i] = element[i];
            }
            element = newElement;
        }
    }

    public void add(int index, E value){
        if(index < 0 || index > size){
            throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
        }
        addCapcity(size + 1);
        for(int i = size - 1; i >=index; i--){
            element[i+1] = element[i];
        }
        element[index] = value;
        size++;
    }

    public void clear(){
        //销毁指向的引用数据变量
        //不压迫element = null--->循环利用
        for(int i = 0; i < element.length; i++){
            element[i] = null;
        }
        size = 0;
    }
    public E set(int index, E value){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
        }
        E tmp = element[index];
        element[index] = value;
        return tmp;
    }
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
        }
        return element[index];
    }
    public E remove(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:"+index + ",Size:"+size+",下标越界");
        }
        E tmp = element[index];
        for(int i = index + 1; i < size; i++){
            element[i - 1] = element[i];
        }
        size--;
        element[size] = null;
        return tmp;
    }

    public String toString(){
        StringBuffer string = new StringBuffer();
        string.append("size=").append(size).append(",[");
        for(int i = 0; i < size; i++){
            if(i != 0){
                string.append(",");
            }
            string.append(element[i]);
        }
        string.append("]");
//        System.out.println(string.toString());
        return string.toString();
    }
}

然后是我定义的Person，用来做测试泛型的

public class Person {

    public int age;
    private String name;
    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }
    public void finalize() throws Throwable{
        super.finalize();
        System.out.println("Person销毁了");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
}

最后：自己的一些感想

看了一些源码，觉得设计这些的人真是太强了，实现每一个接口，或者继承父类，达到复用的效果。

文章如果有错误，还请小伙伴们多多指正！
在这里插入图片描述

Gv_ee
关注
  • 12
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
手写精简版List和ArrayList，适合新手入门学习jdk源码demo
06-04
手写精简版List和ArrayList，适合新手入门学习jdk源码demo，初学易懂
ArrayList 源码深度解析
01-20
ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，存储了6个6的数组，下标（index）从0开始，数组（elementData）表示...
手写ArrayList（非常简单）
AlbenXie的博客
05-15 580
1、自定义异常类 package com.example.demo.myCollection; /** * @Description 数组索引越界异常类 * @Auther gf.x * @Date 2020/5/13 19:09 */ public class IndexOutOfBoundsMyException extends RuntimeException { private static final long serialVersionUID = -407752045512
手写ArrayList
weixin_43776741的博客
04-19 453
手写ArrayList 大家都知道ArrayList的底层实现是一个动态数组，以及有基本的增删查API，手写一个ArrayList来做简单的实现。 首先是基本的属性和构造方法，这里先不考虑负载因子和自动扩容。 ArrayList的新增是这样的，比如对原有数组执行add(3)时 当然，这是最简单的尾部新增，ArrayList的API里面还有一个是指定位置的新增元素，这个会稍微复杂一点，步骤大概如...
手写一个ArrayList
苏法迪的专栏
03-11 3310
1. 手写一个MyArrayList ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是支持动态扩容，即没有固定大小的限制，我们可以添加或删除元素。 ArrayList 本质是数组，故具有查询快，增删慢的特点 add()：新增时需要考虑扩容的因素。这个是区别数组的核心方法 get(): 非常好地体现出下标查找的优势，故查询快 remove()：体现出数组的缺点,删除一个元素，后面的元素需整体前移，故删除慢 优点： 1、根据下标遍历元素效率较高。 2、根据下标访问元素效率较高。 3
Java源码篇之容器类——ArrayList
12-20
Java源码篇之容器类——ArrayList1、前言2、ArrayList的类关系3、...对于平常开发的时候遇到的ArrayList，在此做一个简单的源码阅读记录，JDK1.8版本。 2、ArrayList的类关系 原创文章 13获赞 15访问量 7万+ 关注
ArrayList源码分析
01-20
ArrayList和Vector一样是基于数组实现的，ArrayList 就是一个数组队列，相当于 动态数组。容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable的方法，我们从它的...
基于jdk1.8 的ArrayList的源码分析
12-22
基于jdk1.8 的ArrayList的源码分析 前言：一说到ArrayList的大家可能立马想到的就是：有序、可重复、查找快但是增删慢、线程不安全。但是具体的原因都不是很清楚，本文就会根据这些问题和大家一起去学习。主要会从...
Java集合框架ArrayList源码分析（一）
09-01
主要为大家详细介绍了Java集合框架ArrayList源码分析，感兴趣的小伙伴们可以参考一下
手写ArrayList核心源码
九路
11-12 192
手写ArrayList核心源码 ArrayList是Java中常用的数据结构，不光有ArrayList，还有LinkedList,HashMap,LinkedHashMap,HashSet,Queue，PriorityQueue等等，我们将手写这些常用的数据结构的核心源码，用尽量少的代码来揭示核心原理。 下面我们来手写ArrayList的核心源码 首先我们定义一个QArrayList，不要问为什么叫QArrayList，因为我之前写过Qt，仅此而已。源码 public class<T> QArr
源码分析之手写ArrayList
qq_41988225的博客
11-28 156
public class ExtArrayList { // 底层采用数组存放 private Object[] elementData; // 数组默认容量 private static final int DEFAULT_CAPACITY = 10; // 实际arraylist长度 private int size; // 数组初始容量 public ExtArrayL...
手写ArrayList数组
Cris_Ronaldo的博客
01-22 150
介绍就不介绍了，我自己手写了ArrayList的add、remove、replace等方法，写的不好别见怪。也请各位大佬指教！ 直接上代码吧 package arrayList; /** * @author Cris * @version 1.0 * @className MyArrayList * @description <手写ArrayList> * @date 20...
如何手写一个ArrayList
Kerwin的博客
09-17 5466
写完HashMap，觉得手痒痒，所以隔了一天再来实现一下简单的ArrayList，ArrayList相比而言就非常的简单，主要的核心点有以下几个方面： 1.ArrayList的底层是由数组构成的 2.添加时需要考虑扩容问题 3.对于index索引的操作，需要考虑到下标不合法的异常 4.remove操作的时候，需要一点数学知识进行一下逻辑操作 下面贴出我的代码: MyList接口: ...
手写ArrayList，LinkedList
smile_juan
02-19 2353
虽然学习Java很长时间了，但是对数据结构一直很痛恨，更何况手写Collections之类的了，这次实在是没办法，所以看看书，上网看看别人怎么写的，扒了过来了，记个笔记方便以后复习，\(^o^)/~ ArrayList是比较好写，比较容易看懂的...... package com.juan; public class MyArrayList{          private s
手写arraylist底层数组，给我一个java代码~
最新发布
07-22
当然可以，这是一个简单的手写ArrayList底层数组的Java代码： ```java import java.util.Arrays; public class MyArrayList<E> { private static final int DEFAULT_CAPACITY = 10; private Object[] elements; private int size; public MyArrayList() { elements = new Object[DEFAULT_CAPACITY]; size = 0; } public void add(E element) { if (size == elements.length) { grow(); } elements[size++] = element; } public E get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(); } return (E) elements[index]; } public void remove(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(); } for (int i = index; i < size - 1; i++) { elements[i] = elements[i + 1]; } elements[--size] = null; } public int size() { return size; } private void grow() { int newCapacity = elements.length * 2; elements = Arrays.copyOf(elements, newCapacity); } } ``` 这是一个简单的ArrayList的实现，使用Object数组作为底层存储结构。它具有添加、获取、移除和获取大小等基本功能。需要注意的是，这只是一个简单的示例，没有考虑到并发和其他高级特性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值