26_1集合实现类研究底层（部分）：手撕ArrayList底层源码、手撕LinkedList底层源码、手写单向链表和双向链表

已于 2024-07-11 11:08:03 修改
阅读量777 收藏 10
点赞数 17
分类专栏： JavaSE 文章标签： 链表 java-ee ArrayList底层 LinkedList底层 学习
于 2024-03-09 22:34:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gangain/article/details/136592290
版权
本文详细解析了ArrayList和LinkedList的底层源码，包括它们的数据结构、构造方法、添加和删除元素的过程以及扩容机制。同时，对比了两者在效率上的差异，如添加、查询、删除和修改数据的操作时间。
摘要由CSDN通过智能技术生成

day26上

集合框架图

标绿已经学习底层，深入底层主要是研究实现类底层
集合框架图上

继承关系图

继承关系图

手撕ArrayList底层源码

ps:研究添加元素的过程

思路：

1.研究继承关系

2.研究属性

3.理解创建集合的过程 – 构造方法的底层原理

4.研究添加元素的过程

提升：

1.研究删除集合的过程

2.研究遍历集合的过程

场景
	//ArrayList<String> list = new ArrayList<>();
	ArrayList<String> list = new ArrayList<>(10000);
	
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	list.add("ddd");

底层

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    //回顾：其中抽象类的构造方法由子类调用
    
    //外部操作数（记录添加和删除的次数）
    protected transient int modCount = 0;//最终4
}

额外补充：
    //空数据，没有对象，输出长度为空指针异常
    private static final Object[] EMPTY_ELEMENTDATA = null;    
    //空内容的数组，有对象，输出长度为0
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //默认容量的空内容的数组，有对象，（后面两个对象不同）
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    //默认初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    //空内容的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //默认容量的空内容的数组
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //数据容器最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //数据容器 - [“aaa”,"bbb","ccc","ddd",null,null,null,null,null,null]
    transient Object[] elementData;//new Object[10];
    //元素个数
    private int size;//最终4
    
    //无参构造，默认容量的空内容的数组
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //有参构造，初始化容量
    //initialCapacity - 10000
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }
    
    //e - 最终"ddd"
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;//添加一个元素size+1
        return true;
    }
    
    //minCapacity - 10--11（超）
    private void ensureCapacityInternal(int minCapacity) {
        //使用无参构造创建ArrayList，第一次添加元素时进入的判断
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //minCapacity =  Math.max(10, 1);
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    //minCapacity - 10--11（超）
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 有溢出意识的代码（准备扩容的长度必须大于数据容器的长度）
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //minCapacity - 10--11（超）
    private void grow(int minCapacity) {
        // oldCapacity - 10
        int oldCapacity = elementData.length;
        // newCapacity - 15，超过默认容量，开始扩容
        int newCapacity = oldCapacity + (oldCapacity >> 1);//ArrayList的扩容机制（1.5倍）
        if (newCapacity - minCapacity < 0)
            //newCapacity-10，没有超过默认容量
            newCapacity = minCapacity;
        //当超过最大容量Integer.MAX_VALUE-8
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //内存中一般不会存很多数据，一般几万都很多了，后面会讲解大量数据的处理情况
    //其他地方调用，minCapacity可能为负
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        //minCapacity > 0
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
    }
    
}

面试题

ArrayList的数据结构是什么？

Object类型的一维数组

ArrayList默认初始化容量是多少？

10

ArrayList最大容量是多少？

Integer.MAX_VALUE-8

ArrayList最大容量为什么是Integer.MAX_VALUE-8？

减8是为了腾出空间存放数组的头部信息

ArrayList扩容机制是什么？

扩容后的长度是原来长度的1.5倍

如何减少集合的伸缩性及其目的是什么？

根据需求判断元素大概的长度，在创建集合时指定长度，减少扩容次数，提高效率

手撕LinkedList底层源码

ps:研究添加元素的过程

思路：

1.研究继承关系

2.研究属性

3.理解创建集合的过程 – 构造方法的底层原理

4.研究添加元素的过程

提升：

1.研究删除集合的过程

2.研究遍历集合的过程

场景：
    LinkedList<String> list = new LinkedList<>();
		
	list.add("小小");
	list.add("奇男子");
	list.add("大大");

底层

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    //外部操作数（记录添加和删除的次数）
    protected transient int modCount = 0;//0
}

public abstract class AbstractSequentialList<E> extends AbstractList<E> {
}

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>{
    //元素个数
    transient int size = 0;//0
    //首节点
    transient Node<E> first;//null
	//尾节点
    transient Node<E> last;//null
    
    public LinkedList() {
    }//new对象，系统赋默认值
    
    //添加在inkLast()，所以研究linkLast()
    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);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    
    //回顾：静态内部类应用场景（此处不需要调用外部类的成员属性）
    //节点类
    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;
        }
    }
    
}

节点对象理解图

在这里插入图片描述

补充：双向链表【站在数据结构的角度：结点】【站在java底层的角度：节点】

LinkedList理解图

LinkedList理解图

添加过程解析

第一次添加：

LinkLast（）

1.首先e-小小，l = last为null

2.newNode对象（l，e，null）找到第一个节；所以第一个节点为【0x001】

3.然后last =newNode【0x001】

4.然后判断条件，first = newNode【0x001】

5.然后size++，变成1；modCount++变成1

第二次添加：

重新LinkLast（）

e；l；newNode重新赋值

1.首先e-奇男子，l = last为0x001（上一个节点地址即赋值给下一个首节点，第二个节点的首节点可以找到上一个节点）

2.newNode对象（l，e，null）找到第二个节；所以第二个节点为【0x002】；

3.然后last =newNode【0x002】

4.然后判断条件，l.next = newNode【0x002】（下一个节点地址即赋值给上一个尾节点，上一个节点可以找到下一个节点）

5.然后size++，变成2；modCount++变成2

第三次添加：

重新LinkLast（）

e；l；newNode重新赋值

1.首先e-奇男子，l = last为0x002（上一个节点地址即赋值给下一个首节点，第二个节点的首节点可以找到上一个节点）

2.newNode对象（l，e，null）找到第二个节；所以第二个节点为【0x003】；

3.然后last =newNode【0x003】

4.然后判断条件，l.next = newNode【0x003】（下一个节点地址即赋值给上一个尾节点，上一个节点可以找到下一个节点）

5.然后size++，变成3；modCount++变成3

面试题

LinkedList底层数据结构是什么？

双向链表

ArrayList 和 LinkedList的效率区别：

​ ArrayList底层：一维数组

​ LinkedList底层：双向链表

​ 添加数据 – ArrayList扩容的情况：LinkedList快

​ 添加数据 – ArrayList不扩容的情况：ArrayList快（size指针指哪里添加到哪里）

​ 查询数据：ArrayList快（ArrayList下标查找，LinkedList需要遍历数据 ）

​ 删除数据：LinkedList快（ArrayList删除要往前移动元素，LinkedList删除只要断链接添链接）

​ 修改数据：ArrayList快（修改需要先查询）

补充：平时我们一般使用ArrayList，是因为众多业务中查询功能使用最为频繁，而ArrayList查询功能比LinkedList更快，所以我们选择使用ArrayList会更多

LinkedList如何实现删除？

​ 1.通过下标找到要删除的节点

​ 2.把要删除的节点的下一个节点地址赋值给上一个节点的next

​ 3.把要删除的节点的上一个节点地址赋值给下一个节点的prev

手写单向链表和双向链表

手写单向链表

简单实现

粗略思路：

节点（元素，下一个节点，有参构造）

首节点，尾节点，size

添加（new节点，判断赋值给节点相应位置）

遍历 迭代器 方法实现（仿写底层）判断有没有元素，获取下一个元素

public class UnidirectionalLinkedList<E> {

	private Node<E> first;
	private Node<E> last;
	private int size;
	
	public void add(E e){
		
		Node<E> node = new Node<>(e, null);
		
		if(first == null){
			first = node;
		}else{
			last.next = node;
		}
		last = node;
		size++;
	}
	
	public Iterator<E> iterator(){
		return new Itr();
	}
	
	public class Itr implements Iterator<E>{

		private int cursor;
		private Node<E> node = first;
		
		@Override
		public boolean hasNext() {
			return cursor != size;
		}

		@Override
		public E next() {
			E item = node.item;
			node = node.next;
			cursor++;
			return item;
		}
		
	}
	
	public static class Node<E>{
		E item;
		Node<E> next;
		
		public Node(E item, Node<E> next) {
			this.item = item;
			this.next = next;
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		UnidirectionalLinkedList<String> list = new UnidirectionalLinkedList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String element = it.next();
			System.out.println(element);
		}
		
	}
}

手写双向链表

简单实现

粗略思路：

节点（上一个节点，元素，下一个节点，有参构造）

首节点，尾节点，size

添加（获取上一个节点，new节点，判断赋值给节点相应位置）

遍历 迭代器 方法实现（仿写底层）判断有没有元素，获取下一个元素

package com.qf.bidirectional_linked_list;

import java.util.Iterator;

public class BidirectionalLinkedList<E> {

	private Node<E> first;
	private Node<E> last;
	private int size;
	
	public void add(E e){
		
		Node<E> l = last;
		
		Node<E> node = new Node<>(l,e, null);
		
		if(first == null){
			first = node;
		}else{
			last.next = node;
			
		}
		last = node;
		size++;
	}
	
	
	public Node<E> getLast() {
		return last;
	}

	public Iterator<E> iterator(){
		return new Itr();
	}
	
	public class Itr implements Iterator<E>{

		private int cursor;
		private Node<E> node = first;
		
		@Override
		public boolean hasNext() {
			return cursor != size;
		}

		@Override
		public E next() {
			E item = node.item;
			node = node.next;
			cursor++;
			return item;
		}
	}
	
	public static class Node<E>{
		Node<E> prev;
		E item;
		Node<E> next;
		
		public Node(Node<E> prev,E item, Node<E> next) {
			this.prev = prev;
			this.item = item;
			this.next = next;
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		BidirectionalLinkedList<String> list = new BidirectionalLinkedList<>();
		
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		list.add("eee");
		
		//正序遍历
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
			String element = it.next();
			System.out.println(element);
		}
		
		System.out.println("-----------------------");

		//倒序遍历
		Node<String> node = list.getLast();
		while(node != null){
			System.out.println(node.item);
			node = node.prev;
		}
		
	}
}
程序奇男子
关注
  • 17
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华为OD最新面试手撕代码：实现双向链表
zf169_com的博客
06-28 304
在指定索引插入：遍历链表，找到指定索引位置的节点，将新节点插入到该位置。以上是实现双向链表的基本思路，通过合理的数据结构和算法实现，可以高效地对链表进行插入和删除操作。根据值删除：遍历链表，找到第一个值与给定值相等的节点，将该节点从链表中删除。显示操作：提供一个方法用于显示链表中的所有节点的数据，以便验证插入和删除操作是否正确。在头部插入：如果要在链表的头部插入节点，只需创建一个新节点，将其。类，表示链表中的节点。指向新节点，并将新节点设置为头节点即可。插入：指定索引插入，删除：根据值删除。
从零开始手撕一个数据结构（1）——双向链表
Yuc0114的博客
08-21 1228
前言 刚做完某厂的笔试，要求实现一个LRU算法，没有复习到LRU的我直接就凉了一半了 闲着没事把数据结构都过一遍吧，加深一下印象 作为《从零开始手撕一个数据结构》的第一篇，先从最简单的链表开始吧~ 文章目录前言一、要实现一个什么样的结构？二、实现步骤1. 核心定义1） 创建链表容器类LinkedList2）定义链表核心内部类ListNode2. 方法实现1）添加元素的add方法2）查询元素的get方法3）删除元素的remove方法4）修改元素的set方法5）返回当前链表长度的size方法总结 一、要实
手撕LinkedList
我与风来
01-04 270
LinkedList 底层数据结构是双向链表，可以存储任何元素（包括 null）。它也实现了 Deque 接口，可以将它当做双向队列使用。 初始化 它并没有任何初始化。双向链表依靠 first 和 last 两个节点维护： /** * Pointer to first node. * Invariant: (first == null && last =...
【java】手撕LinkedList
qq_57420582的博客
07-05 366
【java】手撕LinkedList
手撕源码（四）LinkedList（JDK8）
ACGkaka的博客
06-24 371
手撕源码（四）LinkedList（JDK8）
【数据结构】手撕双向链表
m0_68662723的博客
11-15 858
在上一期中我们介绍了单链表，也做了一些练习题，在一些题中使用单链表会十分繁琐。因为单链表只能正着走，不能倒着走，例如：回文、逆置。本期我们将学习带头双向循环链表。
对ArrayList和LinkedList底层实现原理详解
08-26
总结：ArrayList 和 LinkedList 是 Java 中两个常用的集合类，它们的底层实现方式不同，ArrayList 是基于数组实现的，而 LinkedList 是基于链表实现的。理解它们的底层实现方式可以帮助我们更好地使用它们。
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 728
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
Java进阶课程系列之ArrayList集合底层源码实战分析
06-16
ArrayList 允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。另外，由于 ArrayList 底层基于数组实现，所以其可以保证在?O(1)?复杂度下完成随机...
java 集合之实现类ArrayList和LinkedList的方法
08-29
"java 集合之实现类ArrayList和LinkedList的方法" Java 集合框架中，ArrayList 和 LinkedList 是两种常用的实现类，分别实现了 List 接口。下面我们将详细介绍这两种实现类的方法。 ArrayList ArrayList 是一个...
JAVA链表的介绍（包含单项链表、双向链表）、LinkedList 与 ArrayList 比较、链表的基本操作、基本方法等
04-01
在Java中，`LinkedList`和`ArrayList`都是常用的数据容器，它们分别实现了`List`接口，提供了对有序集合的支持。两者的主要区别在于内部实现机制及相应的性能特点： - **ArrayList**： - 内部使用数组实现。 - ...
手撕LinkedList源码
knight20160302的博客
08-20 156
LinkedList是一个实现了List接口和Deque接口的双端链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性; LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法： LinedList维护了...
【手撕算法】 双向链表
ZHAOJING1234567的博客
05-15 502
package test; import org.junit.Test; import java.util.Iterator; public class DoubleList<T> { int size; Node<T> head; Node<T> last; private static class Node<T...
手撕数据结构之双向链表
最新发布
liu3290607528的博客
05-17 482
本文章主要讲述了双向链表的实现以及容易出错的地方，有做的不够好的欢迎大佬们进行指正！！！
数据结构：手撕图解双向循环链表
海绵宝宝de派小星的博客
07-10 4415
双向循环链表的手撕实现和图解 分析对比其与单链表的差异
Java链表进阶=====手撕无头双向链表
qq_56146092的博客
01-28 894
双向链表的学习+手动分析
板鸭带你手撕C语言双向链表
sqm_C的博客
11-11 105
我们都知道双向链表有四种，分别是：双向带头循环链表，双向带头不循环链表，双向不带头循环链表，双向不带头不循环链表。这里我们就讲双向带头循环链表。为什么要讲这一种链表呢？因为双向带头循环链表在实际生活中的使用非常广泛，而且我们只需要了解这一种双向链表，其他三种双向链表我们也会很容易掌握。下图就是我们带头双向链表的逻辑结构。注意：这里的“带头”跟前面我们说的“头节点”是两个概念，实际前面的在单链表阶段称呼不严 谨，但是为了同学们更好的理解就直接称为单链表的头节点。
三分钟带你手撕带头双向循环链表
暴躁小吕的博客
10-26 1087
我们从进入数据结构模块开始，首先学习了顺序表，顺序表其实就是数组，它需要一组连续的物理空间来存储数据，所以它的缺点很明确，但是优点就是查找起来很方便，可以根据下标直接访问，然后我们学习了单链表，单链表就弥补了顺序表必须是连续物理空间的缺点，它的特点是不需要连续的空间，每个结点通过指针来连接，但是它的缺点也很明显就是查找起来很麻烦，如果想要在指定位置插入数据，或者头插等功能不容易找到对应的位置，往往需要设置一个或多个指针来达到目的，所以我们今天来讲一下双向链表。
od面试手撕代码：实现双向链表
互关，互粉，互学。
04-19 34
在指定索引插入：遍历链表，找到指定索引位置的节点，将新节点插入到该位置。以上是实现双向链表的基本思路，通过合理的数据结构和算法实现，可以高效地对链表进行插入和删除操作。根据值删除：遍历链表，找到第一个值与给定值相等的节点，将该节点从链表中删除。显示操作：提供一个方法用于显示链表中的所有节点的数据，以便验证插入和删除操作是否正确。在头部插入：如果要在链表的头部插入节点，只需创建一个新节点，将其。类，表示链表中的节点。指向新节点，并将新节点设置为头节点即可。根据值删除链表中的节点。在链表头部插入新节点。
深入解析JDK7 LinkedList：双向链表实现与源码分析
"该PDF文件主要讲解了JDK 7.0版本中LinkedList集合的底层实现原理，包括LinkedList的概述、存储结构以及内部实现机制，着重解析了源码中的关键部分，如Node节点结构、构造方法和添加元素的实现方式。" 在Java编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值