ArrayList和LinkedList源码解读

最新推荐文章于 2023-04-11 21:55:19 发布
最新推荐文章于 2023-04-11 21:55:19 发布
阅读量111 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daibinbin_/article/details/115309652
版权

ArrayList & LinkedList & Vector源码分析

1. ArrayList源码分析

1.1ArrayList继承关系和层次结构

  • ArrayList:说明支持了泛型
  • entends AbstractList：继承了AbstractList
  • implements List, RandomAccess, Cloneable, java.io.Serializable
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    
{
    private static final long serialVersionUID = 8683452581122892189L;

    //默认的初始化容量
    private static final int DEFAULT_CAPACITY = 10;

    // 指定该ArrayList容量为0时，返回该空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //当调用无参构造方法，返回的是该数组。刚创建一个ArrayList时，其内数据为0
    //它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而EMPTY_ELEMENTDATA是在用户指定容量为0时返回。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //保存添加到ArrayList中的元素
 	//ArrayList的容量就是该数组的长度
    //该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY
    //被标记为transient
    transient Object[] elementData; // non-private to simplify nested class access

    //ArrayList的实际大小（数组包含的元素个数/实际数据的数量）默认为0；
    private int size;

1.2构造方法

  • ArrayList提供3中构造方法：
  • ArrayList(int initialCapacity):构造一个指定容量为capacity的空ArrayList，这是一个带初始容量大小的有参构造函数
    • 初始容量大于0，实例化数组，将自定义的容量大小当成初始化elementData的大小
    • 初始容量等于0，将空数组赋值给elementData
    • 初始容量小于0，将抛出异常
//构造具有指定初始容量的空list
public ArrayList(int initialCapacity) {//传入容量大小的参数
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];//如果比0大就创建传入参数大小的容量数组
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA; //如果相等赋值为空数组
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);//穿入负数抛出异常
        }
    }
  • ArrayList() :构造一个初始容量为10的空列表。如果创建ArrayList对象时不传入参数，则使用此无参构造方法创建ArrayList对象。从前面可以知道DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个空的Object[],将elementData初始化，elementData也是Object[]类型。空的Object[]会给默认的容量，但是这里我们并没有看到数组容量变成10，那么是什么时候回被初始化为10的数组呢？答案是有元素被加入时（使用add（））。当第一次使用add方法时候，elementData将会变成默认长度：10.
//构造一个初始容量为10的空列表
public ArrayList() {
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//
	}
  • ArrayList(Collection<? extends E> c) ：（暂时没有搞懂）
public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

1.3主要方法

  • add（e）:
//将指定的元素追加到此列表的末尾 
public boolean add(E e) {
    	//确定list容量，如果不够容量加1.注意：只加1，保证资源不被浪费
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    	//将元素e放到size的索引位置上，并size++
        elementData[size++] = e;
        return true;
    }
//数组容量检查，不够时则进行扩容，只供内部类使用
private void ensureCapacityInternal(int minCapacity) {  //传入的是size+1的值
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);//三维运算：true时取DEFAULT_CAPACITY；false取minCapacity
            //若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取minCapacity为DEFAULT_CAPACITY和参数minCapacity之间最大的值。
            //DEFAULT_CAPACITY在此之前初始化容量为10
        }
        return minCapacity;
    }
//数组容量检查，不够时则进行扩容，只供内部类使用
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
    	//最小容量>数组缓冲区当前长度
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//扩容
    }

  • add 方法是在list的末尾添加一个元素。size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下。calculateCapacity方法用来计算容量。判断初始化的elementData是不是空的数组，如果是空数组长度size就是0，否则数组长度就不是0。

    • 如果elementData元素是空的，就是第一次添加元素，minCapacity=size+1，其实就是等于1，空的数组没有长度就存放不了，所以就将minCapacity变成10，也就是默认容量的大小。也就是elementData数组的此时需要的最小容量为变10了，此时ensureExplicitCapacity()方法中的minCapacity就是10。到此只是说elementData数组需要的容量至少是10，还没有改变elementData的大小。
    • 如果elementData数组中的元素不是空的，那么它此时需要的最小容量就是原先的数组长度加1，minCapacity代表着elementData中元素增加之后的实际数据个数。
    • 要始终记住minCapacity = size+1,在ensureExplicitCapacity()方法中，首先操作数自增1，再把需要的最小空间容量与数组当前实际长度进行比较：
      • 如果elementData中的元素是空的，它现在需要的容量是10，但是elementData.length为0，所以要扩容。
      • 如果elementData数组中的元素不是空的，若它添加一个元素后需要的容量比原数组长度大，就需要扩容，否则就不需要扩容。

  • ArrayList能自动扩展大小的关键方法就在下面的grow（）方法里：

/**
*扩容，保证ArrayList至少能存储minCapacity个元素
*第一次扩容，逻辑为newCapacity=oldCapacity + (oldCapacity >> 1)；即在原有容量基础上增加一半。
*第一次扩容后，如果容量还小于minCapacity，就将容量扩充为minCapacity。
*
*/
private void grow(int minCapacity) {
        // overflow-conscious code
    	//获取当前数组的容量
        int oldCapacity = elementData.length;
    	//扩容：新的容量 = 当前容量+（当前容量/2）。即在原有容量基础上增加一半（当前容量的1.5倍）
        int newCapacity = oldCapacity + (oldCapacity >> 1);
    	//如果扩容后容量还是小于想要的最想容量
        if (newCapacity - minCapacity < 0)
            //将扩容后容量再次扩容为想要的最小容量
            newCapacity = minCapacity;
    	//elementData为空数组的时候，length=0，oldCapacity=0，newCapacity，在这里就是真正的初始化elementData的大小：10
    	//如果扩容后的容量大于临界点免责进行大容量分配
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
    	//新的容量确认好了，就copy数组，改变容量大小
    	//copyof（原数组，新的数组长度）
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
//进行容量分配
private static int hugeCapacity(int minCapacity) {
     //minCapacity < 0 抛出异常
     if (minCapacity < 0) // overflow
         throw new OutOfMemoryError();
    //如果想要的容量大于MAX_ARRAY_SIZE，则分配 Integer.MAX_VALUE，反则分配AX_ARRAY_SIZE
     return (minCapacity > MAX_ARRAY_SIZE) ?
         Integer.MAX_VALUE :
         AX_ARRAY_SIZE;
    }

2.LinkedList源码分析

2.1LinkedList继承关系

  • LinkedList(E:支持泛型):它继承了AbstractSequentialList类.
    • 实现接口:List、Deque、Cloneable、java.io.Serializable
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}

2.2数据结构：

//元素个数（节点个数）	
transient int size = 0;
//节点头
transient Node<E> first;
//节点尾
transient Node<E> last;

//私有静态内部类，表示双向链表节点
private static class Node<E> {
        E item;			//元素
        Node<E> next;	//指向后一个节点
        Node<E> prev;	//指向前一个节点

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

2.3 构造方法：

 	public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        //添加c到链表中
        addAll(c);
    }

2.4.1 add（）增加方法理解：

  • LinkedListCRUD:CRUD代表着的就是增删改查
public boolean add(E e) { //传入参数
        linkLast(e);
        return true;
    }

void linkLast(E e) { //传入的参数
        final Node<E> l = last; //记录尾结点
        final Node<E> newNode = new Node<>(l, e, null);//创建新节点（1.上个节点的地址、2.参数、3.null）
        last = newNode;  //更新尾部节点
        if (l == null)   //判断相等情况下，更新节点头
            first = newNode;
        else   			//否则将新节点的地址赋值给上个节点next位置
            l.next = newNode;
        size++;
        modCount++;
    }
  1. 使用add方法，传入参数。
  2. 记录尾节点。
  3. 创建新节点（节点参数：l：上个节点的地址、e：实参、null）
  4. 更新尾部节点。
  5. 判断列表为空时：更新头节点，first指向新的节点 / 判断列表不为空时：将新节点的地址赋值给上个节点next位置。
2.4.1.11图片分析：

LinkedList图片分析

2.4.2 remove()删除方法

//1.默认的删除方法，它删除的是第一个元素，调用removeFirst()方法
public E remove() {
        return removeFirst();
    }
//2.执行removeFirst()
public E removeFirst() {
        final Node<E> f = first;//f指向first（第一个元素）
        if (f == null)			//判断为空时，抛出异常	
            throw new NoSuchElementException();
        return unlinkFirst(f); //否则使用unlinkFirst方法
    }
private E unlinkFirst(Node<E> f) { 			//unlinkfirst()方法才是关键的地方
        // assert f == first && f != null;
        final E element = f.item;			//将第一个元素赋值给elment
        final Node<E> next = f.next;		//将第一个元素的next指向后面一个元素
        f.item = null;						//将第一个元素赋值为空
        f.next = null; // help GC			//将第一个元素next也赋值为空，让系统以为它是产生的垃圾
        first = next;                       //让first指向后面一位元素
        if (next == null)
            last = null;					//如果为空，last为null
        else
            next.prev = null;				//如果不为空，后一位元素前节点的地址为空，那新的第一位元素和被删除的第一位链表都断了（不指向）
        size--;								//size-1
        modCount++;
        return element;
    }
2.4.2.1图片分析

LinkedList删除元素

3.Vector源码分析

3.1继承关系

  • extends AbstractList：继承 AbstractLis类
  • implements List, RandomAccess, Cloneable, java.io.Serializable：实现接口
public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

3.2成员变量

protected Object[] elementData;//空的数组
protected int elementCount;   //记录数组中元素的个数
protected int capacityIncrement;//扩容大小

3.3构造方法

//有参构造
public Vector(int initialCapacity, int capacityIncrement) {//传入传数
        super();
        if (initialCapacity < 0) //判断传入元素小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];//创建为一个输入多少参数长度的数组
        this.capacityIncrement = capacityIncrement;//如果不去动，它会一直为0

//有参构造
public Vector(int initialCapacity) {//传入的参数
        this(initialCapacity, 0);//this方法：public Vector(int initialCapacity, int capacityIncrement) {就是上面的有参构造
    }

//无参构造
public Vector() {
        this(10);//这里的this调用的是Vector(int initialCapacity) 方法
    }

public Vector(Collection<? extends E> c) {
        Object[] a = c.toArray();
        elementCount = a.length;
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, elementCount, Object[].class);
        }
    }

3.4解读add方法源码

public synchronized boolean add(E e) {//传入的实参元素
        modCount++;					 //修改次数
        ensureCapacityHelper(elementCount + 1);//
        elementData[elementCount++] = e;
        return true;
    }
private void ensureCapacityHelper(int minCapacity) {//minCapacity：elementCount + 1,
        if (minCapacity - elementData.length > 0) //当判断为true时，使用grow方法（扩容），反则不扩容
            grow(minCapacity);
    }

  
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        
        int oldCapacity = elementData.length; //数组当前大小赋值给old
        //old+（这边是一个三元运算为true时，取capacityIncrement：0；false时取，oldCapacity）
        //当三元运算为false时，就是oldCapacity+oldCapacity，相当于2倍扩容
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?       
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)//当这边的判断成立时，将minCapacity的值赋值给newCapacity
            							//false时，直接执行Arrays.copyOf 按2倍扩容
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);//原数组，扩容的大小（按2倍扩容）
    }
Daibinbin_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中ArrayList和LinkedList区别
12-22
一般大家都知道ArrayList和LinkedList的大致区别： 　1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 　2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要...
ArrayList和LinkedList的初始化以及扩容机制的源码分析
qq_43854982的博客
10-26 1071
ArrayList源码分析 ArrayList的类图结构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OW1GESNm-1603707176501)(C:\Users\hp\AppData\Roaming\Typora\typora-user-images\image-20201026141056486.png)] 初始操作 /** Default initial capacity. 默认初始化容量 */ private st
JDK源码【集合框架】ArrayList和LinkedList
keeplearning
05-25 376
JDK源码【集合框架】HashMap
ArrayList,LinkedList源码分析
白天不懂夜的黑的博客
03-09 197
1.ArrayList底层原理: 原理:基于底数组实现的 2.ArrayList源码分析: 2.1 add方法(在尾部添加元素): public boolean add(E e) { //构造函数时候size已经初始化,size初始化=10,这里这个方法作用:确保elementData的容量可以放入新加的一个元素 ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] =
List接口的常用方法以及ArrayList/LinkedList源码分析
FunnyPrince_的博客
04-20 155
1.List接口的常用方法 ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Tom",12)); System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}] 增：add(int index, ob
一文掌握ArrayList和LinkedList源码解读
zly03的博客
04-11 187
今天我们来看一下ArrayList和LinkedList的源码，主要是看一下常用的方法，包括像add、get、remove方法，大部分都是从源码直接解读的，相信大家读完都会有一定收获。
java 集合之实现类ArrayList和LinkedList的方法
08-29
下面小编就为大家带来一篇java 集合之实现类ArrayList和LinkedList的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
ArrayList和Linkedlist1
08-08
1.List是接口类，ArrayList和LinkedList是List的实现类 2.ArrayList是动态数组（顺序表）的数据结构 3.LinkedList
对ArrayList和LinkedList底层实现原理详解
08-26
今天小编就为大家分享一篇对ArrayList和LinkedList底层实现原理详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
深入浅析ArrayList 和 LinkedList的执行效率比较
08-29
主要介绍了ArrayList 和 LinkedList的执行效率比较的相关资料,需要的朋友可以参考下
满意度调查行·知dr.pptx
04-25
满意度调查行·知dr.pptx
基于B2C的网上拍卖系统_秒杀与竞价.zip
04-25
基于B2C的网上拍卖系统主要用于帮助人们应用互联网方便快捷买到自己所中意的商品，并参与到秒杀与竞拍当中。 主要功能包括： 1.前台模块 （1）普通用户登录/注册。 （2）分类查看商品(普通商品与促销商品) （3）查看商品详细信息 （4）查看秒杀商品 （5）查看竞拍商品 （6）将商品加入购物车 （7)购买，结算功能 （8）留言 2.后台模块 （1）修改密码 (2)商品管理: -- 编辑/删除 -- 设置/取消促销 （3)秒杀商品：设置/取消秒杀 （4)竞拍商品：设置/取消竞拍 （5)订单管理：查看订单 （5)留言管理：查看/删除留言 项目访问路径: 前台：http://localhost:8080/sale 后台：http://localhost:8080/sale/user/adminlogin
分布式系统中Java后端开发技术及其应用实践.pdf
最新发布
04-25
分布式系统的核心思想是复杂计算任务的拆分与并行计算，可有效减少计算时间、节约算力成本。以分布式系统中Java后端开发技术的应用为主题，分析分布式系统开发的需求，探讨Java技术栈、分布式监控与日志管理、云服务模型在分布式系统Java后端开发中的应用路径，旨在为分布式系统的设计与实现提供全面的理论分析和实践指导，以支持构建高效、稳定、可扩展的企业级Java应用。 随着云计算、大数据和人工智能技术的飞速发展， 分布式系统已成为支撑现代企业信息系统的基础架构。 Java 后端开发技术在构建分布式系统中扮演着至关重要的 角色，其应用价值和研究重点主要集中在微服务架构、容 器化技术、自动化部署、服务网格、无服务器计算、应用 程序编程接口（Application Programming Interface， API）管理、数据一致性解决方案、分布式缓存、负载均衡、 复杂事件处理和分布式事务管理等方面[1]。Java平台以 其成熟的生态系统、跨平台的移植性、丰富的开源框架 和库以及稳定的性能，为分布式系统的开发提供了坚实 的基础[2]。深入探讨Java后端开发技术在分布式系统中 的应用实践，旨在为企
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar
04-25
【微信小程序毕业设计】书店系统开发项目(源码+演示视频+说明).rar 【项目技术】 微信小程序开发工具+java后端+mysql 【演示视频-编号：246】 https://pan.quark.cn/s/cb634e7c02b5 【实现功能】 用户信息管理，图书信息管理，图书类型管理，图书留言管理，论坛信息管理等
使用Spring in Guice和Guice in Spring的工具（高分项目）.zip
04-25
Java SSM项目是一种使用Java语言和SSM框架（Spring + Spring MVC + MyBatis）开发的Web应用程序。SSM是一种常用的Java开发框架组合，它结合了Spring框架、Spring MVC框架和MyBatis框架的优点，能够快速构建可靠、高效的企业级应用。 1. Spring框架：Spring是一个轻量级的Java开发框架，提供了丰富的功能和模块，用于开发企业级应用。它包括IoC（Inverse of Control，控制反转）容器、AOP（Aspect-Oriented Programming，面向切面编程）等特性，可以简化开发过程、提高代码的可维护性和可测试性。 2. Spring MVC框架：Spring MVC是基于Spring框架的Web框架，用于开发Web应用程序。它采用MVC（Model-View-Controller，模型-视图-控制器）的架构模式，将应用程序分为模型层、视图层和控制器层，提供了处理请求、渲染视图和管理流程的功能。 3. MyBatis框架：MyBatis是一个持久层框架，用于与数据库进行交互。它提供了一种将数据库操作与Java对象映射起来的方式，避免了手动编写繁琐的SQL语句，并提供了事务管理和缓存等功能，简化了数据库访问的过程
小程序-61-微信小程序的学生选课系统--LW-源码.zip
04-25
提供的源码资源涵盖了小程序应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 适合毕业设计、课程设计作业。这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。 所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！
【前端素材】大数据-010电商物流.zip
04-25
大数据技术指的是用于处理和分析大规模数据集的技术和工具。以下是一些常见的大数据技术和工具： Hadoop：Apache Hadoop是一个用于分布式存储和处理大规模数据的开源框架。它包括Hadoop Distributed File System（HDFS）用于数据存储和MapReduce用于数据处理。 Spark：Apache Spark是一个快速、通用的集群计算系统，提供了比MapReduce更快的数据处理能力。它支持内存计算和更多复杂的数据处理流程。 NoSQL数据库：NoSQL数据库（如MongoDB、Cassandra等）则更适用于处理这类数据。 数据仓库：数据仓库是一个用于集成和分析大规模数据的存储系统，一些知名的数据仓库包括Snowflake、Amazon Redshift等。 数据湖：数据湖是一个存储结构化和非结构化数据的存储池，用于支持数据分析和机器学习应用。 机器学习：大数据技术也广泛应用于机器学习领域，支持大规模数据的模型训练和预测分析。 流式处理：针对实时数据处理需求，流式处理技术（如Apache Kafka、Apache Flink）可以实时。
微信小程序源码 拼音查询小程序 （源码下载 +内附使用说明）
04-25
**微信小程序源码 —— 拼音查询小程序：轻松掌握汉字发音** 对于语言学习者和教育工作者来说，一个实用的拼音查询工具是不可或缺的。我们特别推出了一款微信小程序源码 —— 拼音查询小程序，它能够帮助用户快速查找汉字的拼音和声调，是学习和教学的好帮手。 **核心功能**： - **汉字转拼音**：输入汉字，即可获取准确的拼音和声调。 - **智能搜索**：支持模糊匹配，快速定位用户查询的汉字。 - **多音字识别**：为多音字提供所有正确的拼音选项，方便用户选择。 **源码特点**： - **易于集成**：源码下载后，可以轻松集成到您的微信小程序项目中。 - **高度可定制**：源码开放，允许开发者根据需求进行定制和功能扩展。 - **详细文档**：内附的使用说明文档，帮助您快速理解如何使用和修改源码。 **应用场景**： - **语言学习**：适合汉语学习者练习和纠正汉字发音。 - **教学辅助**：教师可以用于课堂教学，帮助学生掌握正确的拼音。 - **自主学习**：个人用户可以自主查找生僻字或多音字的准确拼音。
毕业设计-使用 Github Actions 跟踪 Github 趋势项目.zip
04-25
这里为你收集整理了关于毕业设计、课程设计可参考借鉴的资料一份，质量非常高，如果你投入时间去研究几天相信肯定对你有很大的帮助。到时候你会回来感谢我的。 本资源是经过本地编译测试、可打开、可运行的项目、文件或源码，可以用于毕业设计、课程设计的应用、参考和学习需求，请放心下载。 祝愿你在这个毕业设计项目中取得巨大进步，顺利毕业！ 但还需强调一下，这些项目源码仅供学习和研究之用。在使用这些资源时，请务必遵守学术诚信原则和相关法律法规，不得将其用于任何商业目的或侵犯他人权益的行为。对于任何因使用本资源而导致的问题，包括但不限于数据丢失、系统崩溃或安全漏洞，风险自担哦！
ArrayList和LinkedList
07-27
ArrayList和LinkedList是两种不同的数据结构实现。ArrayList是基于动态数组的数据结构，而LinkedList是基于双向链表的数据结构。它们在不同的操作上有不同的效率。 对于随机访问的get和set方法，ArrayList要优于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值