Java筆記集合之LinkedList

1、簡介

使用數組來存儲數據的一個缺點是,數組是靜態的結構,因此 不能被容易的擴展或減少數據集。維護新數組也貴 插入和刪除。 在這一章裏,我們考慮另一個名爲鏈表的數據結構 地址的一些侷限性數組。

一個鏈表是一個線性數據結構,其中每個元素是一個單獨的 對象。

每個元素(我們叫它節點的兩個項目——組成的列表 數據和到下一個節點的引用。 最後一個節點的引用null。 入口點到鏈表稱爲頭的列表。 應該注意,頭 不是一個單獨的節點,而是第一個節點的引用。 如果列表爲空,那麼是一個主管 空引用。

一個鏈表是一個動態的數據結構。 列表中的節點的數目是不固定的,可以生長 對需求和收縮。 任何應用程序的處理需要數量未知的對象 使用鏈表。

對數組鏈表的一個缺點是它不允許 直接訪問單個元素。 如果你想訪問一個特定的項目 你必須從頭部開始,遵循項目的引用,直到你到達。

另一個缺點是,鏈表使用更多的內存與——我們額外的數組 4個字節(32位CPU)存儲到下一個節點的引用。

2、鏈表分類

鏈表分類

單鏈表	可以通過後驅找到後續節點
雙鏈表	有前驅和後驅，可以找到前驅結點和後繼結點
循環鏈表	最後一個節點的後驅是第一個節點

3、構造方法

LinkedList()            構造一個空列表。

LinkedList(Collection<? extendsE> c)           構造一個包含指定 collection 中的元素的列表，這些元素按其 collection 的迭代器返回的順序排列。

4、方法摘要

boolean	add(E e)           將指定元素添加到此列表的結尾。
void	add(int index,E element)           在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection<? extendsE> c)           添加指定 collection 中的所有元素到此列表的結尾
boolean	addAll(int index,Collection<? extendsE> c)           將指定 collection 中的所有元素從指定位置開始插入此列表。
void	addFirst(E e)           將指定元素插入此列表的開頭。
void	addLast(E e)           將指定元素添加到此列表的結尾。
void	clear()           從此列表中移除所有元素。
Object	clone()           返回此 LinkedList 的淺表副本
boolean	contains(Object o)           如果此列表包含指定元素，則返回 true。
Iterator<E>	descendingIterator()           返回以逆向順序在此雙端隊列的元素上進行迭代的迭代器。
E	element()           獲取但不移除此列表的頭（第一個元素）。
E	get(int index)           返回此列表中指定位置處的元素。
E	getFirst()           返回此列表的第一個元素。
E	getLast()           返回此列表的最後一個元素。
int	indexOf(Object o)           返回此列表中首次出現的指定元素的索引，如果此列表中不包含該元素，則返回 -1。
int	lastIndexOf(Object o)           返回此列表中最後出現的指定元素的索引，如果此列表中不包含該元素，則返回 -1
Iterator<E>	listIterator(int index)           返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始。
boolean	offer(E e)           將指定元素添加到此列表的末尾（最後一個元素）。
boolean	offerFirst(E e)           在此列表的開頭插入指定的元素
boolean	offerLast(E e)           在此列表末尾插入指定的元素。
E	peek()           獲取但不移除此列表的頭（第一個元素）。
E	peekFirst()           獲取但不移除此列表的第一個元素；如果此列表爲空，則返回 null。
E	peekLast()           獲取但不移除此列表的最後一個元素；如果此列表爲空，則返回 null
E	poll()           獲取並移除此列表的頭（第一個元素）
E	pollFirst()           獲取並移除此列表的第一個元素；如果此列表爲空，則返回 null。
E	pollLast()           獲取並移除此列表的最後一個元素；如果此列表爲空，則返回 null。
E	pop()           從此列表所表示的堆棧處彈出一個元素。
void	push(E e)           將元素推入此列表所表示的堆棧。
E	remove()           獲取並移除此列表的頭（第一個元素）。
E	remove(int index)           移除此列表中指定位置處的元素。
boolean	remove(Object o)           從此列表中移除首次出現的指定元素（如果存在）。
E	removeFirst()           移除並返回此列表的第一個元素。
boolean	removeFirstOccurrence(Object o)           從此列表中移除第一次出現的指定元素（從頭部到尾部遍歷列表時）。
E	removeLast()           移除並返回此列表的最後一個元素。
boolean	removeLastOccurrence(Object o)           從此列表中移除最後一次出現的指定元素（從頭部到尾部遍歷列表時）。
E	set(int index,E element)           將此列表中指定位置的元素替換爲指定的元素。
int	size()           返回此列表的元素數
Object[]	toArray()           返回以適當順序（從第一個元素到最後一個元素）包含此列表中所有元素的數組。
<T> T[]	toArray(T[] a)           返回以適當順序（從第一個元素到最後一個元素）包含此列表中所有元素的數組；返回數組的運行時類型爲指定數組的類型。
12	12

5、部分代碼

1、添加、獲取、刪除、遍歷

public class TestLinkedList {
	public static void main(String[] args) {
		LinkedList<String> books = new LinkedList();

		// 把元素添加到列表的結尾
		books.add("A");
		books.add("B");
		books.add("C");

		// 把元素添加到列表的第一個位置
		books.addFirst("1");

		// 把元素添加到列表的最後一個位置
		books.addLast("8");

		// 把元素添加到列表的最後一個位置
		books.offer("X");

		// 把元素添加到列表的第一個位置
		books.offerFirst("0");

		// 把元素添加到列表的最後一個位置
		books.offerLast("9");

		// 遍歷方法一
		Iterator<String> iter = books.iterator();
		while (iter.hasNext()) {
			String element = iter.next();
			System.out.print(element);
		}
		// 輸出 ：01ABC8X9

		// 遍歷方法二
		for (String str : books) {
			System.out.print(str);
		}
		// 輸出 ：01ABC8X9

		// 獲取鏈表的第一個元素,並且不移除
		// 方法一
		System.out.println(books.getFirst());
		// 方法二
		System.out.println(books.element());
		// 方法三
		System.out.println(books.peek());
		// 方法四
		System.out.println(books.peekFirst());

		// 獲取第一個元素並且移除
		// 方法一
		System.out.println(books.poll());
		// 方法二
		System.out.println(books.pollFirst());
		// 方法三
		System.out.println(books.remove());
		// 方法四
		System.out.println(books.removeFirst());

		// 遍歷方法三，到序遍歷
		iter = books.descendingIterator();
		while (iter.hasNext()) {
			String element = iter.next();
			System.out.print(element);
		}

		// 獲取子鏈表
		System.out.println(books.subList(0, 2));
		// 刪除指定位置的元素
		books.subList(0, 2).clear();
		for (String str : books) {
			System.out.print(str);
		}
	}
}

2、實現棧的效果

public class TestLinkedListandSXtack {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyStacks ms = new MyStacks();
		//入棧
		ms.Push("A");
		ms.Push("B");
		ms.Push("C");
		//LinkedList 轉 ArrayList
		ms.Show();
		
		//獲取棧頂元素
		System.out.println(ms.Top());
	
		
		//連續出棧
		System.out.println(ms.Pop());
		System.out.println(ms.Pop());
		System.out.println(ms.Pop());
	}

}
class MyStacks
{
	private LinkedList<Object> list = new LinkedList<Object>();
	
	public void Show(){
		//LinkedList 轉 ArrayList
		ArrayList<Object> ay = new ArrayList<Object>(list);
		for(Object str:ay){
			System.out.print(str);
		}
		System.out.println();
	}
	
	//獲取棧頂元素
	public Object Top(){
		return list.getFirst();//list.element();
	}
	//入棧
	public void Push(Object o){
		list.addFirst(o);
	}
	//出棧
	public Object Pop(){
		return list.remove();
	}
}

3、實現隊列的效果

<p><span style="font-weight: normal;">package com.jlz;
import java.util.*;
public class TestLinkedListAndQueue {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyQueue queue = new MyQueue();
		queue.Put("A");
		queue.Put("B");
		queue.Put("C");
		
		while(!queue.isEmpty()){
			System.out.print(queue.Get());
		}
	}
}
class MyQueue
{
	LinkedList<Object> list = new LinkedList<Object>();
	//入隊列，添加到隊尾
	public void Put(Object o){
		list.addLast(o);
	}
	//出隊列
	public Object Get(){
		return list.removeFirst();
	}
	//判斷是否爲空
	boolean isEmpty(){
		return list.isEmpty();
	}
}
</span></p>

4、轉換爲數組（長度爲0，長度爲鏈表長度）、轉換爲ArrayList

package com.jlz;
import java.util.*;
public class LinkedListChangeIndex {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedList<String> list =  new LinkedList<String>();
		list.add("A");
		list.add("B");
		list.add("C");
		//轉爲數組,數組長度爲0
		String str[] = list.toArray(new String[0]);
		for(String s:str){
			System.out.print(s);
		}
		//轉爲數組,數組長度爲鏈表長度
		String string[] = list.toArray(new String[list.size()]);
		for(String s:string){
			System.out.print(s);
		}
		//轉爲ArrayList
		ArrayList<String> alist = new ArrayList<String>(list);
		for(Object o:alist){
			System.out.print(o);
		}
	}

}

5、同步

package com.jlz;
import java.util.*;
public class LinkedListStackSynchronized {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedList<Object> stack = new LinkedList<Object>();
		stack.addFirst("A");
		stack.addFirst("B");
		stack.addFirst("C");
		//同步
		stack = (LinkedList<Object>)Collections.synchronizedList(stack);
	}

}