LinkedList特点和底层实现

最新推荐文章于 2021-07-05 17:46:09 发布
最新推荐文章于 2021-07-05 17:46:09 发布
阅读量251 收藏
点赞数
分类专栏： 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
关注
专栏目录
linkedlist类的特点是_最详细集合源码解析之LinkedList集合源码解析
weixin_42515364的博客
11-28 646
LinkedList集合特点就是增删快，查询慢，这种特性的主要原因就是其内部是通过链表来做为存储数据的数据结构，先看下内部整体结构。LinkedList整体结构这里主可以看到，和ArrayList的继承结构大致差不多，这里LinkedList实现了Queue,可以实现一些队列的操作，先带大家看下LinkedList的内部的Node内部类的结构，这个是完成数据存储的核心部分，所有的操作都是围绕No...
LinkedList相关知识及底层链表实现原理
czh91589的博客
08-13 1358
LikedList集合 一、LinkedList集合存储元素特点 1）LinkedList集合实现了List接口，存储元素特点是：有序且可重复，并且集合元素都有下标，从0开始以1递增。 2）LinkedList底层是以链表为这种数据结构来存储数据 3）LinkedList集合存储元素优缺点： 优点：由于底层是以链表为数据结构，所以在增删方面速度很快，也很方便 缺点：查询数据速度较慢。 所以在选择ArrayList集合和LinkedList集合时，需要频繁对数据进行增删的话，适合使用LinkedList集合；
LinkedList特点
weixin_45208757的博客
11-01 2095
LinkedList特点和底层实现 LinkedList的特点和存储结构 LinkedList底层用双向链表实现存储 特点：增删效率高，查询效率低，线程不安全 双向链表也叫双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向前一个节点和后一个节点。 LinkedList的存储结构图 节点类的内容 class Node{ Node previous;//指向前一个节点 Node next;//指向后一个节点 Object element;//本节点所存放数据 } ...
LinkedList的特性
qq_34409900的博客
02-24 4098
LinkedList分析：    1）. LinkedList是通过双向链表去实现的。     2）. 从LinkedList的实现方式中可以看出，它不存在容量不足的问题，因为是链表。     3）. LinkedList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写出“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。    ...
记录工作中遇到的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
ArrayList和LinkedList的底层实现和区别
最新发布
06-11
ArrayList和LinkedList都是Java中常见的List集合类型，它们的底层实现方式不同，因此它们的性能特点也不同。 ArrayList底层使用数组来实现，因此它具有以下特点： 1. 随机访问效率高：由于ArrayList中的元素是按照...
ArrayList与LinkedList底层实现与增删查效率比较
Stan的专栏
03-23 1万+
我们知道ArrayList是List接口的一个实现类，它的特点是查询效率高，增删效率低，线程不安全 原因是因为ArrayList底层是封装了一个数组，它是用数组实现的。 看下图，数组在内存中的存储方式：现在定义一个int[] a数组，假设它的首地址是2000，int类型占4个字节，所以a[0]的首地址是2000，a[1]的首地址就是2004，以此类推….到a[n] 所以上面的这张图，就很形象的
linkedlist:ADSB 链表实现
06-26
总结来说，"ADSB 链表实现"涉及到Java中的LinkedList数据结构，可能需要根据特定需求进行扩展和定制。理解链表的工作原理，以及何时使用链表，对于优化代码性能和提高软件质量至关重要。在实际项目中，应根据具体...
如何实现Java中一个简单的LinkedList
08-31
在Java编程中，LinkedList和ArrayList都是List接口的实现类，它们各自具有不同的特点和使用场景。LinkedList采用双向链表结构，而ArrayList则是基于数组实现。本文将详细介绍如何在Java中实现一个简单的LinkedList。...
ArrayList 和LinkedList各自的特点是什么
01-24
ArrayList 和LinkedList各自的特点是什么，自己实用中的总结
对ArrayList和LinkedList底层实现原理详解
08-26
今天小编就为大家分享一篇对ArrayList和LinkedList底层实现原理详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
LinkedList常见特性
zcc2018的博客
06-03 1033
1.LinkedList底层 LinkedList底层是通过链表实现的，链表中的一个节点是一个Node类型的数据结构，其保存了一个指向前驱节点的引用、真实数据和一个指向后继节点的引用； 特点是随机访问效率低，删除和插入快； 可以当作栈，队列和双端队列来使用； 非线程安全，如果要创建一个线程安全的LinkedList，则可以用 Collections.synchronizedList(new LinkedList(…)) 实现Serializable接口，因此它支持序列化，能够通过序列化传输，实现Clonea
Collection接口、List接口与Set接口
再来一块红烧肉
03-24 958
我们为什么需要Collection接口、List接口与Set接口？ Collection接口 List接口 Set接口 ...
java集合之LinkedList详解
热门推荐
zhao_xinhu的博客
09-15 2万+
我们上一次说到List的ArrayList，我们这次去看下LinkedList---顾名思义是链表，链表的优点就不用说了吧，增删效率比较高（具体的朋友们上网看吧），先来看下LinkedList的整体构架：  首先我们看到了LinkedList间接的实现了List接口（说明LinkedList是有list的特性的，add，remove等）、实现了Cloneable（可复制）、Serializa...
LinkedList的底层实现
无
03-04 369
 public class LinkedList&lt;E&gt;    extends AbstractSequentialList&lt;E&gt;    implements List&lt;E&gt;, Deque&lt;E&gt;, Cloneable, java.io.Serializablepublic interface Deque&lt;E&gt; extends Queue&l...
LinkedList底层实现
tyh1579152915的博客
07-05 569
一、什么是LinkedList public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable 根据源码我们可以看出： ①LinkedList继承了AbstractSequentialList，即按次序的List，也就是说不像ArrayList一样具有随机访问元
java【LinkedList底层实现】
极客蓝天
10-28 586
双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 下面代码中，不是双向循环链表，而是双向链表，但是头节点和尾节点没有连接起来。 package com.bjsxt.collection; import java...
Java中LinkedList的底层实现
zxjzxj1234的专栏
06-21 289
LinkedList底层是链表实现，首先要理解链表的基本概念和基本操作。 以双向链表为例： 链表中，链表是由节点组成的，每个节点由3部分构成，前置节点，节点的内容，后置节点。 Java底层的LinkedList是实现List接口的。 下面我们自己实现LinkedList的底层实现，主要是要理解双向链表的原理。 package cn.zhouxj.collection; public...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值