Java 手写Arraylist简易版（黑马笔记）

已于 2023-03-28 15:19:09 修改
阅读量264 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java数据结构与算法 文章标签： java 开发语言 算法
于 2023-03-26 19:19:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_53184944/article/details/129782684
本文介绍了一个简单的Java动态数组实现，包括添加元素、扩容机制（1.5倍增长）、以及三种遍历方式（函数式接口、迭代器和流）。动态数组使用了一个私有的int数组，跟踪已用容量（size）和总容量（capacity），在添加元素时会检查是否需要扩容。此外，还提供了插入、查询和删除元素的方法，以及不同方式的遍历实现。

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

ArrayList是个动态数组, 实际上我们就是实现一个简单的动态数组

占用空间

Java 中数组结构为（以int型数组为例）：

  • 8 字节markword（记录对象hashcode，垃圾回收时的分代年龄）
  • 4 字节 class 指针 （压缩 class 指针的情况 作用去找到对应的类型）
  • 4 字节 数组大小 （决定了数组最大容量式2^32）
  • 数组元素 + 对齐字节（java中所有对象大小都是8字节的整数倍，不足时要补足）

java数组本身是一个对象，所以主要是由对象头与数据组成

例如

int[] array = {1, 2, 3, 4, 5};

的大小为 40 个字节，组成如下

8 + 4 + 4 + 5*4 + 4(alignment)

代码如下：

package com.itheima.datastructure;

// 动态数组

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

public class DynamicArray implements Iterable<Integer> {

    private int size = 0; //逻辑大小
    private int capacity = 8; //容量
    private int[] array = {}; //用到再创建

    //添加一个值，在array逻辑大小的最后一位
    public void addLast(int element) {
        //添加逻辑之前 考虑扩容
        checkAndGrow();
//        array[size] =element;
//        size ++;
        add(size, element);
    }

    //扩容及检查越界逻辑
    private void checkAndGrow() {
        // 创建
        if (size == 0) {
            array = new int[capacity];
        }
        else if(size == capacity) {
            //进行扩容， Java中（1.5倍） 还有0.618倍 或者翻倍：2
            capacity  += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0, newArray, 0, size);
            // >> 比 + 优先级高
            //   capacity = capacity + capacity >> 1;
            array = newArray;
        }
    }

    //插入值（假设有效范围内）
    public void add(int index, int element) {
        //添加逻辑之前 考虑扩容
        checkAndGrow();
        if(index >= 0 && index< size) {
           System.arraycopy(array, index, array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

    //按索引查询
    public int get(int index) { //[0..size)
        return array[index];
    }

    //Consumer 是一个返回void 的函数式接口
    // 1.遍历方式一  函数式接口
    public void forEach1(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
//            System.out.println(array[i]);
            consumer.accept(array[i]);
            // 提供array[i]
            // 返回 void
        }
    }

    //2.遍历方式二 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() { //有没有下一个元素 有 返回真

                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    //3. 遍历方式三 流
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size)); //[0,size)
    }

    //删除 （假设有效范围内）
    public int remove(int index) { //[0,size)有效区间
        int removed = array[index];
        if(index < size - 1) {
            //        System.arraycopy(要copy的数组, 从哪个开始copy, copy到哪个数组,copy到这个数组的那个位置,   copy几个);
            System.arraycopy(array, index + 1, array,index, size - index - 1);
        }
        size--;
        return removed;
    }



}

解释：

这个是整体结构

在这里插入图片描述

三个属性：

  • private int size = 0; //逻辑大小
  • private int capacity = 8; //容量
  • private int[] array = {};

这里size表示的是已经用了的容量大小，capacity 带代表总共的容量大小（size + 没用的容量 =capacity）

checkAndGrow方法

这个代码做了两件事：

  • 判断数组是否存在(if (size == 0)）不存在则创建一个容量为capacity的类型为int的数组；
  • 判断是否越界（else if(size == capacity)）越界的话就将数组扩容。

解释一下arraycopy方法：

  • System.arraycopy(array, 0, newArray, 0, size)
    System.arraycopy(要copy的数组, 从哪个开始copy, copy到哪个数组,copy到这个数组的哪个位置, copy几个);

具体怎么扩容的根据代码分析:

 //扩容及检查越界逻辑
    private void checkAndGrow() {
        // 创建
        if (size == 0) {
            array = new int[capacity];
        }
        else if(size == capacity) {
            //进行扩容， Java中（1.5倍） 还有0.618倍 或者翻倍：2
            capacity  += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0, newArray, 0, size);
            // >> 比 + 优先级高
            //   capacity = capacity + capacity >> 1;
            array = newArray;
        }
    }

添加方法

这里有两个方法分代码中有解释作用：

//添加一个值，在array逻辑大小的最后一位
    public void addLast(int element) {
        //添加逻辑之前 考虑扩容
        checkAndGrow();
//        array[size] =element;
//        size ++;
        add(size, element);
    }

    //插入值（假设有效范围内）
    public void add(int index, int element) {
        //添加逻辑之前 考虑扩容
        checkAndGrow();
        if(index >= 0 && index< size) {
           System.arraycopy(array, index, array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

遍历方法（三种）

  • 方式一：利用了函数式接口来实现，目的可以让用户重写accept方法，然后把逻辑传回该方法
  • 方式二：利用迭代器遍历，用了一个Iterator<Integer>Iterator<Integer>Iterator<Integer> 接口（点进去可以发现是个接口所以return了两个方法，这个应用看不懂的可以先去看一下匿名内部类）；
  • 方式三：流实现，IntStream.of方法创建有限元流，流又可以通过其中的forEach方法来实现遍历；
 //Consumer 是一个返回void 的函数式接口
    // 1.遍历方式一  函数式接口
    public void forEach1(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
//            System.out.println(array[i]);
            consumer.accept(array[i]);
            // 提供array[i]
            // 返回 void
        }
    }

    //2.遍历方式二 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() { //有没有下一个元素 有 返回真

                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    //3. 遍历方式三 流
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size)); //[0,size)
    }

测试遍历代码：

	 //遍历方式一
		 dynamicArray.forEach1(System.out::println);
        
        System.out.println("================ ");
	 //遍历方式二
        for (Integer element : dynamicArray) {
            System.out.println(element);
        }
	 //遍历方式三
        System.out.println("================ ");

        dynamicArray.stream().forEach(System.out::println);

方式一测试的三种写法：

	// 1
dynamicArray.forEach1(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
       // 2 
        dynamicArray.forEach1(e ->System.out.println(e));
        
		// 3
        dynamicArray.forEach1(System.out::println);

三种方法都效果都一样；

删除

//删除 （假设有效范围内）
    public int remove(int index) { //[0,size)有效区间
        int removed = array[index];
        if(index < size - 1) {

            System.arraycopy(array, index + 1, array,index, size - index - 1);
        }
        size--;
        return removed;
    }

注意：这里的插入与删除都式假设有效范围内（意思就是在[0,size)范围内，如果超出的话插入与删除都为一种异常情况，需要自己完善判断处理）。

Java朴实无华按天计划从入门到实战（强化速战版-66天）
博客主要分享技术教程、工具教程、bug解决、前沿技术动态、编程经验、心得感悟等。 内容同步、干货获取、推广宣发请看侧栏推广信息
05-01 200
Java朴实无华按天计划从入门到实战（强化速战版-66天）
Java朴实无华按天计划从入门到实战（94天直达Java高阶）
最新发布
博客主要分享技术教程、工具教程、bug解决、前沿技术动态、编程经验、心得感悟等。 内容同步、干货获取、推广宣发请看侧栏推广信息
05-01 329
Java朴实无华按天计划从入门到实战（94天直达Java高阶）
手写精简版List和ArrayList，适合新手入门学习jdk源码demo
06-04
手写精简版List和ArrayList，适合新手入门学习jdk源码demo，初学易懂
【Java】手写ArrayList
点子渣手的博客
01-23 528
ArrayList作为java中常用的数据结构，很有自己重现一遍的必要，这里只是针对于ArrayList的源码进行了分析，提取了其中动态分配，添加，删除等核心功能，并加入了合并及去重合并的功能。希望在以后能够搭建动态数组模型对于具体问题具体解决。 接口部分：定义通用方法 public interface MyList<E> { public void add(E element); public void add(int index,E element); public E
Java手写ArrayList
weixin_43442127的博客
12-30 214
手写ArrayList主要部分，了解ArrayList扩容原理
利用Java来手写ArrayList
weixin_45747080的博客
08-19 396
利用Java来手写ArrayList 几乎所有的语言都会有数组，Java也不例外。数组有个特点就是在初始化的时候必须确定长度，即使容量到达了也无法自动扩容，无法满足需求，所以我们可以利用动态数组（ArrayList）来实现可以自动扩容的数组。参考Java官方的ArrayList实现：java.util.ArrayList。ArrayList的底层还是数组，相当于数组的强化版，能够进行自动扩容并且进行数据的增删改查。 注意： 以下利用动态数组来表示ArrayList，利用数组来表示Object[] 私有属
Java手写简易版ArrayList
乾坤未定，你我皆是黑马
11-14 225
代码 public class MyArrayList { private static final int DEFAULT_CAPACITY=10; private int capacity; private int size; private int[] elements; public MyArrayList(int capacity){ this.size=0; this.capacity=capacity; e
Java学习计划与资源推荐（入门到进阶、高阶、实战）
博客主要分享技术教程、工具教程、bug解决、前沿技术动态、编程经验、心得感悟等。 内容同步、干货获取、推广宣发请看侧栏推广信息
04-30 231
Java学习计划与资源推荐（入门到进阶、高阶、实战）
【最新版】Java学习路线（含B站口碑推荐视频链接）
Redemption___的博客
08-14 6956
文章目录一、计算机网络二、数据结构与算法三、操作系统四、计算机组成原理五、编译原理六、设计模式七、MySQL八、实操工具九、JAVA并发与JVM十、Redis十一、Linux十二、Java路线学习尚硅谷黑马程序员动力节点狂神说十三、Java基础十四、JavaWeb十五、框架十六、微服务/分布式十七、中间件十八、面试技巧、简历优化
神秘的java
stay hungry,stay foolish!
11-02 2053
1.单元测试不再怕！一文学会SpringBoot单元测试2.一文搞懂🔥SpringBoot自动配置原理3.封装属于自己的Spring-Boot-Starter4.爽!🔥自定义SpringBoot的@EnableXXX注解1.灰度发布是什么？
JAVA----集合----手写ArrayList
m0_68092999的博客
04-28 779
1.首先我们写一个MyArrayList这个类，让它实现List这个接口，再然后 去实现它里面的方法。如下： public class MyArrayList implements List { @Override public int size() { return 0; } @Override public boolean isEmpty() { return false; } @Override
java手写ArrayList实现
GYJ_HL的博客
05-31 603
使用java实现ArrayList集合。 实现了简单的增删改查功能。 package list; import java.util.Arrays; /** * * @author Grant * * @param <E> 泛型 */ public class ArrayList<E> { // 数组容量； private int capacit...
JAVA（手写）简单实现ArrayList和LinkedList
Simlier的博客
11-08 915
JAVA（手写）简单实现ArrayList和LinkedList 大家都知道在java学习中list类的实现类中有ArrayList 和LinkedList，其中ArrayList是使用数组实现，而LinkedList则是用链表实现的。今天就自己去用java去简单实现一下它们。 1.ArrayList的实现 1.类必须的属性 一个object的数组 list的长度 2.基本代码 `public c...
Java学习笔记：ArrayList手写实现
菜到不敢run
07-20 832
  本文是对高淇版Java三百集，容器部分ArrayList内容学习的记录。java中ArrayList本质是一个数组，该类中包含两个属性Object[] elementData,int size,恰如字面意思，前一个数组用于存储数据，后者的size记录有多少个数据。 一、ArrayList源码 1.1 add()方法 1.2 remove()方法 1.3 二、自定义实现ArrayList功能 2.1 定义MyArrayList类，简单实现add方法 package cn.edu.ucas.gqlearn;
手写ArrayList
JavaAlliance
10-17 640
1.首先编写ExtList接口（） package com.itmayiedu.list; public interface ExtList&amp;lt;E&amp;gt; { public void add(E object); public void add(int index, E object); public Object remove(int index); ...
手写一个ArrayList
苏法迪的专栏
03-11 3499
1. 手写一个MyArrayList ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是支持动态扩容，即没有固定大小的限制，我们可以添加或删除元素。 ArrayList 本质是数组，故具有查询快，增删慢的特点 add()：新增时需要考虑扩容的因素。这个是区别数组的核心方法 get(): 非常好地体现出下标查找的优势，故查询快 remove()：体现出数组的缺点,删除一个元素，后面的元素需整体前移，故删除慢 优点： 1、根据下标遍历元素效率较高。 2、根据下标访问元素效率较高。 3
java中 ArrayList类实现方法的简易实现（手写版，附详细注释说明）
浅时光|初如梦
05-24 386
import java.util.Arrays; public class ListTest { public static void main(String[] args) { //创建列表对象 ListArray listArray = new ListArray(); listArray.add("a"); listArray.add("b"); //没有重写toString()方法，只能调用原始的Obje.
手写简易ArrayList
weixin_44795847的博客
06-03 230
一、功能接口： package com.ckw.test.arraylist; /** * @author ckw * @version 1.0 * @date 2020/6/3 15:01 * @description: TestArrayList功能封装 */ public interface TestArrayListInterface { //添加元素 void add(Object object); //添加指定索引位置 void add(int
基于ArrayList的简易Java库存管理开发教程
初学Java编程时，利用ArrayList集合构建一个简易的库存管理系统是一个非常好的练习项目。这个系统能够帮助初学者理解如何使用数组列表来存储和管理数据，以及如何实现基本的增删改查功能。通过实践这样的项目，学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Aholic 冲冲冲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值