您的位置:首页 > 编程语言 > Java开发

Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例

2014-07-15 11:55 1096 查看

概要

前面,我们已经学习了ArrayList,并了解了fail-fast机制。这一章我们接着学习List的实现类——LinkedList。
和学习ArrayList一样,接下来呢,我们先对LinkedList有个整体认识,然后再学习它的源码;最后再通过实例来学会使用LinkedList。内容包括:
第1部分 LinkedList介绍
第2部分 LinkedList数据结构
第3部分 LinkedList源码解析(基于JDK1.6.0_45)
第4部分 LinkedList遍历方式
第5部分 LinkedList示例

转载请注明出处:/article/4709043.html

第1部分 LinkedList介绍

LinkedList简介

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口,能对它进行队列操作。
LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
LinkedList 是非同步的。

LinkedList构造函数

// 默认构造函数
LinkedList()

// 创建一个LinkedList,保护Collection中的全部元素。
LinkedList(Collection<? extends E> collection)


LinkedList的API

1 import java.util.List;
2 import java.util.Iterator;
3 import java.util.LinkedList;
4 import java.util.NoSuchElementException;
5
6 /*
7  * @desc LinkedList测试程序。
8  *
9  * @author skywang
10  * @email  kuiwu-wang@163.com
11  */
12 public class LinkedListTest {
13     public static void main(String[] args) {
14         // 测试LinkedList的API
15         testLinkedListAPIs() ;
16
17         // 将LinkedList当作 LIFO(后进先出)的堆栈
18         useLinkedListAsLIFO();
19
20         // 将LinkedList当作 FIFO(先进先出)的队列
21         useLinkedListAsFIFO();
22     }
23
24     /*
25      * 测试LinkedList中部分API
26      */
27     private static void testLinkedListAPIs() {
28         String val = null;
29         //LinkedList llist;
30         //llist.offer("10");
31         // 新建一个LinkedList
32         LinkedList llist = new LinkedList();
33         //---- 添加操作 ----
34         // 依次添加1,2,3
35         llist.add("1");
36         llist.add("2");
37         llist.add("3");
38
39         // 将“4”添加到第一个位置
40         llist.add(1, "4");
41
42
43         System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
44         // (01) 将“10”添加到第一个位置。  失败的话,抛出异常!
45         llist.addFirst("10");
46         System.out.println("llist:"+llist);
47         // (02) 将第一个元素删除。        失败的话,抛出异常!
48         System.out.println("llist.removeFirst():"+llist.removeFirst());
49         System.out.println("llist:"+llist);
50         // (03) 获取第一个元素。          失败的话,抛出异常!
51         System.out.println("llist.getFirst():"+llist.getFirst());
52
53
54         System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
55         // (01) 将“10”添加到第一个位置。  返回true。
56         llist.offerFirst("10");
57         System.out.println("llist:"+llist);
58         // (02) 将第一个元素删除。        失败的话,返回null。
59         System.out.println("llist.pollFirst():"+llist.pollFirst());
60         System.out.println("llist:"+llist);
61         // (03) 获取第一个元素。          失败的话,返回null。
62         System.out.println("llist.peekFirst():"+llist.peekFirst());
63
64
65         System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
66         // (01) 将“20”添加到最后一个位置。  失败的话,抛出异常!
67         llist.addLast("20");
68         System.out.println("llist:"+llist);
69         // (02) 将最后一个元素删除。        失败的话,抛出异常!
70         System.out.println("llist.removeLast():"+llist.removeLast());
71         System.out.println("llist:"+llist);
72         // (03) 获取最后一个元素。          失败的话,抛出异常!
73         System.out.println("llist.getLast():"+llist.getLast());
74
75
76         System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
77         // (01) 将“20”添加到第一个位置。  返回true。
78         llist.offerLast("20");
79         System.out.println("llist:"+llist);
80         // (02) 将第一个元素删除。        失败的话,返回null。
81         System.out.println("llist.pollLast():"+llist.pollLast());
82         System.out.println("llist:"+llist);
83         // (03) 获取第一个元素。          失败的话,返回null。
84         System.out.println("llist.peekLast():"+llist.peekLast());
85
86
87
88         // 将第3个元素设置300。不建议在LinkedList中使用此操作,因为效率低!
89         llist.set(2, "300");
90         // 获取第3个元素。不建议在LinkedList中使用此操作,因为效率低!
91         System.out.println("\nget(3):"+llist.get(2));
92
93
94         // ---- toArray(T[] a) ----
95         // 将LinkedList转行为数组
96         String[] arr = (String[])llist.toArray(new String[0]);
97         for (String str:arr)
98             System.out.println("str:"+str);
99
100         // 输出大小
101         System.out.println("size:"+llist.size());
102         // 清空LinkedList
103         llist.clear();
104         // 判断LinkedList是否为空
105         System.out.println("isEmpty():"+llist.isEmpty()+"\n");
106
107     }
108
109     /**
110      * 将LinkedList当作 LIFO(后进先出)的堆栈
111      */
112     private static void useLinkedListAsLIFO() {
113         System.out.println("\nuseLinkedListAsLIFO");
114         // 新建一个LinkedList
115         LinkedList stack = new LinkedList();
116
117         // 将1,2,3,4添加到堆栈中
118         stack.push("1");
119         stack.push("2");
120         stack.push("3");
121         stack.push("4");
122         // 打印“栈”
123         System.out.println("stack:"+stack);
124
125         // 删除“栈顶元素”
126         System.out.println("stack.pop():"+stack.pop());
127
128         // 取出“栈顶元素”
129         System.out.println("stack.peek():"+stack.peek());
130
131         // 打印“栈”
132         System.out.println("stack:"+stack);
133     }
134
135     /**
136      * 将LinkedList当作 FIFO(先进先出)的队列
137      */
138     private static void useLinkedListAsFIFO() {
139         System.out.println("\nuseLinkedListAsFIFO");
140         // 新建一个LinkedList
141         LinkedList queue = new LinkedList();
142
143         // 将10,20,30,40添加到队列。每次都是插入到末尾
144         queue.add("10");
145         queue.add("20");
146         queue.add("30");
147         queue.add("40");
148         // 打印“队列”
149         System.out.println("queue:"+queue);
150
151         // 删除(队列的第一个元素)
152         System.out.println("queue.remove():"+queue.remove());
153
154         // 读取(队列的第一个元素)
155         System.out.println("queue.element():"+queue.element());
156
157         // 打印“队列”
158         System.out.println("queue:"+queue);
159     }
160 }


运行结果

Test "addFirst(), removeFirst(), getFirst()"
llist:[10, 1, 4, 2, 3]
llist.removeFirst():10
llist:[1, 4, 2, 3]
llist.getFirst():1

Test "offerFirst(), pollFirst(), peekFirst()"
llist:[10, 1, 4, 2, 3]
llist.pollFirst():10
llist:[1, 4, 2, 3]
llist.peekFirst():1

Test "addLast(), removeLast(), getLast()"
llist:[1, 4, 2, 3, 20]
llist.removeLast():20
llist:[1, 4, 2, 3]
llist.getLast():3

Test "offerLast(), pollLast(), peekLast()"
llist:[1, 4, 2, 3, 20]
llist.pollLast():20
llist:[1, 4, 2, 3]
llist.peekLast():3

get(3):300
str:1
str:4
str:300
str:3
size:4
isEmpty():true

useLinkedListAsLIFO
stack:[4, 3, 2, 1]
stack.pop():4
stack.peek():3
stack:[3, 2, 1]

useLinkedListAsFIFO
queue:[10, 20, 30, 40]
queue.remove():10
queue.element():20
queue:[20, 30, 40]


更多内容

01. Java 集合系列目录

02. Java 集合系列01之 总体框架

03. Java 集合系列03之 ArrayList详细介绍(源码解析)和使用示例

04. Java 集合系列08之 List总结(LinkedList, ArrayList等使用场景和性能分析)

05. Java 集合系列18之 Iterator和Enumeration比较
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐