ArrayList和LinkedList的区别、优缺点以及应用场景详解（一）

最新推荐文章于 2023-06-11 16:24:19 发布
最新推荐文章于 2023-06-11 16:24:19 发布
阅读量237 收藏
点赞数
分类专栏： 集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huihuidage/article/details/105940531
版权

ArrayList和LinkedList都是实现了List接口的容器类，用于存储一系列的对象引用。下面我们通过源码（模拟）来分析下它们的底层实现。
首先，需要一个接口List（模拟）：

public interface List {
	
	//返回线性表的大小，及数据元素的个数
	int size();
	
	
	//返回线性表中序号为i的数据元素
	
	Object get(int i);
	
	//如果线性表为空返回true，否则返回false
	boolean isEmpty();
	
	
	//判断线性表是否包含元素e
	boolean contains();
	
	
	//返回元素e在线性表中的序号
	int indexOf(Object e);
	
    //将元素e插入到线性表中的i位置
	void add(int i,Object e);
	
	//将元素e插入到线性表中的末尾
	void add(Object e);
	
	//将元素e插入到元素obj之前
	boolean addBefore(Object obj,Object e);
	
	//将元素e插入到元素obj之后
	boolean addAfter(Object obj,Object e);
	
	
	//删除线性表中序号为i的元素，并返回值
	Object remove(int i);
	
	//删除线性表中第一个与e相同的元素
	Object remove(Object e);
	
	//替换线性表中序号为i的数据元素为e，返回元数据元素
	Object replace(int i,Object obj);
		
	
}

接下来，我们实现顺序表ArrayList（模拟）

import java.util.Arrays;

import com.cshg.exception.MyArrayIndexOutOfBoundsException;

public class ArrayList  implements List{
	private Object[] elementData; //底层就是一个数组
	
	private int size;  //元素个数
	
	
	
	public ArrayList() {
		//没有指定长度，默认为10
		this(10);
	}
	
	

	public ArrayList(int initialCapacity) {
		this.elementData = new Object[initialCapacity];
	}


	//集合大小
	@Override
	public int size() {
		return size;
	}
	
	//获取下标为i的元素
	@Override
	public Object get(int i) {
		if(i < 0 || i >= size){
			return new MyArrayIndexOutOfBoundsException("下标越界异常："+i); 
		}
		return elementData[i];
	}
	
	//是否为空
	@Override
	public boolean isEmpty() {
		
		return size == 0;
	}
	//包含
	@Override
	public boolean contains(Object o) {
		return indexOf(o) >= 0;
	}
	
	@Override
	public int indexOf(Object o) {
		if(o == null){
			for(int i = 0; i< size; i++)
				if(elementData[i] == null)
					return i;
		}else{
			for(int i = 0; i< size; i++)
				if(o.equals(elementData[i]))
					return i;
		}
		return -1;
	}
	public void rangeCheck(int i) throws MyArrayIndexOutOfBoundsException {
		if(i < 0 || i >= size){
			throw new MyArrayIndexOutOfBoundsException("下标越界异常："+i); 
		}
	}
    public void rangeCheckForAdd(int i) throws MyArrayIndexOutOfBoundsException {
    	if(i < 0 || i > size){
			throw new MyArrayIndexOutOfBoundsException("下标越界异常："+i); 
		}
	}
	@Override
	public void add(int i, Object e) throws MyArrayIndexOutOfBoundsException {
		rangeCheckForAdd(i);
		//元素后移
		for (int j = size; j > i; j--) {
			elementData[j] = elementData[j-1];
		}
		elementData[i] = e;
		size++;
		//扩容
		grow(size);
	}
	
	//扩容
	public void grow(int size){
		if(size > elementData.length){
			int number = (int)(size + size>>1);
			Object[] newArray = new Object[number];
			newArray = Arrays.copyOf(elementData,number);
			elementData = newArray;
		}
	}

	@Override
	public void add(Object o) {
		elementData[size] = o;
		size++;
		//扩容
		grow(size);
	}

	@Override
	public boolean addBefore(Object obj, Object e)  throws MyArrayIndexOutOfBoundsException {
		int i = indexOf(obj);
		if(i > -1){
			add(i,e);
			return true;
		}
		return false;
	}

	@Override
	public boolean addAfter(Object obj, Object e) throws MyArrayIndexOutOfBoundsException {
		int i = indexOf(obj);
		if(i > -1){
			add(i+1,e);
			return true;
		}
		return false;
	}

	@Override
	public Object remove(int i) throws MyArrayIndexOutOfBoundsException {
		rangeCheck(i);
		//前移
		for (int j = i; j <size-1; j++) {
			elementData[j] = elementData[j+1];			
		}
		elementData[size-1] = null;
		size--;
		return elementData;
	}

	@Override
	public Object remove(Object e) throws MyArrayIndexOutOfBoundsException {
		int i = indexOf(e);
		if(i > -1){
			remove(i);
		}
		return elementData;
	}

	@Override
	public Object replace(int i, Object obj) throws MyArrayIndexOutOfBoundsException{
		rangeCheck(i);
		elementData[i] = obj;
		return elementData;
	}

}

分析：
成员变量

    private Object[] elementData; //底层就是一个数组
	
	private int size;  //元素个数

size表示elementData数组的实际元素个数，elementData.length表示数组的最大集合容量。
构造函数

public ArrayList() {
		//没有指定长度，默认为10
		this(10);
}
public ArrayList(int initialCapacity) {
		this.elementData = new Object[initialCapacity];
}

无参构造函数，调用有参构造函数，并设置默认长度。
操作方法
add操作

	public void add(Object o) {
		elementData[size] = o;
		size++;
		//扩容
		dilatation(size);
	}

该函数插入数据时，会在后面插入，这就保证了数据的有序性。

	public void add(int i, Object e) throws MyArrayIndexOutOfBoundsException {
		rangeCheckForAdd(i);
		//元素后移
		for (int j = size; j > i; j--) {
			elementData[j] = elementData[j-1];
		}
		elementData[i] = e;
		size++;
		//扩容
		dilatation(size);
	}

该函数用于中间插入数据，但是插入该数据之前，还要做很多次的元素后移操作，即自i至最后的每个元素都必须向后挪一个位置，因此中间进行数据插入的性能很低。
扩容

    //扩容
	public void grow(int size){
		if(size > elementData.length){//如果实际元素个数大于数组的最大容量时，则进行扩容
			int number = (int)(size + size>>1);
			Object[] newArray = new Object[number];
			newArray = Arrays.copyOf(elementData,number);
			elementData = newArray;
		}
	}

进行add操作的时候，会调用扩容的方法，当size>elementData.length时，则进行扩容， 扩容后大小为原始容量的 1.5 倍。且看实现：新建一个长度为原来1.5倍的数组，将之前的数组的元素拷贝给新数组，最后将新数组赋值给elementData，即elementData的指针指向新数组。
remove操作

	@Override
	public Object remove(int i) throws MyArrayIndexOutOfBoundsException {
		rangeCheck(i);
		//前移
		for (int j = i; j <size-1; j++) {
			elementData[j] = elementData[j+1];			
		}
		elementData[size-1] = null;
		size--;
		return elementData;
	}

该函数会将第i个元素进行删除，在删除之前还要做很多次的元素前移操作，即自i至最后的每个元素都必须向前挪一个位置，因此中间进行数据删除的性能很低。
get操作

    //获取下标为i的元素
	@Override
	public Object get(int i) {
		if(i < 0 || i >= size){
			return new MyArrayIndexOutOfBoundsException("下标越界异常："+i); 
		}
		return elementData[i];
	}

直接调用数组随机访问，性能很好。
单链表
在这里插入图片描述
单链表代码模拟实现

public class MyLinkedList {
	
	private MyNode head;
	private int size;
	
	public int size(){
		return size;
	}
	public boolean isEmpty(){
		return size == 0;
	}
	
	public void addHead(Object data){
		MyNode newNode = new MyNode(data);
		newNode.next = head;
		head = newNode;
		size++;
	}
	
	public void add(Object data,int position) throws MyArrayIndexOutOfBoundsException{
		checkPosition(position);
		if(position == 0){
			addHead(data);
		}else{
			MyNode cur = getCur(position);
			MyNode newNode = new MyNode(data);
			newNode.next = cur.next;//当前节点的next赋给新节点的next
			cur.next = newNode;//当前节点next指向新节点
			size++;
		}
	}
	
	public void delHead(){
		head = head.next;
	}
	public void delete(int position) throws MyArrayIndexOutOfBoundsException{
		checkPosition(position);
	    if(position == 0){
			delHead();
		}else{
			MyNode cur = getCur(position);
			cur.next = cur.next.next;
			size--;
		}
	}
	public void checkPosition(int position) throws MyArrayIndexOutOfBoundsException{
		if(position<0 || position > size){
			throw new MyArrayIndexOutOfBoundsException("-1", "指针越界");
		}
	}
	
	public MyNode getCur(int position) throws MyArrayIndexOutOfBoundsException{
		checkPosition(position);
		MyNode cur = head;
		for (int i = 1; i < position; i++) {
			cur = cur.next;  //一直往后遍历，直到找到插入的位置的上个节点（在此称为当前节点）
		}
		return cur;
	}
	public Object get(int position) throws MyArrayIndexOutOfBoundsException{
		return getCur(position+1).getValue();
	}
	

	
	class MyNode{
		Object value;
		MyNode next; //下一个指针
		public MyNode(Object value){
			this.value = value;
		}
		public MyNode(Object value,MyNode next){
			this.value = value;
			this.next = next;
		}
		public Object getValue(){
			return value;
		}
		
		
	}
}

add操作
1.addHead

	public void addHead(Object data){
		MyNode newNode = new MyNode(data);
		newNode.next = head;
		head = newNode;
		size++;
	}

添加头节点：创建一个新节点，新节点的后继指向原先的头节点，引用变量head指向新节点。请看图解：
在这里插入图片描述

2.add

	public void add(Object data,int position) throws MyArrayIndexOutOfBoundsException{
		checkPosition(position);
		if(position == 0){
			addHead(data);
		}else{
			MyNode cur = getCur(position);
			MyNode newNode = new MyNode(data);
			newNode.next = cur.next;//当前节点的next赋给新节点的next
			cur.next = newNode;//当前节点next指向新节点
			size++;
		}
	}
	public MyNode getCur(int position) throws MyArrayIndexOutOfBoundsException{
		checkPosition(position);
		MyNode cur = head;
		for (int i = 1; i < position; i++) {
			cur = cur.next;  //一直往后遍历，直到找到插入的位置的上个节点（在此称为当前节点）
		}
		return cur;
	}

插入数据：找到插入的位置的上一个节点（我们就叫它为当前节点吧）,将当前节点的后继赋给新节点的后继，当前节点的后继指向新节点。图解：
在这里插入图片描述

remove操作
deleteHead

	public void delHead(){
		head = head.next;
	}

删除头结点:head = head.next，结合下图理解。
在这里插入图片描述
如上图所示，dataA所在的节点为头节点，删除头节点之后，那么头节点就变成了dataB所在的节点了，写成代码不就是head = head.next;

huihuidage
关注
专栏目录
List,Set和Map详解及其区别和他们分别适用的场景
Java知音
02-07 7018
Java中的集合包括三大类，它们是Set（集）、List（列表）和Map（映射），它们都处于java.util包中，Set、List和Map都是接口，它们有各自的实现类。Set的实现类主要有HashSet和TreeSet，List的实现类主要有ArrayList，Map的实现类主要有HashMap和TreeMap。 Collection是最基本的集合接口，声明了适用于JAVA集合的通用方法，li
浅谈java中集合的由来,以及集合和数组的区别详解
09-01
在Java编程语言中，集合和数组是两种不同的数据结构，它们各自有其特定的用途和优缺点。本文将深入探讨Java集合的起源及其与数组之间的关键差异。 首先，让我们了解集合的由来。在Java早期版本中，程序员主要依赖...
ArrayList和LinkedList区别及使用场景代码解析
08-28
主要介绍了ArrayList和LinkedList区别及使用场景代码解析，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
ArrayList和LinkedList的特点
班轻扬
03-16 832
ArrayList其实是包装了一个数组 Object[]，当实例化一个ArrayList时，一个数组也被实例化，当向ArrayList中添加对象是，数组的大小也相应的改变。这样就带来以下有缺点： 快速随即访问 你可以随即访问每个元素而不用考虑性能问题，通过调用get(i)方法来访问下标为i的数组元素。 向其中添加对象速度慢 当你创建数组是并不能确定其容量，所以当改变这个数组时就必须在内存中做很多事情。 操作其中对象的速度慢 当你要想数组中任意两个元素中间添加对象时，数组需要移动所有后面的对象。
ArrayList和LinkedList区别
鱼与飞鸟
04-07 8606
 ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么ArrayList和LinkedList在性能上有什么差别呢？什么时候应该用ArrayList什么时候又该用LinkedList呢？一．时间复杂度首先一点关键的是，ArrayList的内部实现是基于基
ArrayList和LinkedList区别及使用场景
minolk的博客
07-09 1888
区别ArrayList底层是用数组实现的，可以认为ArrayList是一个可改变大小的数组。随着越来越多的元素被添加到ArrayList中，其规模是动态增加的。LinkedList底层是通过双向链表实现的， LinkedList和ArrayList相比，增删的速度较快。但是查询和修改值的速度较慢。同时LinkedList还实现了Queue接口，所以他还提供了offer(),peek(), poll...
ArrayList和LinkedList的区别以及优缺点
热门推荐
qq_32679815的博客
12-26 5万+
*ArrayList和LinkedList都是实现了List接口的容器类，用于存储一系列的对象引用。他们都可以对元素的增删改查进行操作。 *对于ArrayList，它在集合的末尾删除或添加元素所用的时间是一致的，但是在列表中间的部分添加或删除时所用时间就会大大增加。但是它在根据索引查找元素的时候速度很快。对于LinkedList则相反，它在插入、删除集合中任何位置的元素所花费的时间都是一样的，但是
java基础--list（ArrayList、LinkedList、匿名类）.docx
08-07
ArrayList和LinkedList是List接口的两种主要实现，它们各有优缺点，适用于不同的场景。此外，匿名类的概念在Java中用于简化代码结构，尤其是在实现接口时。 1. **List接口** List接口继承自Set接口，它不仅提供了...
C# ArrayList、HashSet、HashTable、List、Dictionary的区别详解
08-25
本文将介绍 C# 中的 ArrayList、HashSet、HashTable、List、Dictionary 等集合类的区别和应用场景。 ArrayList 是一个可变长数组，可以将任意多的数据添加到 ArrayList 中。其内部维护的数组，当长度不足时，会自动...
java LinkedList源码详解及实例
08-31
LinkedList的每个元素都封装在一个`Node`类中，包含`item`字段存储元素，以及`next`和`prev`字段分别指向下一个和前一个节点，支持双向遍历。 3. **源码分析**： - `getFirst()`和`getLast()`通过直接访问`first`...
ArrayList 与 LinkedList 的区别和适用场景
tianSir的博客
12-26 993
1. Arraylist： 优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。 缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。 2. LinkedList： 优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和...
ArrayList 和 LinkedList的联系、区别及应用场景
最新发布
djf19991225的博客
06-11 502
本文主要总结了ArrayList和LinkedList的联系，区别以及应用场景，让我们更好去学习和理解。
ArrayList和LinkedList的区别、优缺点以及应用场景
DDDDeng_的博客
02-19 274
https://blog.csdn.net/TTTZZZTTTZZZ/article/details/84916281?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.cont
ArrayList和LinkedList的区别及使用场景
颜淡慕潇
03-18 5165
从图中可以看出： 1. List是一个接口，它继承与Collection接口，代表有序的队列。 2. AbstractList是一个抽象类，它继承与AbstractCollection。AbstractList实现了List接口中除了size()、get(int location)之外的方法。 3. AbstractSequentialList是一个抽象类，它继承与AbstrctList。AbstractSequentialList实现了“链......
ArrayList和LinkedList的区别？各自的使用场景？
Garry
09-12 1347
区别？ 1、List常用的ArrayList 和 LinkedList。 2、ArrayList底层使用是数组。LinkedList使用的是链表。 3、数组查询具有所有查询特定元素比较快。而插入和删除和修改比较慢（数组在内存中是一块连续的内存，如果插入或删除时需要移动内存） 4、链表不要求内存是连续的，在当前元素中存放下一个或上一个元素的地址，查询时需要从头部开始，一个一个的找，所以查询效率低。插入时不需要移动内存，只需要改变引用指向即可。所插入或者删除的效率高。 使用场景？ ArrayList使用在查询比
ArrayList 与 LinkedList
jiaomubai的博客
05-23 1937
ArrayList、LinkedList、ArrayList 与 LinkedList 的区别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值