【java集合系列】--- LinkedList

开篇前言--LinkedList中的基本用法

在前面的博文中，小编介绍List接口中的ArrayList集合，List这个接口，有两个实现类，一个就是ArrayList另一个是LinkedList（链表），这两个类都实现了List接口，so。她们有很多相似的地方。LinkedList和ArrayList一样实现了List接口，但是她执行插入和删除操作时比ArrayList更加高效，因为她是基于链表的，但同时也决定了她在随机访问方面要比ArrayList弱一点。我们通过一系列的小demo来加深对LinkedList的了解。新建一个Class，取名为LinkedListTest1，编写code，addLast和addFirst方法，如下所示：

package j2se.demo;
 
import java.util.LinkedList;
 
public class LinkedListTest1 {
	public static void main(String[] args) {
 
		LinkedList list = new LinkedList();
		list.add("F");
		list.add("B");
		list.add("D");
		list.add("E");
		list.add("C");
 
		list.addLast("Z");
		list.addFirst("A");
 
		list.add(1,"A2");
 
		System.out.println("最初的集合:"+list);
 
	}
 
}

运行效果，如下图所示：

接着，我们来看一下remove的方法，编写相关代码，如下所示：

package j2se.demo;
 
import java.util.LinkedList;
 
public class LinkedListTest1 {
	public static void main(String[] args) {
 
		LinkedList list = new LinkedList();
		list.add("F");
		list.add("B");
		list.add("D");
		list.add("E");
		list.add("C");
 
		list.addLast("Z");
		list.addFirst("A");
 
		list.add(1,"A2");
 
		System.out.println("最初的集合:"+list);
 
		list.remove("F");
		list.remove(2);
 
		System.out.println("变化后的集合:"+list);
 
	}
 
}

运行效果如下所示：

接着，我们来看set方法，编写相关代码，如下所示：

package j2se.demo;
 
import java.util.LinkedList;
 
public class LinkedListTest1 {
	public static void main(String[] args) {
 
		LinkedList list = new LinkedList();
		list.add("F");
		list.add("B");
		list.add("D");
		list.add("E");
		list.add("C");
 
		list.addLast("Z");
		list.addFirst("A");
 
		list.add(1,"A2");
 
		System.out.println("最初的集合:"+list);
 
		list.remove("F");
		list.remove(2);
 
		System.out.println("变化后的集合:"+list);
 
		Object value = list.get(2);
		list.set(2, (String)value+"change");
		System.out.println("最后的集合:"+list);
 
	}
 
}

运行效果，如下所示：

LinkedList底层实现--双向链表

我们知道LinkedList底层实现是一个链表，我们来看看什么是链表，首先我们来看线性结构，在数据结构中，一般将数据结构分为两大类，线性数据结构和非线性数据结构，其中线性数据结构有线性表、栈、队列、串、数组和文件；非线性数据结构有树和图。我们重点来看一下线性表的特征：

a、线性表的逻辑结构是n个数据元素的有限序列，如a1，a2，a3，...an，其中n为线性表的长度（n>=0），n=0的表称为空表；

b、在线性表中，数据元素呈线性关系，必存在唯一的称为“第一个”的数据元素；必存在唯一的称为“最后一个”的数据元素；除第一个元素外，每个元素都有且只有一个前驱元素；除最后一个元素外，每个元素都有且只有一个后继元素；

c、所有数据元素都在同一个线性表中必须是相同的数据类型；

d、线性表按其存储结构可以分为顺序表和链表，用顺序存储结构存储的线性表称为顺序表；用链式存储结构存储的线性表称为链表；

e、将线性表中的数据元素依次存放在某个存储区域中，所形成的表称为顺序表，一堆数组就是用顺序方式存储的线性表。

我们来看链表，对于一个顺序表来说，她存放这个元素本身就可以了，比如说3，我们存放这个3就可以了，因为她的地址是连续存放的，通过首地址就能一个一个找到后续元素的地址，但是对于链表来说，就不行，链表不是连续存放的。so，对于链表来说，光有数据还不够，必须还要有一个指向后继元素的引用才行。设计一个类，实现链表这个结构，该如何设计，应该包括哪些方法和属性呢？首先，我们需要设计一个node类，编写代码如下所示：

package j2se.demo;
 
public class Node {
 
	String data;//存放节点数据本身
	Node next;//存放指向下一个节点的引用
 
	public Node(String data){
		this.data=data;
	}
 
}

这样，我们就定义好了Node这个类本身，接着，新建一个Class，取名为NodeTest，实现使得node1的后继是node2，node2的后继是node3；该怎么写呢？代码如下所示：

package j2se.demo;
 
public class NodeTest {
 
	public static void main(String[] args) {
 
		Node node1 = new Node("node1");
		Node node2 = new Node("node2");
		Node node3 = new Node("node3");
 
		node1.next=node2;
		node2.next=node3;
 
		System.out.println(node1.next.next.data);
 
	}
 
}

运行，如下所示：

接着，这个时候有一个node4，需要插入在node1和node2之间，编写相关代码部分，如下所示：

package j2se.demo;
 
public class NodeTest {
 
	public static void main(String[] args) {
 
		Node node1 = new Node("node1");
		Node node2 = new Node("node2");
		Node node3 = new Node("node3");
 
		node1.next=node2;
		node2.next=node3;
 
		System.out.println(node1.next.next.data);
 
		System.out.println("----------");
 
		Node node4  = new Node("node4");
		node1.next=node4;
		node4.next=node2;
		System.out.println(node1.next.next.next.data);
 
	}
 
}

运行，效果如下所示：

接着，我们将node4进行删除，代码如下所示：

package j2se.demo;
 
public class NodeTest {
 
	public static void main(String[] args) {
 
		Node node1 = new Node("node1");
		Node node2 = new Node("node2");
		Node node3 = new Node("node3");
 
		node1.next=node2;
		node2.next=node3;
 
		System.out.println(node1.next.next.data);
 
		System.out.println("----------");
 
		Node node4  = new Node("node4");
		node1.next=node4;
		node4.next=node2;
		System.out.println(node1.next.next.next.data);
 
		System.out.println("----------");
 
		node1.next=node2;
		node4.next=null;
		System.out.println(node1.next.next.data);
 
	}
 
}

运行效果如下所示：

接着，我们来看双向循环链表，使得node1的后一个元素是node2，node2的前一个元素是node1，node2的后一个元素是node3，node3的前一个元素是node2，node3的下一个元素是node1，node1的前一个元素是node3，首先我们需要定义一个Node2类，我们来看代码部分：

package j2se.demo;
 
public class Node2 {
	Node2 previous;
	String data;
	Node2 next;
 
	public Node2(String data){
		this.data=data;
	}
 
}

接着，我们来实现，代码如下所示：

package j2se.demo;
 
public class NodeTest2 {
	public static void main(String[] args) {
		Node2 node1 = new Node2("data1");
		Node2 node2 = new Node2("data2");
		Node2 node3 = new Node2("data3");
 
		node1.next = node2;
		node2.next = node3;
		node3.next = node1;
 
		node3.previous = node2;
		node2.previous = node1;
		node1.previous = node3;
 
		System.out.println(node1.next.next.data);
		System.out.println(node3.previous.previous.data);
 
	}
 
}

运行效果，如下所示：

接着，小伙伴可以对其进行插入和删除的操作，和单向链表大同小异，小伙伴们可以自己动手实现。小编为什么要讲链表呢？因为LinkedList的底层实现就是一个双向链表，这个如果明白了，LinkedList的源码也就明白了，跟进去LinkedList的源码，我们来看她的部分源码，我们首先来看LinkedList类结构的定义，如下所示：

//通过LinkedList实现的接口可知，其支持队列操作，双向列表操作，能被克隆，支持序列化
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // LinkedList的大小（指其所含的元素个数）
    transient int size = 0;
 
    /**
     * 指向第一个节点
     * 不变的: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;
 
    /**
     * 指向最后一个节点
     * 不变的: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;
 
    ......
}

通过上面的代码，我们知道，
a、LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
b、LinkedList 实现 List 接口，能对它进行队列操作。
c、LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
d、LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
e、LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
f、LinkedList 是非同步的。
LinkedList包含了三个重要的对象：first、last 和 size。
a、 first 是双向链表的表头，它是双向链表节点所对应的类Node的实例
b、 last 是双向链表的最后一个元素，它是双向链表节点所对应的类Node的实例
c、 size 是双向链表中节点的个数。
接着我们来看一下LinkedList的构造函数，如下所示：

//构建一个空列表
    public LinkedList() {
    }
 
    /**
     * 构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回的顺序排列的
     * @param  c 包含用于去构造LinkedList的元素的collection
     * @throws NullPointerException 如果指定的collection为空
     */
    //构建一个包含指定集合c的列表
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

LinkedList的源码部分就先介绍到这里，小伙伴可以自己点进去看看哦，List的实现接口，小编已经介绍完两个了，一个ArrayList和LinkedList，既然她们两个都是实现了List接口，那么她们有什么样的区别和联系呢？

ArrayList && LinkedList 比较

a、ArrayList是基于数组，LinkedList基于链表实现。
b、对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
c、对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
d、查找操作indexOf,lastIndexOf,contains等，两者差不多。
小编寄语：该博文，小编主要介绍了list接口中另一个实现类LinkedList，从LinkedList的基本方法，到LinkedList的源码部分，和ArrayList进行对比，ArrayList底层采用数组实现，LinkedList采用双向链表实现，当执行插入或者删除操作的时候，采用LinkedList比较好；当执行搜索操作的时候，采用ArrayList比较好。小伙伴在学习的过程中，可以多查一查API文档，一起加油，小伙伴们`(*∩_∩*)′。