MyArrayList的实现

最新推荐文章于 2023-08-17 16:36:58 发布
最新推荐文章于 2023-08-17 16:36:58 发布
阅读量371 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： arraylist java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/AllenDA1/article/details/107453944
本文介绍了如何实现一个自定义的MyArrayList，包括定义MyList和MyIterator接口，设计ArrayList的常量、属性、构造方法和API。讨论了添加、删除、修改和查找操作的实现细节，如扩容策略、内存泄漏预防以及对null元素的处理。同时，还阐述了迭代器的内部类实现，强调了在删除操作中正向与逆向遍历的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MyArrayList的实现

定义两个接口MyList和MyIterator。定义好集合和迭代器的规则（方法只实现增删改查及迭代器）

 public interface MyList<E> extends Iterable<E> {
 ​
     boolean add(E e);
 ​
     void add(int index, E e);
 ​
     E remove(int index);
 ​
     boolean remove(Object obj);
 ​
     void clear();
 ​
     boolean contains(Object obj);
 ​
     E get(int index);
 ​
     int index(Object obj);
 ​
     int lastIndexOf(Object obj);
 ​
     MyIterator<E> iterator();
 ​
     MyIterator<E> iterator(int index);
     
 }
 import java.util.Iterator;
 ​
 public interface MyIterator<E> extends Iterator<E> {
     boolean hasNext();
 ​
     boolean hasPrevious();
 ​
     E next();
 ​
     E previous();
 ​
     int nextIndex();
 ​
     int prevIndex();
 ​
     void add(E e);
 ​
     void remove();
 ​
     void set(E e);
 }

对于ArrayList，要对其常量、属性、构造方法、API进行设计

常量：要确定底层数组的最大容量和默认容量

 private static final int DEFAULT_CAPACITY = 10;
 private static final int MAX_CAPACITY = Ineger.MAX_VALUE - 8;

 

属性：底层是数组

 private Object[] elements;
 private int size;
 private int modCount;   //统计集合结构修改的次数，验证迭代器是否失效

 

构造方法

 public MyArrayList() {
     elements = new Object[DEFAULT_CAPACITY];
 }
 ​
 public MyArrayList(int initialCapacity) {
     if (initialCapacity <= 0 || initialCapacity > MAX_CAPACITY)
         throw new IllegalArgumentException("initialCapacity=" + initialCapacity);
     elements = new Object[initialCapacity];
 }

 

API：

增： boolean add(E e) void add(int index, E e)

tips：

  • 计算扩容长度时，可以使用移位运算符

  • 在grow()扩容方法中，要记得将elements数组指向已经扩容好的数组

 public boolean add(E e) {
     add(size, e);
     return true;
 }
 public void add(int index, E e) {
     //判断索引是否合法
     checkIndexForAdd(index);
     //判断是否需要扩容
     if (size == elements.length) {
         // 计算新数组的容量
         int minCapacity = size + 1;
         int newCapacity = calculateCapacity(minCapacity);
         // 扩容
         grow(newCapacity);
     }
     // 添加元素
     for (int i = size; i > index; i--) {
         elements[i] = elements[i - 1];
     }
     elements[index] = e;
     size++;
     modCount++;
 }
 ​
 private void grow(int newCapacity) {
     Object[] newArr = new Object[newCapacity];
     // 复制数据
     for (int i = 0; i < size; i++) {
         newArr[i] = elements[i];
     }
     // elements指向新数组
     elements = newArr; // Caution!
 }
 ​
 private int calculateCapacity(int minCapacity) {
     if (minCapacity > MAX_CAPACITY || minCapacity < 0) {
         throw new ArrayOverflowException();
     }
     // 一定容纳下minCapacity个元素
     int newLength = elements.length + (elements.length >> 1);
     if (newLength > MAX_CAPACITY || newLength < 0) {
         newLength = MAX_CAPACITY;
     }
     // 返回minCapacity和newLength的最大值
     return newLength > minCapacity ? newLength : minCapacity;
 }
 ​
 private void checkIndexForAdd(int index) {
     if (index < 0 || index > size) {
         throw new IndexOutOfBoundsException("index=" + index + ", size=" + size);
     }
 }

 

删：E remove (int index) boolean remove(Object obj) void clear()

tips:

  • 删除操作所检查的索引范围时[0,size-1]，注意与增加操作区分开

  • clear()中，要把所有元素值置为null，避免内存泄漏

 public E remove(int index) {
     //首先要检查索引的合法性
     checkIndex(index);
     E removeValue = (E) elements[index];
     //将索引后的元素都前移
     for (int i = index; i < size - 1; i++) {
         elements[i] = elements[i + 1];
     }
     elements[--size] = null;    //最后一个元素置为null值，避免内存泄漏
     modCount++;
     return removeValue;
 ​
 }
 ​
 private void checkIndex(int index) {
     //，注意检查的值与检查增加的索引值不同。范围[0,size-1]
     if (index < 0 || index >= size)
         throw new IndexOutOfBoundsException("index=" + index + ",size=" + size);
 }
 public boolean remove(Object obj) {
     //这里调用indexOf(obj)就可以找到目标索引。有了索引直接调用remove(index)即可
     int index = indexOf(obj);
     if (index == -1) return false;
     remove(index);
     return true;
 }
 public void clear() {
     //把集合中的元素都置为null值
     for (int i = 0; i < size; i++) {
         elements[i] = null;
     }
     size = 0;
     modCount++;     //修改了集合结构
 }

 

改： E set(int index, E e)

 public E set(int index, E e) {
     checkIndex(index);
     E oldValue = (E) elements[index];
     elements[index] = e;
     return oldValue;
 }

 

查： int indexOf(Object obj) lastIndexOf(Object obj) boolean contains(Object obj)

E get(int index) boolean isEmpty() int size()

tips：

  • 注意要判断指定对象的值是否为null（分情况），因为List集合是可以存储null元素的。判断的时候也要分情况，看代码吧

 public int indexOf(Object obj) {
     if (obj == null) {
         for (int i = 0; i < size; i++) {
             if (elements[i] == null) return i;
         }
     }
     else {
         for (int i = 0; i < size; i++) {
             if (obj.equals(elements[i])) return i;
         }
     }
     return -1;
 }
 public int lastIndexOf(Object obj) {
     if (obj == null) {
         for (int i = size - 1; i >= 0; i--) {
             if (obj.equals(elements[i])) return i;
         }
     }
     else {
         for (int i = size - 1; i >= 0; i--) {
             if (obj.equals(elements[i])) return i;
         }
     }
     return -1;
 }
 public boolean contains(Object obj) {
     return indexOf(obj) != -1;
 }
 public E get(int index) {
     checkIndex(index);
     return (E) elements[index];
 }
 public boolean isEmpty() {
     return size == 0;
 }
 public int size() {
     return size;
 }

迭代器部分

迭代器使用内部类方式定义

属性

 int cursor;
 int lastRet = -1;   //最近返回元素的索引，-1代表最近未返回元素
 int expCount = modCount;    //当前集合修改次数为期望次数

构造方法

 Itr() {}
 ​
 Itr(int index) {
     cursor = index; //将光标置为index
 }

API

 public boolean hasNext() {
     return cursor != size;
 }
 public boolean hasPrevious() {
     return cursor != 0;
 }
 public E next() {
     //判断迭代器是否有效
     checkConModException();
     //判断光标后面还有元素嘛
     if (!hasNext())
         throw new NoSuchElementException();
     //简化了步骤，返回的是光标经过的值，也就是当前光标后的索引
     //lastRet = cursor，然后cursor后移
     lastRet = cursor++;
     return (E) elements[lastRet];
 }
 ​
 private void checkConModException() {
     if (expCount != modCount)
         throw new ConcurrentModificationException();
 }
 public E previous() {
     checkConModException();
     if (!hasPrevious())
         throw new NoSuchElementException();
     //cursor指向的元素是前面那一个，lastRet要先--在获取
     lastRet = --cursor;
     return (E) elements[lastRet];
 }
 public int nextIndex() {
     return cursor;
 }
 public int prevIndex() {
     return cursor - 1;
 }
 public void add(E e) {
     checkConModException();
     //这里是内部类，调用外部类方法，必须要借助外部类对象
     //这里和remove不同，lastRet可能为-1.cursor为0
     MyArrayList.this.add(cursor, e);    //这里modCount++,修改了集合结构
     //修改迭代器属性
     expCount = modCount;    //通过迭代器修改，允许修改，将expCount的值变为当前修改次数
     lastRet = -1;           //修改之后，上次返回值索引变为-1
     cursor++;
 }

 

 public void remove() {
     checkConModException();
     //判断最近是否有返回元素，因为删除操作必须对最近返回的元素(lastRet)进行删除，光标只负责指向的
     if (lastRet == -1)
         throw new IllegalArgumentException();
     MyArrayList.this.remove(lastRet);
     expCount = modCount;
     //关于cursor的变化，这里要分正向和逆向遍历讨论。结合画图可以找到对应规律！！
     cursor = lastRet;   //!!!!!
     lastRet = -1;
 }

注意删除操作中，要判断当前是正向遍历还是逆向遍历。画出图可得知相应规律(删除后的cursor始终等于lastRet)

 

 public void set(E e) {
     checkConModException();
 ​
     if (lastRet == -1)
         throw new IllegalArgumentException();
     elements[lastRet] = e;
     lastRet = -1;
 }

 

外部类调用了Iterator内部类的两个构造方法对创建Itr对象

 public MyIterator<E> iterator() {
     return new Itr();
 }
 public MyIterator<E> iterator(int index) {
     checkIndex(index);
     return new Itr(index);
 }
MyArrayList-基于ArrayList的简易实现
Galaxy_K的博客
02-10 1615
代码已托管至：https://github.com/GalaxyHe/DataStructure.git  希望大家可以随手star一下~        ArrayList是大家在实际中经常使用到的集合类之一。想要更加熟练地去运用它，必须先了解其底层实现原理。其实还是挺容易理解的：它是一个针对于List接口的数组实现,是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入甚至包括nu...
自定义MyArrayList类型基本功能的实现
qq_41004971的博客
02-22 982
ArrayList是我们平时所用到较多的一种可变长数组 特征：数组形式的操作方式，增删慢，查询快 数组：Object类型数组 方法：基本上都是从List接口中遵从实现的方法 在这里我们写一个自定义MyArrayList类型来实现ArrayList中基本的方法 /** * 自定义实现MyArraylist * @author yrm * * @param <E> 自定义泛型 */ pub...
MyArrayList.java
09-03
使用Java自定义实现ArrayList，增加、删除、查询等。
List(ArrayList/LinkedList/Vector)总结
m0_47300610的博客
10-06 213
ArrayList底层基于数组，数组在内存上是连续分配的地址空间，是对数组的升级，长度是动态的。 自定义ArrayList: class MyArrayList<E>{ private E[] elements;//存放元素的容器 private int size; //实际的元素个数 private final static int defaultCapacity = 5; //默认的初始化参数 public MyArrayList(){ this
简单实现MyArrayList
ArcProDreLHh的博客
01-05 725
这篇看不懂下篇看了也没有！ package cn.limbo.java_structure; import java.util.Iterator; import java.util.NoSuchElementException; /** * MyArrayList: * 1:保持基础数,数组的容量以及存储在MyArrayList中当前项数 * 2:提出一种机制用来改变基础数组的容量.获
ArrayList的具体实现，myArrayList
qq_42190158的博客
11-17 361
今天，复习了java 的容器框架，自己实现了个简单的myArrayList,包括get,set,add,remove,以及迭代器内部类的实现，自己敲了一遍，感觉不错， 我们知道，所有的容器类都是继承于Iterable接口的，实现该接口则必须提供一个Itrrator方法，用来返回一个迭代器对象，JDK中的Arraylist实现的是list接口，而list接口又继承于collection接口，coll...
C#自定义MyArrayList实现IEnumerable和IEnumerator
本文档主要介绍如何创建一个名为`MyArrayList`的自定义集合类，该类实现了`IEnumerable`和`IEnumerator`接口，这两个接口是.NET框架中的两个关键接口，用于处理可枚举的集合。 首先，`MyArrayList`类内部维护一个...
MyArrayList源码包
10-31
本文将通过分析一个名为"MyArrayList"的自定义实现，来深入探讨线性表的概念及其在Java中的具体实现，帮助新手更好地理解和应用此类数据结构。 首先，MyArrayList是基于MyList接口实现的，这个接口定义了线性表的...
1.MyArrayList(ArrayList底层实现).md
08-18
ArrayList. 底层用数组实现, 自己编写的MyArrayList,初始长度10,扩容2倍.
【Java数据结构】基于ArrayList实现一个MyArrayList
最新发布
weixin_65949261的博客
08-17 306
ArrayList是基于顺序表设计的一个能够动态存储的容器。对于数组长度不可变的限制，ArrayList提供了动态数组的功能，这对程序员编写代码提供了很大的便利。为了对ArrayList有一个更加深刻的认识，接下来我们自己实现一个简易版的Array List。
ArrayList的一个C++类模板实现
07-28
采用双层散列实现的一个ArrayList类模板，可以支持20M以上个数的对象的列表，利用双层链表做的一个散列实现，查询、插入的执行效率非常快。
自定义MyArrayList
weixin_30897233的博客
04-01 252
PS：如果觉得文章有什么地方写错了，哪里写得不好，或者有什么建议，欢迎指点。 ArrayList 类提供了 List ADT 的可增长数组的实现。 一、自定义实现的 ArrayList 类 MyArrayList 源码链接：戳此进GitHub查看 MyArrayList 泛型类实现了 Iterable 接口从而可以拥有增强 for 循环（for each 循环）。 public class M...
MyArrayList
Paul Joo的专栏
12-24 1415
MyArrayList将保持基础数组，数组的容量，以及存储在MyArrayList中的当前项数。 MyArrayList将提供一种机制以改变基础数组的容量。通过获得一个新数组，将老数组拷贝到新数组中来改变数组的容量，允许虚拟机回收老数组。 MyArrayList将提供get和set的实现。 MyArrayList将提供基本的例程，如size、isEmpty和clear。还提供remove，以
MyArryList
chengxunrenshen的博客
01-03 146
MyArrayList ArrayList自定义实现 import java.util.Arrays; public class MyArrayList<E> { // 增 删 改 查 // 定义数组 private E[] data; // 数组大小 private int size; // 抑制编译器警告 @SuppressWarnings("unchecked"...
小伙伴来自己实现一个ArrayList
duanyugen的专栏
08-28 2817
想来去年实习面试的时候，有公司发来面试题，要求自己实现一个List，当时觉得好难好难，现工作了，有空回来补习一下数据结构，在此与各位小伙伴共勉，望大家多多指教。 代码如下：package com.david.duan; import java.util.Iterator; import java.util.NoSuchElementException; public class MyArra
Java数据结构 ArrayList的简单MyArrayList编写
qq_46037971的博客
05-20 452
编写MyArrayList的基本思路 1.根据ArrayList，MyArrayList需要有clear(),size(),isEmpty(),get(index),set(index ,data),add(data),add(index , data),remove(index)方法。 2.MyArrayList需要提供一个实现Iterator接口的类，这个类current存储迭代序列下一项的下标，并重写hasnext()和next()方法，新增remove()方法，MyArrayList的迭代器方法
MyArrayList——自己实现ArrayList
a631278993的博客
10-15 294
注：转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/5965205.html 代码已移植：https://github.com/ygj0930/MyArrayList 大家fork之余随手给我个star呀~ ArrayList是我们常用的集合类之一，其实它的实现机制很简单，底层还是使用了一个传统的Array数组来...
c++实现的一个MyArrayList
anwenling5845的博客
09-24 445
MyArrayList类实现代码 1 #pragma once 2 3 template<class T> 4 class MyArrayList 5 { 6 public: 7 8 int Length; //list中已有的元素的个数 9 10 MyArrayList(void) 1...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值