Java：自己实现一个ArrayList

最新推荐文章于 2024-06-12 14:33:24 发布
最新推荐文章于 2024-06-12 14:33:24 发布
阅读量1k 收藏 5
点赞数 2
分类专栏： Java基础 数据结构 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45867071/article/details/119743904
版权

 Java：自己实现一个ArrayList

目录

 Java：自己实现一个ArrayList

一.MyList接口

二.实现MyArrayList的方法

1.检查范围checkRange()

2.add(),addAll()的实现

3.remove(),removeAll()的实现

4.sort()方法的实现

三.完整代码

四.关于在Java中System.arraycopy() 和 Arrays.copyOf()两者之间的区别

  为了更好地理解Java的ArrayList类，我们决定自己实现一个ArrayList类，就叫它MyArrayList吧！

一.MyList接口

  首先，我们先写一个MyList接口，将我们要实现的方法都列举出来：

public interface MyList<E> {
    
    /**
     *
     * @return 存储的元素个数
     */
    int size();

    /**
     * @param value 添加的元素
     */
    void add(E value);

    /**
     * 合并
     * @param list 需要合并的List
     */
    void addAll(MyList list);

    /**
     * 合并一个对象数组
     * @param objects
     */
    void addAll(E[] objects);
    
    /**
     * 获取：
     * @param index 根据下标获取
     * @return 返回元素对象
     */
    Object get(int index);

    /**
     * 根据元素查找
     * @param value
     * @return 下标数组
     */
    int[] get(E value);

    /**
     * 根据下标删除
     * @param index
     */
    void remove(int index);

    /**
     * 根据元素对象值删除
     * @param value
     * @return 是否删除成功
     */
    boolean remove(E value);

    /**
     * 清空队列
     */
    void removeAll();
    
    /**
     *
     * @param index 目标元素的下标
     * @param value 目标元素需要替换的对象
     */
    void set(int index,E value);

    /**
     *
     * @param repobj 目标元素对象
     * @param value 目标元素需要替换的对象
     */
    void set(E repobj,E value);
    
    /**
     * 排序 对象的 hashcode
     */
    void sort();
}

二.实现MyArrayList的方法

然后我们要做的就是逐个实现这些方法：

1.检查范围checkRange()

索引index必须在0到Integer.MAX_VALUE之间，否则抛出异常

//检查范围
    public void checkRange(int index) {
        if(index < 0 || index >= size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

2.add(),addAll()的实现

add系列的方法实现：关键在于扩容机制，其中add方法如果容量不够我们的做法是利用

Arrays.copyOf()将容量增加10.
    @Override   
    public void add(E value) {
        //扩展容量
        if(size >= arr.length) {
            Object[] newArr = Arrays.copyOf(arr, arr.length+10);
            arr = newArr;
        }
        arr[size++] = value;
    }

    @Override
    public void addAll(MyList list) {
        Object[] newArr = Arrays.copyOf(arr, arr.length+list.size());
        arr = newArr;
        System.arraycopy(list, 0, arr, size, list.size());
    }

    @Override
    public void addAll(E[] objects) {
        Object[] newArr = Arrays.copyOf(arr, arr.length+objects.length);
        arr = newArr;
        System.arraycopy(objects, 0, arr, size, objects.length);
    }

3.remove(),removeAll()的实现

其中remove(int index)方法是关键，remove(E value)、 removeAll()是在前者基础上实现的；

实现remove(int index)方法，我们的做法是以下标为index的元素为分界线，分别利用arraycopy方法将其前后的两段数组复制到一个新的数组newArray中去，然后让arr指向新的newArr；

    @Override
    public void remove(int index) {
        this.checkRange(index);

        Object[] newArr = new Object[arr.length-1];
        System.arraycopy(arr, 0, newArr, 0, index);
        System.arraycopy(arr, index+1, newArr, index, size-index-1);

        this.size -= 1;
        arr = newArr;
    }

    @Override
    public boolean remove(E value) {
        for(int i = 0; i < this.size; i++) {
            if(arr[i].equals(value)) {
                this.remove(i);
                return true;
            }
        }
        return false;
    }

    @Override
    public void removeAll() {
        for(int i = 0; i < arr.length; i++) {
            this.remove(i);
        }

        this.size = 0;
    }

4.sort()方法的实现

利用hashCode进行排序：

        @Override
        public void sort() {
            //利用hashCode进行排序
            int[] hash = new int[this.size];
            for(int i = 0; i < this.size; i++) {
                hash[i] = arr[i].hashCode();
            }
            //冒泡排序
            for (int i = 0; i < this.size; i++)
            {
                for (int j = 0; j < this.size -  i - 1; j++)
                {
                    if (hash[j] > hash[j + 1])
                    {
                        Object temp1 = null;
                        temp1 = this.arr[j + 1];
                        this.arr[j + 1] = this.arr[j];
                        this.arr[j] = temp1;

                        int temp2 = 0;

                        temp2 = hash[j + 1];
                        hash[j + 1] = hash[j];
                        hash[j] = temp2;
                    }
                }
            }
        }

三.完整代码

给各位hxdm完整代码：

import java.util.Arrays;

public class MyArrayList<E> implements MyList<E> {
    //数组最小大小
    private static final int MIN_SIZE = 10;
    //数组最大大小
    private static final int MAX_SIZE = Integer.MAX_VALUE;
    //数组中元素的个数
    private int size = MIN_SIZE;
    //声明数组arr
    private Object[] arr = null;

    //检查范围
    public void checkRange(int index) {
        if(index < 0 || index >= size) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public MyArrayList() {
        arr = new Object[this.MIN_SIZE];
    }

    public MyArrayList(int length) {
        //长度小于0，异常
        if(length < 0) {
            try {
                throw new Exception();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //长度大于等于0小于10，设置为最小长度
        else if(length >= 0 && length < MIN_SIZE) {
            length = MIN_SIZE;
        }
        arr = new Object[length];
        size = 0;
    }

    public MyArrayList(Object[] arr) {
        this.size = arr.length;
        System.arraycopy(arr, 0, this.arr, 0, arr.length);
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public void add(E value) {
        //扩展容量
        if(size >= arr.length) {
            Object[] newArr = Arrays.copyOf(arr, arr.length+10);
            arr = newArr;
        }
        arr[size++] = value;
    }

    @Override
    public void addAll(MyList list) {
        Object[] newArr = Arrays.copyOf(arr, arr.length+list.size());
        arr = newArr;
        System.arraycopy(list, 0, arr, size, list.size());
    }

    @Override
    public void addAll(E[] objects) {
        Object[] newArr = Arrays.copyOf(arr, arr.length+objects.length);
        arr = newArr;
        System.arraycopy(objects, 0, arr, size, objects.length);
    }

    @Override
    //返回下标为index的元素的值
    public Object get(int index) {
        this.checkRange(index);
        return arr[index];
    }

    @Override
    public int[] get(E value) {
        int[] ret = new int[size];
        int index = 0;
        for(int i = 0; i < size; i++) {
            if(arr[i] == value) {
                ret[index] = i;
                index++;
            }
        }
        return ret;
    }

    @Override
    public void remove(int index) {
        this.checkRange(index);

        Object[] newArr = new Object[arr.length-1];
        System.arraycopy(arr, 0, newArr, 0, index);
        System.arraycopy(arr, index+1, newArr, index, size-index-1);

        this.size -= 1;
        arr = newArr;
    }

    @Override
    public boolean remove(E value) {
        for(int i = 0; i < this.size; i++) {
            if(arr[i].equals(value)) {
                this.remove(i);
                return true;
            }
        }
        return false;
    }

    @Override
    public void removeAll() {
        for(int i = 0; i < arr.length; i++) {
            this.remove(i);
        }

        this.size = 0;
    }

    @Override
    public void set(int index, E value) {
        this.checkRange(index);

        arr[index] = value;
    }

    @Override
    public void set(E repobj, E value) {
        for(int i = 0 ; i < this.size; i++) {
            if(arr[i].equals(repobj)) {
                arr[i] = value;
            }
        }
    }

    @Override
    public void sort() {
        //利用hashCode进行排序
        int[] hash = new int[this.size];
        for(int i = 0; i < this.size; i++) {
            hash[i] = arr[i].hashCode();
        }
        //冒泡排序
        for (int i = 0; i < this.size; i++)
        {
            for (int j = 0; j < this.size -  i - 1; j++)
            {
                if (hash[j] > hash[j + 1])
                {
                    Object temp1 = null;
                    temp1 = this.arr[j + 1];
                    this.arr[j + 1] = this.arr[j];
                    this.arr[j] = temp1;

                    int temp2 = 0;

                    temp2 = hash[j + 1];
                    hash[j + 1] = hash[j];
                    hash[j] = temp2;
                }
            }
        }

    }

}

四.关于在Java中System.arraycopy() 和 Arrays.copyOf()两者之间的区别

这篇文章讲的很不戳：

链接

Chamberlain T
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础——ArrayList集合
qq_58390802的博客
03-19 1463
Java基础ArrayList集合的使用
用java自己实现的arrayList
07-18
用java自己实现的arrayList，比较详细，有助于初学者理解arrayList的基本概念和基础用法
Java实现自己的ArrayList
hjlooper的博客
07-06 236
java实现了ArrayList的基本操作
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
最新发布
秋刀鱼不做梦的编程日常
06-12 2675
Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
Java-自定义ArrayList类
qq_52998673的博客
08-09 1714
Java-自定义ArrayList类
创建一个自己的MyArrayList类，实现ArrayList的部分功能
qq_50852965的博客
09-18 1029
创建一个MyArrayList的类，并实现如下的方法： //获取长度 int getSize(); //获取容量 int getCapacity(); //判断是否为空的方法 boolean isEmpty(); //添加元素的方法 void add(E data); void add(int index,E data); //删除元素的方法 E delete(int index); E deleteFirst(); E deleteLast(); //获取元素下标的方法 int indexOf(E dat
【Java】List集合之ArrayList
weixin_53972936的博客
03-12 2465
​ List集合下共有ArrayList、LinkedList、Vector三种实现方法，但是ArrayList是 java 集合框架中比较常用的数据结构。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 每一个ArrayList都有一个初始化的容量（10），该容量代表了数组的大小，随着容器
java数据结构——顺序表（MyArrayList的实现）
weixin_62144403的博客
10-12 506
实现一个自己顺序表MyArrayList来体会顺序表背后对元素的存储和操作过程
MyArrays:我自己的Java ArrayList类的实现
03-30
在Java编程语言中，ArrayList是集合框架（Collections Framework）的一部分，它是一个动态数组，允许我们存储、添加、删除和操作对象。ArrayList类是基于数组的数据结构，提供了许多实用的方法来处理列表中的元素。...
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList是Java集合框架中常用的列表实现之一，它作为动态数组，允许我们在运行时根据需要增加或减少元素。ArrayList继承自AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口。这意味着...
java 中ArrayList迭代的两种实现方法
08-29
在Java编程语言中，ArrayList是ArrayList类的一个实例，它继承自AbstractList并实现了List接口。ArrayList主要用于存储可变大小的对象数组。当我们需要遍历ArrayList中的元素时，有两种主要的迭代方式：通过`...
简单实现arraylist
05-06
面试遇到的一个小的提问，回答的不是很好，自己回来又写了个
Java ArrayList 实现实例讲解
09-01
ArrayList是Java集合框架中的一员，它是一个基于数组实现的动态列表。ArrayList的主要特点是其容量能够自动增长，以适应添加更多的元素。在Java中，ArrayList类位于`java.util`包下，它实现了`List`接口，同时也实现...
DynamicMatrix-2d:在Java中使用Arraylist类实现动态矩阵结构
03-06
使用ArrayList实现动态矩阵的一个主要优点是灵活性。由于ArrayList可以动态扩展，所以矩阵的行数和列数可以在程序运行时自由增加或减少。此外，由于ArrayList提供了丰富的API，如`add()`, `get()`, `set()`, `remove...
原来Java中有两个ArrayList
09-02
然而，有些开发者可能会惊讶地发现，Java中其实存在两个“ArrayList”：一个是大家熟知的`java.util.ArrayList`，另一个则是`java.util.Arrays.ArrayList`。这两个类虽然名字相似，但在功能和使用场景上却有着显著的...
如何实现Java的ArrayList经典实体类
08-31
SimpleArrayList 提供了两个构造器：一个无参构造器和一个带 int 参数的构造器。无参构造器默认创建一个大小为 10 的数组，而带参数的构造器允许用户自定义初始容量。在 SimpleArrayList 中，`elementData` 是用于...
自定义实现一个java中ArrayList类。
m0_46123217的博客
03-03 386
自定义实现一个java中ArrayList类。 文章目录一、顺序表是什么二、ArrayList三、测试总结 一、顺序表是什么 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 二、ArrayList 代码如下： import java.util.Arrays; public class MyArrayList { private int[] elem; private int usedSize; public
Java中ArrayList的创建
qq_46622940的博客
08-12 2927
关于ArrayList的创建以及ArrayList扩容的原理
Java代码实现ArrayList
1 Byte 的博客
09-26 1498
ArrayList结构图 Java代码实现ArrayList 注意点：注意数组下标越界问题 public class MyArrayList<E> { // 数组长度 private int size; // 数组已存数据的大小 private int index; // 声明数组 private E dadaArr[]; // 构造函数完成初始化 public MyArrayList(int size){ t
ArrayList详解：Java List接口实现与实战应用
在ArrayList的使用中，值得注意的是索引从0开始，get()方法用于获取指定索引处的元素，这也是多态的一个体现，因为get方法调用的是ArrayList类的具体实现。当打印对象时，由于多态性，会自动调用对象的toString()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值