手写简单的ArrayList（仿照源码）

最新推荐文章于 2022-04-07 20:17:44 发布
最新推荐文章于 2022-04-07 20:17:44 发布
阅读量218 收藏 2
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hobo_hua/article/details/105849143
版权

手写简单的ArrayList（仿照源码）

ArrayList简述

ArrayList底层使用的是数组，相对于LinkeList来说查询修改快，增删慢，适用于查询较多的场景。非线程安全。

  1. List 接口： List是Collection的子接口，它是一个元素有序(按照插入的顺序维护元素顺序)、可重复、可以为null的集合
  2. AbstractList 类： List接口的骨架实现类，最小化实现了List接口所需要实现的工作量
  3. 实现了Cloneable接口，即覆盖了函数clone()，能克隆;
  4. 实现了Cloneable接口，实现了该接口标示了类可以被序列化和反序列化
  5. RandomAccess 接口，实现了该接口的类支持快速随机访问

手写实现

定义属性
public class MyArrayList<E> {
    //初始容量
    private static final int DEFAULT_CAPACITY = 10;
    //初始的数组（空数组）
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //底层数组
    Object[] elementData;
    //包含的元素个数
    private int size;
增删改查方法
插入
/**
     * 添加元素
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        //是否对数组进行扩容
        ensureCapacityInternal(size + 1);
        //此时数组长度已扩容或长度够不需要扩容
        elementData[size++] = e;
        return true;
    }

    /**
     * 确保内部容量
     * 判断数组的容量，小于minCapacity就进行扩容1.5倍
     *
     * @param minCapacity
     */
    private void ensureCapacityInternal(int minCapacity) {
        //如果是空数组则 minCapacity = 10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        if (minCapacity - elementData.length > 0) {
            //原数组容量
            int oldCapacity = elementData.length;
            //扩容为之前的1.5倍（扩容因子为1.5）
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            //如果新容量 小于 最小容量，则新容量 = 最小容量
            if (newCapacity - minCapacity < 0) {
                newCapacity = minCapacity;
            }
            //ArrayList最大数组长度为Integer.MAX_VALUE - 8
            if (newCapacity > (Integer.MAX_VALUE - 8)) {
                // overflow
                if (minCapacity < 0) {
                    throw new OutOfMemoryError();
                }
                newCapacity = (minCapacity > Integer.MAX_VALUE - 8) ? Integer.MAX_VALUE : Integer.MAX_VALUE - 8;
            }
            //创建新长度的数组，并将原数组数据赋值给新数组
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

    /**
     * 添加元素至索引处，索引处和其之后的元素全部后挪一位
     *
     * @param index
     * @param element
     * @return
     */
    public E add(int index, E element) {
        //检查index是否合法
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("index不合法+ index:" + index + ",size:" + size);
        }
        //是否需要扩容,true->扩容
        ensureCapacityInternal(size + 1);
        //size-(index+1)+1
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        return null;
    }

    public void addAll(Collection<? extends E> e) {
    	//将集合e中的元素放到数组中
        Object[] a = e.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);
        //将新数组添加到底层数组的尾部
        System.arraycopy(a,0,elementData,size,numNew);
        size +=numNew;
    }
查询
	/**
	* 根据索引查询（数组的随机查询，效率高）
	* @param index
	* @return
	*/
	public E get(int index) {
	        //检查index是否合法（是否越界）
	        rangeCheck(index);
	        return (E) elementData[index];
	        //返回查询的元素
	    }
	
	/**
	 * 检查给定索引是否在数组的有效范围内
	 *
	 * @param index
	 */
	private void rangeCheck(int index) {
	    if (index >= size) {
	        throw new IndexOutOfBoundsException("index不合法！！index:" + index + ",size:" + size);
	    }
	}
修改
	/**
     * 根据索引修改元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element) {
        //检查index是否合法（是否越界）
        rangeCheck(index);
        E oldValue = (E) elementData[index];
        elementData[index] = element;
        return oldValue;
    }
删除
	/**
     * 根据索引删除元素，并将其之后的元素向前移一位
     * @param index
     * @return
     */
    public E remove(int index) {
        rangeCheck(index);
        E oldValue = (E) elementData[index];
        //要改变下标的元素个数 size-（index+1）
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            //从elementData数组的下标index+1开始，覆盖到从elementData数组的下标index的位置
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        //尾部的元素设置为null，size先-- 再使用
        elementData[--size] = null;
        return oldValue;
    }
	/**
     * 根据元素删除，遍历数组找到第一个于 o == 的元素 获取他的索引将其删除
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++) {
                if (elementData[index] == null) {
                    remove(index);
                    return true;
                }
            }
        } else {
            for (int index = 0; index < size; index++) {
                if (o.equals(elementData[index])) {
                    remove(index);
                    return true;
                }
            }
        }
        return false;
    }

实现代码

package com.clh.test.mylist;

import java.util.*;

/**
 * 手写ArrayList，底层是数组（Array），在查询大量数据时for遍历效率大于Iterator
 * 特点：查询快，增删慢 线程不安全 效率高
 *
 * @author 华华
 * @date 2020/4/29
 **/
public class MyArrayList<E> {

    /**
     * 初始容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 初始的数组（空数组）
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 底层数组
     */
    Object[] elementData;

    /**
     * 包含的元素个数
     */
    private int size;

    /**
     * 创建MyArrayList对象时，并且使elementData为默认长度（空）
     */
    public MyArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public MyArrayList(Collection<? extends E> e) {
        this();
        addAll(e);
    }


    public int size() {
        return size;
    }

    /**
     * 添加元素
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        //是否对数组进行扩容
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }

    /**
     * 确保内部容量
     * 判断数组的容量，小于minCapacity就进行扩容1.5倍
     *
     * @param minCapacity
     */
    private void ensureCapacityInternal(int minCapacity) {
        //如果是空数组则 minCapacity = 10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        if (minCapacity - elementData.length > 0) {
            //原数组容量
            int oldCapacity = elementData.length;
            //扩容为之前的1.5倍（扩容因子为1.5）
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            //如果新容量 小于 最小容量，则新容量 = 最小容量
            if (newCapacity - minCapacity < 0) {
                newCapacity = minCapacity;
            }
            //ArrayList最大数组长度为Integer.MAX_VALUE - 8
            if (newCapacity > (Integer.MAX_VALUE - 8)) {
                // overflow
                if (minCapacity < 0) {
                    throw new OutOfMemoryError();
                }
                newCapacity = (minCapacity > Integer.MAX_VALUE - 8) ? Integer.MAX_VALUE : Integer.MAX_VALUE - 8;
            }
            //创建新长度的数组，并将原数组数据赋值给新数组
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

    /**
     * 添加元素至索引处，索引处和其之后的元素全部后挪一位
     *
     * @param index
     * @param element
     * @return
     */
    public E add(int index, E element) {
        //检查index是否合法
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("index不合法+ index:" + index + ",size:" + size);
        }
        //是否需要扩容,true->扩容
        ensureCapacityInternal(size + 1);
        //size-(index+1)+1
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        return null;
    }

    public void addAll(Collection<? extends E> e) {
        Object[] a = e.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);
        //将新数组添加到底层数组的尾部
        System.arraycopy(a,0,elementData,size,numNew);
        size +=numNew;
    }

    /**
     * 根据索引查询（数组的随机查询，效率高）
     * @param index
     * @return
     */
    public E get(int index) {
        //检查index是否合法（是否越界）
        rangeCheck(index);
        return (E) elementData[index];
        //返回查询的元素
    }

    /**
     * 检查给定索引是否在数组的有效范围内
     *
     * @param index
     */
    private void rangeCheck(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException("index不合法！！index:" + index + ",size:" + size);
        }
    }

    /**
     * 根据索引修改元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element) {
        //检查index是否合法（是否越界）
        rangeCheck(index);
        E oldValue = (E) elementData[index];
        elementData[index] = element;
        return oldValue;
    }


    /**
     * 根据索引删除元素，并将其之后的元素向前移一位
     * @param index
     * @return
     */
    public E remove(int index) {
        rangeCheck(index);
        E oldValue = (E) elementData[index];
        //要改变下标的元素个数 size-（index+1）
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            //从elementData数组的下标index+1开始，覆盖到从elementData数组的下标index的位置
            System.arraycopy(elementData, index + 1, elementData, index, numMoved);
        }
        //尾部的元素设置为null，size先-- 再使用
        elementData[--size] = null;
        return oldValue;
    }

    /**
     * 根据元素删除，遍历数组找到第一个于 o == 的元素 获取他的索引将其删除
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++) {
                if (elementData[index] == null) {
                    remove(index);
                    return true;
                }
            }
        } else {
            for (int index = 0; index < size; index++) {
                if (o.equals(elementData[index])) {
                    remove(index);
                    return true;
                }
            }
        }
        return false;
    }
}

总结

很多场景下ArrayList更受欢迎，但是还有些情况下LinkedList更为合适。譬如：

  1. 你的应用不会随机访问数据。因为如果你需要LinkedList中的第n个元素的时候，你需要从第一个元素顺序数到第n个数据，然后读取数据。

  2. 你的应用更多的插入和删除元素，更少的读取数据。因为插入和删除元素不涉及重排数据，所以它要比ArrayList要快。

以上就是关于ArrayList和LinkedList的差别。你需要一个不同步的基于索引的数据访问时，请尽量使用ArrayList。ArrayList很快，也很容易使用。但是要记得要给定一个合适的初始大小，尽可能的减少更改数组的大小。

Hobo_hua
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Copy ArrayList的四种方式
vx539413949的博客
04-30 2637
简介 ArrayList是我们经常会用到的集合类，有时候我们需要拷贝一个ArrayList，今天向大家介绍拷贝ArrayList常用的四种方式。 使用构造函数 ArrayList有个构造函数，可以传入一个集合： public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) {
手写实现简易ArrayList
12-20
数组是最基本的数据结构，通过创建动态数组我们可以不再考虑必须为数组赋值得问题我们可以按自己的需求动态获取空间。 在此基础上我们可以实现队列和栈的应用` 将这个类用泛型标记表示可以创建任意类型集合 ...
java仿写ArrayList
幻影寒狼
10-27 502
ArrayList实现了长度可变的数组，在内存中分配连续的空间。 优点：遍历元素和随机访问元素的效率比较高 缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低。 为深入了解学习ArrayList，自己仿写了部分方法。 public class MyArrayList { private Object[] elementData; private int size;
ArrayList源码（二）：扩容和移位、删除元素详解
IT-CRUD
04-07 1399
关于ArrayList的文章有两篇，前一篇写了ArrayList的数据结构、扩容机制、源码分析等，这篇来看一下ArrayList的一些操作细节。 删除元素操作 通过foreach删除 List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.add("3"); for (String element : list) {
java中ArrayList的实现模拟
SimpleSimpleSimples的博客
12-13 487
1.ArrayList集合的特点          1.查询,更改较快,新增和删除较慢。          2.面试问得较多，一般要求模拟实现。 2.代码 Import java.util.Arrays; public class MyArrayList { // 将字段私有化，防止对象直接访问，只能通过公共方法在本类中访问 private Object[] elements
使用arraycopy（）进行数据删除和插入数据
qq_42765393的博客
04-08 244
//删除指定位置的数据 public static String[] removeElements(String[] s,int index) { System.arraycopy(s, index+1, s, index,s.length-index-1); s[s.length-1]=null; for(String str : s) { System.out...
简易仿写ArrayList
qq_37720933的博客
06-07 321
实现ArrayList基于数组的增删改查 class testList<E>{ //属性: //声明数组 private Object[] data; //记录大小 private int size; //集合: //创建数组 //有参 public testList(int x){ if(x<0) System.out.println("参数错误"...
仿写java中集合工具类中的ArrayList
dengit_w的博客
09-25 526
java的数据存储离不开集合工具，集合工具有很多种，今天在这就不一一举例了，进入今天的主题：先定义一个List的接口，定义一些仿ArrayList功能的方法public interface List { Object get(int index); boolean add(Object obj); void set(Object obj,int index); boolean
JAVA仿写ArrayList
去流浪
07-30 370
功能 Object get(int index); 获取该位置数据 boolean add(Object obj); 添加数据 void set(int index, Object obj); 替换该位置数据 boolean remove(int index); 清除该位置数据 boolean isEmpty(); list是否为空 boolean isFull(); list是否已满 int size(); 返...
100行代码手写模拟一个ArrayList
润青
11-13 355
一、ArrayList     首先ArrayList是一个List集合，底层的实现原理是数组，因此我们来手写模拟一下ArrayList，顺便复习下数组和数据结构。 二、结果演示：  2.1、测试add()、set()、get()方法 2.2、测试clear()方法 2.3、测试remove()方法 三、实现思路  get（) 实现思路：     首先，需要自定义一...
自己编码模拟实现ArrayList底层代码
MonkeyBrothers的博客
12-16 537
自己编码模拟实现ArrayList底层代码
Python手写识别源码.txt
12-19
Python手写识别源码.txt
基于python手写数字识别系统源码
最新发布
02-22
基于python手写数字识别系统源码 基于python的手写数字识别系统的目的就是在于建立属于自己的一套手写识别系统，在日常的工作中，手写识别是一件非常重要的事情，比如说企业或事业单位当中。需要电子版的手签章，...
tensorflow框架手写文字识别python源码案例.zip
07-09
用Python写的手写字体识别系统，基于TensorFlow的框架，很适合初学者的学习使用
手写springmvc源码
11-04
-------------------------1、技术工具选型------------------------- JDK: jdk1.8.1 J2EE: Servlet-api2.5 WEB Container： Tomcat8.5 IDE： IntelliJ IDEA2017 ... Apache maven3.5.4 -------------------------...
用java实现ArrayList(顺序存储结构)，并实现插入，删除等基本操作
HXZ_CREATE的博客
07-26 985
Java中的ArrayList在底层实际上使用数组实现的，它拥有和数组相似的特性，容易存取，不容易插入或者删除。 下面来看看如何手动实现一个ArrayLis，实现的ArrayList中增加有泛型。 首先创建一个名为hxzArrayList的类，里面有我们待实现的方法： class hxzArrayList<E>{ Object[] elementData;//定义容器中的属性 private int size;//容器中元素的个数 private static final int
ArrayList自己实现（添加，插入，删除，遍历）
CSDN1782747395的博客
03-20 2496
~~public class MyArrayList { private Object[] elementData = {}; private int size = 0; private void expand(){ if( size == 0 ){ elementData = new Object[10]; } if( size == elementData.length ){ //...
java中addrange_Java中ArrayList类的用法(转)
weixin_36297266的博客
02-13 402
1、什么是ArrayListArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小2、如何使用ArrayList最简单的例子：ArrayList List = new ArrayList();for( int i=0;i <10;i++ ) //给数组增加...
自己手动实现一个的ArrayList - Java
俩科的博客
01-24 516
ArrayList是什么常用方法首先声明一个Object类型的数组，一个数组内元素个数写一个size方法，主要是返回还有多少个数现在写构造方法ArrayListTest （就是仿写ArrayList）现在写一个add()方法写一个rangCheck()用来判断是不是越界了。写一个get()方法写remove（）方法，跟add差不多写一个isEmpty（）方法写一个main（）试一试总结完整的代码 链接: 浅析list链表基本使用. 常用方法 add，remove，size,get,isEmpty等等，嗯，下
手写一个handler源码
01-16
好的，下面是手写一个 HTTP 处理程序的示例代码： ``` from http.server import BaseHTTPRequestHandler, HTTPServer class MyHTTPRequestHandler(BaseHTTPRequestHandler): def do_GET(self): # 处理 GET 请求 self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write(b'<h1>Hello, world!</h1>') def run_server(server_class=HTTPServer, handler_class=MyHTTPRequestHandler): server_address = ('', 8000) httpd = server_class(server_address, handler_class) httpd.serve_forever() run_server() ``` 这段代码创建了一个基于 Python 的 HTTP 服务器，当客户端发起 GET 请求时，服务器会向客户端返回一个带有标题 "Hello, world!" 的 HTML 文档。 你可以在 `do_GET` 函数中添加更多的代码来扩展服务器的功能，例如解析请求中包含的数据、连接数据库等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值