Java LinkedList基本用法

转自：http://blog.csdn.net/jdsjlzx/article/details/41654295

LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
LinkedList的构造函数如下
1. public LinkedList():  ——生成空的链表
2. public LinkedList(Collection col):  复制构造函数
1、获取链表的第一个和最后一个元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class LinkedListTest{  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.   
12.   
13.     System.out.println("链表的第一个元素是 : " + lList.getFirst());  
14.     System.out.println("链表最后一个元素是 : " + lList.getLast());  
15.   }  
16. }  

2、获取链表元素  

[java]  view plain copy

1. for (String str: lList) {  
2.       System.out.println(str);  
3.     }  

3、从链表生成子表

[java]  view plain copy

1. List subl = lList.subList(1, 4);  
2.     System.out.println(subl);  
3.     lst.remove(2);  
4.     System.out.println(lst);  
5.     System.out.println(lList);  

4、添加元素：添加单个元素
 如果不指定索引的话，元素将被添加到链表的最后.
public boolean add(Object element)
public boolean add(int index, Object element)
也可以把链表当初栈或者队列来处理:
public boolean addFirst(Object element)
public boolean addLast(Object element)
addLast()方法和不带索引的add()方法实现的效果一样.

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class LinkedListTest{  
4.   public static void main(String[] a) {  
5.     LinkedList list = new LinkedList();  
6.     list.add("A");  
7.     list.add("B");  
8.     list.add("C");  
9.     list.add("D");  
10.     list.addFirst("X");  
11.     list.addLast("Z");  
12.     System.out.println(list);  
13.   }  
14. }  

5、删除元素

[java]  view plain copy

1. public Object removeFirst()  
2. public Object removeLast()  
3. import java.util.LinkedList;  
4.   
5.   
6. public class MainClass {  
7.   public static void main(String[] a) {  
8.   
9.   
10.     LinkedList list = new LinkedList();  
11.     list.add("A");  
12.     list.add("B");  
13.     list.add("C");  
14.     list.add("D");  
15.     list.removeFirst();  
16.     list.removeLast();  
17.     System.out.println(list);  
18.   }  
19. }  

6、使用链表实现栈效果

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class MainClass {  
3.   public static void main(String[] args) {  
4.     StackL stack = new StackL();  
5.     for (int i = 0; i < 10; i++)  
6.       stack.push(i);  
7.     System.out.println(stack.top());  
8.     System.out.println(stack.top());  
9.     System.out.println(stack.pop());  
10.     System.out.println(stack.pop());  
11.     System.out.println(stack.pop());  
12.   }  
13. }  
14. class StackL {  
15.   private LinkedList list = new LinkedList();  
16.   public void push(Object v) {  
17.     list.addFirst(v);  
18.   }  
19.   public Object top() {  
20.     return list.getFirst();  
21.   }  
22.   public Object pop() {  
23.     return list.removeFirst();  
24.   }  
25. }  

7、使用链表来实现队列效果

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class MainClass {  
3.   public static void main(String[] args) {  
4.     Queue queue = new Queue();  
5.     for (int i = 0; i < 10; i++)  
6.       queue.put(Integer.toString(i));  
7.     while (!queue.isEmpty())  
8.       System.out.println(queue.get());  
9.   }  
10. }  
11. class Queue {  
12.   private LinkedList list = new LinkedList();  
13.   public void put(Object v) {  
14.     list.addFirst(v);  
15.   }  
16.   public Object get() {  
17.     return list.removeLast();  
18.   }  
19.   public boolean isEmpty() {  
20.     return list.isEmpty();  
21.   }  
22. }  

8、将LinkedList转换成ArrayList

[java]  view plain copy

1. ArrayList<String> arrayList = new ArrayList<String>(linkedList);  
2.     for (String s : arrayList) {  
3.       System.out.println("s = " + s);  
4.     }  

9、删掉所有元素：清空LinkedList
    lList.clear();
10、删除列表的首位元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.         //元素在删除的时候，仍然可以获取到元素  
12.     Object object = lList.removeFirst();  
13.     System.out.println(object + " has been removed");  
14.     System.out.println(lList);  
15.     object = lList.removeLast();  
16.     System.out.println(object + " has been removed");  
17.     System.out.println(lList);  
18.   }  
19. }  

11、根据范围删除列表元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.     lList.subList(2, 5).clear();  
12.     System.out.println(lList);  
13.   }  
14. }  

12、删除链表的特定元素

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] args) {  
4.     LinkedList<String> lList = new LinkedList<String>();  
5.     lList.add("1");  
6.     lList.add("2");  
7.     lList.add("3");  
8.     lList.add("4");  
9.     lList.add("5");  
10.     System.out.println(lList);  
11.     System.out.println(lList.remove("2"));//删除元素值=2的元素  
12.     System.out.println(lList);  
13.     Object obj = lList.remove(2);  //删除第二个元素  
14.     System.out.println(obj + " 已经从链表删除");  
15.     System.out.println(lList);  
16.   }  
17. }  

13、将LinkedList转换为数组，数组长度为0

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. public class Main {  
4.   public static void main(String[] args) {  
5.     List<String> theList = new LinkedList<String>();  
6.     theList.add("A");  
7.     theList.add("B");  
8.     theList.add("C");  
9.     theList.add("D");  
10.     String[] my = theList.toArray(new String[0]);  
11.     for (int i = 0; i < my.length; i++) {  
12.       System.out.println(my[i]);  
13.     }  
14.   }  
15. }  

14、将LinkedList转换为数组，数组长度为链表长度

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. public class Main {  
4.   public static void main(String[] args) {  
5.     List<String> theList = new LinkedList<String>();  
6.     theList.add("A");  
7.     theList.add("B");  
8.     theList.add("C");  
9.     theList.add("D");  
10.     String[] my = theList.toArray(new String[theList.size()]);  
11.     for (int i = 0; i < my.length; i++) {  
12.       System.out.println(my[i]);  
13.     }  
14.   }  
15. }  

15、将LinkedList转换成ArrayList

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. public class Main {  
5.   public static void main(String[] args) {  
6.     LinkedList<String> myQueue = new LinkedList<String>();  
7.     myQueue.add("A");  
8.     myQueue.add("B");  
9.     myQueue.add("C");  
10.     myQueue.add("D");  
11.     List<String> myList = new ArrayList<String>(myQueue);  
12.     for (Object theFruit : myList)  
13.       System.out.println(theFruit);  
14.   }  
15. }  

16、实现栈

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.LinkedList;  
3. public class Main {  
4.   public static void main(String[] argv) throws Exception {  
5.     LinkedList stack = new LinkedList();  
6.     Object object = "";  
7.     stack.addFirst(object);  
8.     Object o = stack.getFirst();  
9.     stack = (LinkedList) Collections.synchronizedList(stack);  
10.   }  
11. }  

17、实现队列

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class Main {  
3.   public static void main(String[] argv) throws Exception {  
4.     LinkedList queue = new LinkedList();  
5.     Object object = "";  
6.     // Add to end of queue  
7.     queue.add(object);  
8.     // Get head of queue  
9.     Object o = queue.removeFirst();  
10.   }  
11. }  

18 、同步方法

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.LinkedList;  
3. public class Main {  
4.   public static void main(String[] argv) throws Exception {  
5.     LinkedList queue = new LinkedList();  
6.     Object object = "";  
7.     queue.add(object);  
8.     Object o = queue.removeFirst();  
9.     queue = (LinkedList) Collections.synchronizedList(queue);  
10.   }  
11. }  

19、查找元素位置

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class Main {  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.     lList.add("2");  
12.     System.out.println(lList.indexOf("2"));  
13.     System.out.println(lList.lastIndexOf("2"));  
14.   }  
15. }  

20、替换元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3. public class Main {  
4.   public static void main(String[] args) {  
5.     LinkedList<String> lList = new LinkedList<String>();  
6.     lList.add("1");  
7.     lList.add("2");  
8.     lList.add("3");  
9.     lList.add("4");  
10.     lList.add("5");  
11.     System.out.println(lList);  
12.     lList.set(3, "Replaced");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值  
13.     System.out.println(lList);  
14.   }  
15. }  

21、链表添加对象

[java]  view plain copy

1. import java.util.LinkedList;  
2. class Address {  
3.   private String name;  
4.   private String street;  
5.   private String city;  
6.   private String state;  
7.   private String code;  
8.   Address(String n, String s, String c, String st, String cd) {  
9.     name = n;  
10.     street = s;  
11.     city = c;  
12.     state = st;  
13.     code = cd;  
14.   }  
15.   public String toString() {  
16.     return name + " " + street + " " + city + " " + state + " " + code;  
17.   }  
18. }  
19.   
20.   
21. class MailList {  
22.   public static void main(String args[]) {  
23.     LinkedList<Address> ml = new LinkedList<Address>();  
24.     ml.add(new Address("A", "11 Ave", "U", "IL", "11111"));  
25.     ml.add(new Address("R", "11 Lane", "M", "IL", "22222"));  
26.     ml.add(new Address("T", "8 St", "C", "IL", "33333"));  
27.     for (Address element : ml)  
28.       System.out.println(element + "\n");  
29.   }  
30. }  

22、确认链表是否存在特定元素

[java]  view plain copy

1. import java.util.LinkedList;  
2.   
3.   
4. public class Main {  
5.   public static void main(String[] args) {  
6.     LinkedList<String> lList = new LinkedList<String>();  
7.     lList.add("1");  
8.     lList.add("2");  
9.     lList.add("3");  
10.     lList.add("4");  
11.     lList.add("5");  
12.     if (lList.contains("4")) {  
13.       System.out.println("LinkedList contains 4");  
14.     } else {  
15.       System.out.println("LinkedList does not contain 4");  
16.     }  
17.   }  
18. }  

23、根据链表元素生成对象数组

[java]  view plain copy

1. Object[] objArray = lList.toArray();  
2. for (Object obj: objArray) {  
3.    System.out.println(obj);  
4. }  

24、链表多线程

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. class PrepareProduction implements Runnable {  
5.   private final List<String> queue;  
6.   PrepareProduction(List<String> q) {  
7.     queue = q;  
8.   }  
9.   public void run() {  
10.     queue.add("1");  
11.     queue.add("done");  
12.   }  
13. }  
14. class DoProduction implements Runnable {  
15.   private final List<String> queue;  
16.   DoProduction(List<String> q) {  
17.     queue = q;  
18.   }  
19.   public void run() {  
20.     String value = queue.remove(0);  
21.     while (!value.equals("*")) {  
22.       System.out.println(value);  
23.       value = queue.remove(0);  
24.     }  
25.   }  
26. }  
27. public class Main {  
28.   public static void main(String[] args) throws Exception {  
29.     List q = Collections.synchronizedList(new LinkedList<String>());  
30.     Thread p1 = new Thread(new PrepareProduction(q));  
31.     Thread c1 = new Thread(new DoProduction(q));  
32.     p1.start();  
33.     c1.start();  
34.     p1.join();  
35.     c1.join();  
36.   }  
37. }  

25、优先级链表（来自JBOSS）

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. import java.util.ListIterator;  
5. import java.util.NoSuchElementException;  
6.   
7.   
8. public class BasicPriorityLinkedList {  
9.   
10.   
11.   protected LinkedList[] linkedLists;  
12.   protected int priorities;  
13.   protected int size;  
14.   
15.   
16.   public BasicPriorityLinkedList(int priorities) {  
17.     this.priorities = priorities;  
18.     initDeques();  
19.   }  
20.   public void addFirst(Object obj, int priority) {  
21.     linkedLists[priority].addFirst(obj);  
22.     size++;  
23.   }  
24.   public void addLast(Object obj, int priority) {  
25.     linkedLists[priority].addLast(obj);  
26.     size++;  
27.   }  
28.   public Object removeFirst() {  
29.     Object obj = null;  
30.     for (int i = priorities - 1; i >= 0; i--) {  
31.       LinkedList ll = linkedLists[i];  
32.       if (!ll.isEmpty()) {  
33.         obj = ll.removeFirst();  
34.         break;  
35.       }  
36.     }  
37.     if (obj != null) {  
38.       size--;  
39.     }  
40.     return obj;  
41.   }  
42.   public Object removeLast() {  
43.     Object obj = null;  
44.     for (int i = 0; i < priorities; i++) {  
45.       LinkedList ll = linkedLists[i];  
46.       if (!ll.isEmpty()) {  
47.         obj = ll.removeLast();  
48.       }  
49.       if (obj != null) {  
50.         break;  
51.       }  
52.     }  
53.     if (obj != null) {  
54.       size--;  
55.     }  
56.     return obj;  
57.   }  
58.   
59.   
60.   public Object peekFirst() {  
61.     Object obj = null;  
62.     for (int i = priorities - 1; i >= 0; i--) {  
63.       LinkedList ll = linkedLists[i];  
64.       if (!ll.isEmpty()) {  
65.         obj = ll.getFirst();  
66.       }  
67.       if (obj != null) {  
68.         break;  
69.       }  
70.     }  
71.     return obj;  
72.   }  
73.   
74.   
75.   public List getAll() {  
76.     List all = new ArrayList();  
77.     for (int i = priorities - 1; i >= 0; i--) {  
78.       LinkedList deque = linkedLists[i];  
79.       all.addAll(deque);  
80.     }  
81.     return all;  
82.   }  
83.   
84.   
85.   public void clear() {  
86.     initDeques();  
87.   }  
88.   
89.   
90.   public int size() {  
91.     return size;  
92.   }  
93.   
94.   
95.   public boolean isEmpty() {  
96.     return size == 0;  
97.   }  
98.   
99.   
100.   public ListIterator iterator() {  
101.     return new PriorityLinkedListIterator(linkedLists);  
102.   }  
103.   
104.   
105.   protected void initDeques() {  
106.     linkedLists = new LinkedList[priorities];  
107.     for (int i = 0; i < priorities; i++) {  
108.       linkedLists[i] = new LinkedList();  
109.     }  
110.     size = 0;  
111.   }  
112.   
113.   
114.   class PriorityLinkedListIterator implements ListIterator {  
115.     private LinkedList[] lists;  
116.     private int index;  
117.     private ListIterator currentIter;  
118.     PriorityLinkedListIterator(LinkedList[] lists) {  
119.       this.lists = lists;  
120.       index = lists.length - 1;  
121.       currentIter = lists[index].listIterator();  
122.     }  
123.   
124.   
125.     public void add(Object arg0) {  
126.       throw new UnsupportedOperationException();  
127.     }  
128.   
129.   
130.     public boolean hasNext() {  
131.       if (currentIter.hasNext()) {  
132.         return true;  
133.       }  
134.       while (index >= 0) {  
135.         if (index == 0 || currentIter.hasNext()) {  
136.           break;  
137.         }  
138.         index--;  
139.         currentIter = lists[index].listIterator();  
140.       }  
141.       return currentIter.hasNext();  
142.     }  
143.   
144.   
145.     public boolean hasPrevious() {  
146.       throw new UnsupportedOperationException();  
147.     }  
148.   
149.   
150.     public Object next() {  
151.       if (!hasNext()) {  
152.         throw new NoSuchElementException();  
153.       }  
154.       return currentIter.next();  
155.     }  
156.   
157.   
158.     public int nextIndex() {  
159.       throw new UnsupportedOperationException();  
160.     }  
161.   
162.   
163.     public Object previous() {  
164.       throw new UnsupportedOperationException();  
165.     }  
166.   
167.   
168.     public int previousIndex() {  
169.       throw new UnsupportedOperationException();  
170.     }  
171.   
172.   
173.     public void remove() {  
174.       currentIter.remove();  
175.       size--;  
176.     }  
177.   
178.   
179.     public void set(Object obj) {  
180.       throw new UnsupportedOperationException();  
181.     }  
182.   }  
183.   
184.   
185. }  

26、生成list的帮助类（来自google）

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.Collections;  
3. import java.util.LinkedList;  
4. import java.util.List;  
5. public class Lists {  
6.   private Lists() { }  
7.   public static <E> ArrayList<E> newArrayList() {  
8.     return new ArrayList<E>();  
9.   }  
10.   public static <E> ArrayList<E> newArrayListWithCapacity(int initialCapacity) {  
11.     return new ArrayList<E>(initialCapacity);  
12.   }  
13.   public static <E> ArrayList<E> newArrayList(E... elements) {  
14.     ArrayList<E> set = newArrayList();  
15.     Collections.addAll(set, elements);  
16.     return set;  
17.   }  
18.   public static <E> ArrayList<E> newArrayList(Iterable<? extends E> elements) {  
19.     ArrayList<E> list = newArrayList();  
20.     for(E e : elements) {  
21.       list.add(e);  
22.     }  
23.     return list;  
24.   }  
25.   public static <E> LinkedList<E> newLinkedList() {  
26.     return new LinkedList<E>();  
27.   }  
28. }