Java学习 LinkedList

一、简介

1. LinkedList类是双向链表，链表中的每个节点都包含了对前一个和后一个元素的引用。实现了Deque（双端队列），Queue（队列）和Stack（栈）。

2. LinkedList的操作不是线程安全的，建议在单线程环境下使用。

3. 双向链表添加元素只是新增一个节点，延长链表，所以LinkedList不存在容量不足的问题。

4. 常用方法同ArrayList。

5. 序列分先进先出FIFO,先进后出FILO。FIFO在Java中又叫Queue（队列），FILO在Java中又叫Stack（栈）。

二、LinkedList和ArrayList的区别

1. ArrayList 插入、删除数据慢。因为是顺序结构，定位快。

2. LinkedList 插入、删除数据快。因为是链表结构，需要一个一个的查找，定位慢。

三、Deque 双端队列

1. 在将双端队列用作队列时，将得到 FIFO（先进先出）行为。

2. 双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack类。Java堆栈Stack类已经过时，Java官方推荐使用Deque替代Stack使用。Deque堆栈操作方法：push()、pop()、peek()。

四、Queue 队列

Queue是先进先出队列 FIFO，常用方法有

1. offer() 在最后添加元素

2. poll() 取出第一个元素

3. peek() 查看第一个元素

五、Stack 栈

Stack是后进先出队列 LIFO，常用方法有

1. push() 在最后添加元素

2. pop() 取出第一个元素

3. peek() 查看第一个元素

六、代码演示

public class TestLinkedList {
	private static void testLinkedList() {
		LinkedList<Hero> ll = new LinkedList<>();
		ll.addLast(new Hero("hero1"));
		ll.addLast(new Hero("hero2"));
		ll.addLast(new Hero("hero3"));
		System.out.println(ll);
		ll.addFirst(new Hero("heroX"));
		System.out.println(ll);
		System.out.println(ll.getFirst());
		System.out.println(ll.getLast());
		System.out.println(ll.removeFirst());
		System.out.println(ll);
	}
	
	private static void testQueue() {       
        //LinkedList实现了Deque，进而又实现了Queue这个接口，Queue代表FIFO 先进先出的队列
        Queue<Hero> q= new LinkedList<Hero>();        
        //加在队列的最后面
        System.out.print("初始化队列：\t");
        q.offer(new Hero("Hero1"));
        q.offer(new Hero("Hero2"));
        q.offer(new Hero("Hero3"));
        q.offer(new Hero("Hero4"));
        
        System.out.println(q);
        System.out.print("把第一个元素取poll()出来:\t");
        //取出第一个Hero，FIFO 先进先出
        Hero h = q.poll();
        System.out.println(h);
        System.out.print("取出第一个元素之后的队列:\t");
        System.out.println(q);
          
        //把第一个拿出来看一看，但是不取出来
        h = q.peek();
        System.out.print("查看peek()第一个元素:\t");
        System.out.println(h);
        System.out.print("查看并不会导致第一个元素被取出来:\t");
        System.out.println(q);
	}
	
	private static void testDequeFIFO() {       
        //在将双端队列用作队列时，将得到 FIFO（先进先出）行为。
        Deque<Hero> fifo = new LinkedList<Hero>();
        //加在队列的最前面
        System.out.print("通过Deque的FIFO方式初始化队列：\t");
        fifo.offer(new Hero("Hero11"));
        fifo.offer(new Hero("Hero22"));
        fifo.offer(new Hero("Hero33"));
        fifo.offer(new Hero("Hero44"));
          
        System.out.println(fifo);
        System.out.print("把第一个元素取poll()出来:\t");
        //取出第一个Hero，FIFO 先进先出
        Hero h = fifo.poll();
        System.out.println(h);
        System.out.print("取出第一个元素之后的队列:\t");
        System.out.println(fifo);
          
        //把第一个拿出来看一看，但是不取出来
        h = fifo.peek();
        System.out.print("查看peek()第一个元素:\t");
        System.out.println(h);
        System.out.print("查看并不会导致第一个元素被取出来:\t");
        System.out.println(fifo);
	}
	
	/* 双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack类。
	 * Deque堆栈操作方法：push()、pop()、peek()。
	 */
	private static void testDequeLIFO() {       
        Deque<Hero> lifo = new LinkedList<Hero>();         
        System.out.print("通过Deque的LIFO方式初始化队列：\t");
        lifo.push(new Hero("Hero11"));
        lifo.push(new Hero("Hero22"));
        lifo.push(new Hero("Hero33"));
        lifo.push(new Hero("Hero44"));
          
        System.out.println(lifo);
        System.out.print("把第一个元素取poll()出来:\t");
        //取出第一个Hero，LIFO 后进先出
        Hero h = lifo.poll();
        System.out.println(h);
        System.out.print("取出第一个元素之后的队列:\t");
        System.out.println(lifo);
          
        //把第一个拿出来看一看，但是不取出来
        h = lifo.peek();
        System.out.print("查看peek()第一个元素:\t");
        System.out.println(h);
        System.out.print("查看并不会导致第一个元素被取出来:\t");
        System.out.println(lifo);
	}

	private static void testStack() {       
        //Java堆栈Stack类已经过时，Java官方推荐使用Deque替代Stack使用。
        Stack<Hero> s = new Stack<>();
          
        //加在队列的最后面
        System.out.print("通过栈方式初始化队列：\t");
        s.push(new Hero("Hero111"));
        s.push(new Hero("Hero222"));
        s.push(new Hero("Hero333"));
        s.push(new Hero("Hero444"));
          
        System.out.println(s);
        System.out.print("把第一个元素取poll()出来:\t");
        //取出第一个Hero，FIFO 先进先出
        Hero h = s.pop();
        System.out.println(h);
        System.out.print("取出第一个元素之后的队列:\t");
        System.out.println(s);
          
        //把第一个拿出来看一看，但是不取出来
        h = s.peek();
        System.out.print("查看peek()第一个元素:\t");
        System.out.println(h);
        System.out.print("查看并不会导致第一个元素被取出来:\t");
        System.out.println(s);
	}

	public static void main(String[] args) {
		testLinkedList();
		testQueue();
		testDequeFIFO();
		testDequeLIFO();
		testStack();		
	}
}

七、打印结果