LinkedList特点和底层实现

最新推荐文章于 2024-03-04 21:23:02 发布
最新推荐文章于 2024-03-04 21:23:02 发布
阅读量248 收藏
点赞数
分类专栏： Java 文章标签： java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JIFAQO/article/details/105116292
版权

title: JavaLinkedList特点和底层实现
date: 2020-03-25 22:25:50
author: JF
blog: https://www.huqifa.com/
tags:
- Java
- LinkedList
categories:
- Java

LinkedList特点和底层实现

LinkedList底层用双向链表实现的存储。

特点：查询效率低，增删效率高，线程不安全。

双向链表也叫双链表，是链表的一种，它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点。所以，从双向链表中的任意一个节点开始，都可以很方便地找到所有节点。

每个节点都应该有三部分内容：

class	Node{
		Node previous;	//前一个节点
		Object element;	//本节点保存的数据
		Node next;		//后一个节点
}

我们查看LinkedList的源码，可以看到里面包含了双向链表的相关代码：

package cn.LinkedList;
public class Node {
	Node previous;
	Node next;
	Object element;	
	public Node(Node previous,Node next,Object element) {
		super();
		this.previous = previous;
		this.next = next;
		this.element = element;
	}
	public Node(Object element) {
		super();
		this.element = element;
	}	
}

package cn.LinkedList;
/**
 * 自定义一个链表
 * @author HQF
 *
 */
public class LinkedList01 {
	private Node first;	//第一个节点
	private Node last;	//最后一个节点
	private int size;	//大小，有多少元素	
	//[]
	//['a','b','c']
	public void add(Object object) {
		Node node = new Node(object);	
		if (first==null) {
			first = node;
			last = node;
		}else {		
			node.previous = last;
			node.next = null;	
			last.next = node;
			last = node;
		}
	}
	@Override
	public String toString() {
		//[a,b,c]	first = a,	last = c;
		StringBuilder sBuilder = new StringBuilder("[");
		Node temp = first;
		while (temp!=null) {
			sBuilder.append(temp.element+",");
			temp = temp.next;
		}
		//setCharAt要使用单引号，否则会报错		sBuilder.setCharAt(sBuilder.length()-1, ']');
		return sBuilder.toString();
	}
	public static void main(String[] args) {
		LinkedList01 linkedList = new LinkedList01();
		linkedList.add("a");
		linkedList.add("b");
		linkedList.add("c");
	System.out.println(linkedList);
	}
}

['a','b','c']

LinkedList_get查询_节点遍历

package cn.LinkedList;
/**
 * 自定义一个链表
 * @author HQF
 *
 */
public class LinkedList01 {
	private Node first;
	private Node last;
	private int size;
	
	//取出C元素，索引数为2
	public Object get(int index) {
		System.out.println(size);
		//异常处理
		if ((index<0)||(index>size-1)) {
			throw new RuntimeException("索引数字不合法"+index);
		}
		
		Node temp = null;
		
		//如果index大于size一半则从后便利，否则从前面遍历
		if (index<=(size>>1)) {//size>>1相当于除以2
			temp = first;
			for (int i = 0; i < index; i++) {
				temp = temp.next;
			}		
		}else {
			temp = last;
			for (int i = size-1; i > index; i--) {
				temp = temp.previous;
			}
		}
		return temp.element;
	}
	
	//[]
	//['a','b','c']
	public void add(Object object) {
		Node node = new Node(object);
		
		if (first==null) {
			first = node;
			last = node;
		}else {
			
			node.previous = last;
			node.next = null;
			
			last.next = node;
			last = node;
		}
		size++;
	}
	@Override
	public String toString() {
		//[a,b,c]	first = a,	last = c;
		StringBuilder sBuilder = new StringBuilder("[");
		Node temp = first;
		while (temp!=null) {
			sBuilder.append(temp.element+",");
			temp = temp.next;
		}
		//setCharAt要使用单引号，否则会报错
		sBuilder.setCharAt(sBuilder.length()-1, ']');
		return sBuilder.toString();
	}
	
	public static void main(String[] args) {
		LinkedList01 linkedList = new LinkedList01();
		
		linkedList.add("a");
		linkedList.add("b");
		linkedList.add("c");
		linkedList.add("d");
		linkedList.add("e");
		linkedList.add("f");
		
		System.out.println(linkedList);
		System.out.println(linkedList.get(4));
	}
}

LinkedList_remove移除节点

package cn.LinkedList;

/**
 * 自定义一个链表
 * @author HQF
 *
 */
public class LinkedList01 {
	private Node first;
	private Node last;
	private int size;
	
	//移除指定的元素
	public void remove(int index) {
		Node temp = getNode(index);
		
		if (temp!=null) {
			Node up = temp.previous;
			Node down = temp.next;
			
			if (up!=null) {
				up.next = down;
			}
			
			if (down!=null) {
				down.previous = up;
			}
			
			if (index == 0) {
				first = down;
			}
			
			if (index == size-1) {
				last = up;
			}
			size--;
		}
	}
	
	//取出C元素，索引数为2
	public Object get(int index) {
		System.out.println(size);
		//异常处理
		if ((index<0)||(index>size-1)) {
			throw new RuntimeException("索引数字不合法"+index);
		}
		Node temp = getNode(index);
		
		return temp!=null?temp.element:null;
	}
	
	public Node getNode( int index) {
		Node temp = null;
		
		//如果index大于size一半则从后便利，否则从前面遍历
		if (index<=(size>>1)) {//size>>1相当于除以2
			temp = first;
			for (int i = 0; i < index; i++) {
				temp = temp.next;
			}		
		}else {
			temp = last;
			for (int i = size-1; i > index; i--) {
				temp = temp.previous;
			}
		}
		return temp;
	}
	
	//[]
	//['a','b','c']
	public void add(Object object) {
		Node node = new Node(object);
		
		if (first==null) {
			first = node;
			last = node;
		}else {
			
			node.previous = last;
			node.next = null;
			
			last.next = node;
			last = node;
		}
		size++;
	}
	@Override
	public String toString() {
		//[a,b,c]	first = a,	last = c;
		StringBuilder sBuilder = new StringBuilder("[");
		Node temp = first;
		while (temp!=null) {
			sBuilder.append(temp.element+",");
			temp = temp.next;
		}
		//setCharAt要使用单引号，否则会报错
		sBuilder.setCharAt(sBuilder.length()-1, ']');
		return sBuilder.toString();
	}
	
	public static void main(String[] args) {
		LinkedList01 linkedList = new LinkedList01();
		
		linkedList.add("a");
		linkedList.add("b");
		linkedList.add("c");
		linkedList.add("d");
		linkedList.add("e");
		linkedList.add("f");
		
		System.out.println(linkedList);
		System.out.println(linkedList.get(4));
		linkedList.remove(0);
		System.out.println(linkedList);
	}
}

代码实现

[a,b,c,d,e,f]
6
e
[b,c,d,e,f]

LinkedList_插入节点

//添加节点
	public void add(int index,Object obj) {
		Node newNode = new Node(obj);
		Node temp = getNode(index);
		
		
		if (temp!=null) {
			Node up = temp.previous;
			
			up.next = newNode;
			newNode.previous = up;
			
			newNode.next = temp;
			temp.previous = newNode;
		}
	}

linkedList.add(3,"JF");
		System.out.println(linkedList);

//输出
[a,b,c,JF,d,e,f]

LinkedList完善_增加泛型

package cn.LinkedList;

/**
 * 自定义一个链表
 * @author HQF
 *
 */
public class LinkedList01<E> {
	private Node first;
	private Node last;
	private int size;
	
	//添加节点
	public void add(int index,E element) {//alt+shirt +r 替换
		Node newNode = new Node(element);
		Node temp = getNode(index);
		
		if (temp!=null) {
			Node up = temp.previous;
			
			up.next = newNode;
			newNode.previous = up;
			
			newNode.next = temp;
			temp.previous = newNode;
		}
	}
	
	//移除指定的元素
	public void remove(int index) {
		
		checkRange(index);
		
		Node temp = getNode(index);
		
		if (temp!=null) {
			Node up = temp.previous;
			Node down = temp.next;
			
			if (up!=null) {
				up.next = down;
			}
			
			if (down!=null) {
				down.previous = up;
			}
			
			if (index == 0) {
				first = down;
			}
			
			if (index == size-1) {
				last = up;
			}
			size--;
		}
	}
	
	//取出C元素，索引数为2
	public E get(int index) {
		System.out.println(size);

		Node temp = getNode(index);
		
		return temp!=null?(E)temp.element:null;
	}
	
	//处理索引的index合不合法
	private void checkRange(int index) {
		//异常处理
		if ((index<0)||(index>size-1)) {
			throw new RuntimeException("索引数字不合法"+index);
		}
	}
	
	private Node getNode( int index) {
		checkRange(index);
		
		Node temp = null;
		
		//如果index大于size一半则从后便利，否则从前面遍历
		if (index<=(size>>1)) {//size>>1相当于除以2
			temp = first;
			for (int i = 0; i < index; i++) {
				temp = temp.next;
			}		
		}else {
			temp = last;
			for (int i = size-1; i > index; i--) {
				temp = temp.previous;
			}
		}
		return temp;
	}
	
	//[]
	//['a','b','c']
	public void add(E element) {
		Node node = new Node(element);
		
		if (first==null) {
			first = node;
			last = node;
		}else {
			
			node.previous = last;
			node.next = null;
			
			last.next = node;
			last = node;
		}
		size++;
	}
	@Override
	public String toString() {
		//[a,b,c]	first = a,	last = c;
		StringBuilder sBuilder = new StringBuilder("[");
		Node temp = first;
		while (temp!=null) {
			sBuilder.append(temp.element+",");
			temp = temp.next;
		}
		//setCharAt要使用单引号，否则会报错
		sBuilder.setCharAt(sBuilder.length()-1, ']');
		return sBuilder.toString();
	}
	
	public static void main(String[] args) {
		LinkedList01<String> linkedList = new LinkedList01<>();
		
		linkedList.add("a");
		linkedList.add("b");
		linkedList.add("c");
		linkedList.add("d");
		linkedList.add("e");
		linkedList.add("f");
		
		System.out.println(linkedList);
		System.out.println(linkedList.get(4));
		linkedList.add(3,"JF");
		System.out.println(linkedList);
		System.out.println(linkedList.get(1));
	}
}
Ashura78
关注
专栏目录
如何实现Java中一个简单的LinkedList
08-31
在Java编程中，LinkedList和ArrayList都是List接口的实现类，它们各自具有不同的特点和使用场景。LinkedList采用双向链表结构，而ArrayList则是基于数组实现。本文将详细介绍如何在Java中实现一个简单的LinkedList。...
【Java LinkedList详解】
Java程序员廖志伟
05-31 2689
Java中的LinkedList是一个重要的集合类，它是基于双向链表实现的，具有动态扩容能力、查询性能低、插入和删除性能高、访问和删除任意位置元素性能高以及线程安全等特点。本文将详细讲解LinkedList的实现原理、特性和使用场景。
LinkedList常见特性
zcc2018的博客
06-03 1033
1.LinkedList底层 LinkedList底层是通过链表实现的，链表中的一个节点是一个Node类型的数据结构，其保存了一个指向前驱节点的引用、真实数据和一个指向后继节点的引用； 特点是随机访问效率低，删除和插入快； 可以当作栈，队列和双端队列来使用； 非线程安全，如果要创建一个线程安全的LinkedList，则可以用 Collections.synchronizedList(new LinkedList(…)) 实现Serializable接口，因此它支持序列化，能够通过序列化传输，实现Clonea
LinkedList特点
weixin_45208757的博客
11-01 2093
LinkedList特点和底层实现 LinkedList的特点和存储结构 LinkedList底层用双向链表实现存储 特点：增删效率高，查询效率低，线程不安全 双向链表也叫双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向前一个节点和后一个节点。 LinkedList的存储结构图 节点类的内容 class Node{ Node previous;//指向前一个节点 Node next;//指向后一个节点 Object element;//本节点所存放数据 } ...
Java集合（2）：LinkedList概述与源码解析
qq_44437298的博客
02-07 282
一、LinkedList的概述与特点 LinkedList与ArrayList一样都实现了List接口，但是在底层上却截然不同。也许在平时中它的使用频率不及ArrayList，但是相较于ArrayList，LinkedList也具有独有的特点，因此知道它的实现方式以及在特定场合中使用它是很有必要的。 LinkedList的特点如下： （1）底层为一个双向链表，存储空间不连续，增删快，查找慢。 （2）属于List，有序存储，存储元素可重复，允许null元素存储。 （3）不支持同步，线程不安全。 二、继承体系
一.list集合的特点与linkedlist特性的论证
m0_74018330的博客
06-13 945
使用for循环和contains方法：通过for循环遍历List中的元素，并使用contains方法判断元素是否存在于新的List集合中，如果不存在则添加到新的List集合中。这是因为在不断进行添加元素的过程中，每一次扩容都需要更多的时间和内存空间，因此在集合需要扩容时，如果一次性扩容的空间过大，会浪费大量的内存资源。5.相比ArrayList消耗更多内存：LinkedList在存储元素时，需要额外的空间来存储前后元素的引用，因此占用的空间比ArrayList更多，但是之后的插入或删除等操作效率更高。
linkedlist:ADSB 链表实现
06-26
总结来说，"ADSB 链表实现"涉及到Java中的LinkedList数据结构，可能需要根据特定需求进行扩展和定制。理解链表的工作原理，以及何时使用链表，对于优化代码性能和提高软件质量至关重要。在实际项目中，应根据具体...
Java LinkedList集合功能实例解析
08-19
了解LinkedList集合的特点和使用场景，可以更好地选择合适的集合实现来解决实际问题。 参考文献 * Java SDK Documentation: LinkedList类 * Java集合框架官方文档 * 《Java精华卷》-集合框架篇
浅谈普通for循环遍历LinkedList弊端
08-31
总结来说，LinkedList在使用普通for循环遍历时存在效率问题，主要是由于其底层数据结构的特点。在处理LinkedList时，应优先考虑使用迭代器进行遍历，以获得更好的性能。在选择List实现时，应根据实际需求来权衡，...
linkedlist和arraylist的区别是什么
thunder-1
04-09 1765
主要区别：ArrayList是Array(动态数组)的数据结构，而LinkedList是Link(链表)的数据结构。随机访问（get和set）时，ArrayList优于LinkedList；新增和删除操作，LinedList比较占优势。 LinkedeList和ArrayList的区别 1、数据结构不同 ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的...
LinkedList底层实现
tyh1579152915的博客
07-05 567
一、什么是LinkedList public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable 根据源码我们可以看出： ①LinkedList继承了AbstractSequentialList，即按次序的List，也就是说不像ArrayList一样具有随机访问元
LinkedList集合
m0_55716146的博客
04-08 414
链表数据结构 1.对于链表数据结构来说：基本的单元是节点Node 2.对于单向链表来说，任何一个节点Node中都有两个属性： ​ 第一：储存的数据 ​ 第二：下一个节点的内存地址 3.LinkedList集合底层也是有下标的 4.注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因。是因为底层数组发挥的作用。 5.LinkedList集合照样有下标，但是检索/查找某个元素的时候效率比较低，因为只能从头节点开始一个一个遍历 6.链表的优点： ​ 由于链表上的元素在空间储存上内存地址
记录工作中遇到的k8s的坑
qq_39904356的博客
07-24 438
记录工作中遇到的k8s的坑和简单用法1、k8s指定node节点启动pod 1、k8s指定node节点启动pod 在工作中遇到集群节点通信问题，需要指定节点启动pod的情况，这个时候就要去修改yaml脚本。 首先我需要知道指定节点上的标签，k8s不能直接指定hostname进行节点指定，需要从节点的label中找到特征的key-value，用 nodeSelector 这个字段，放在containers的同级。不要用TAB键。 执行下面这条命令 kubectl get node --show-la
Java基础之LinkedList
qq_45344586的博客
04-09 1736
Java基础之LinkedList
数组面试题
m0_57084845的博客
06-17 87
面试-数据结构（数组，hashmap）
数据结构之LinkedList与链表
sniper_fandc的博客
03-22 1935
目录 1.LinkedList的特点和存在意义 2.LinkedList的简单使用 2.1.LinkedList的构造 2.2.常见方法 2.3.遍历 3.链表结构 4.简单实现 4.1单向无头不循环链表 4.2.双向无头不循环链表 5.ArrayList与LinkedList的不同 1.LinkedList的特点和存在意义 LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了...
LinkedList底层原理
最新发布
feng_ling_01的博客
03-04 473
LinkedList是一个双向列表实现的单列集合。有序，可重复、有索引。
JDK源码解析之LinkedList
孤独的根号三_
08-04 261
一、 LinkedList简介         LinkedList 跟 ArrayList一样实现了List接口，但跟ArrayList不同的是ArrayList采用的是数组作为存储元素的容器，所以ArrayList可以直接用角标获取元素，所以ArrayList查询效率较高， 但在添加和删除元素的速度比较慢，因为得移动元素。而LinkedList采用的是链表来存储元素, 因为它没有下标，所
ArrayList和LinkedList的底层实现和区别
06-11
ArrayList和LinkedList都是Java中常见的List集合类型，它们的底层实现方式不同，因此它们的性能特点也不同。 ArrayList底层使用数组来实现，因此它具有以下特点： 1. 随机访问效率高：由于ArrayList中的元素是按照顺序存储在数组中的，因此可以通过下标来快速访问任意一个元素，时间复杂度为O(1)。 2. 插入和删除效率低：由于ArrayList中的元素是存储在数组中的，因此在插入或删除元素时需要移动数组中的其他元素，时间复杂度为O(n)。 3. 空间浪费少：由于ArrayList中的元素是存储在数组中的，因此每个元素占用的空间是固定的，不会因为元素的增加而浪费空间。 LinkedList底层使用双向链表来实现，因此它具有以下特点： 1. 随机访问效率低：由于LinkedList中的元素是按照指针链接的方式存储在链表中的，因此不能通过下标来快速访问任意一个元素，需要遍历链表，时间复杂度为O(n)。 2. 插入和删除效率高：由于LinkedList中的元素是存储在链表中的，因此在插入或删除元素时只需要修改指针的指向，时间复杂度为O(1)。 3. 空间浪费多：由于LinkedList中的元素是存储在链表中的，每个元素需要额外的指针来链接前后元素，因此每个元素占用的空间比ArrayList大。 需要根据具体的场景来选择使用ArrayList还是LinkedList。如果需要快速访问元素，应该选择ArrayList；如果需要频繁插入或删除元素，应该选择LinkedList。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值