Java中的List的实现类

一、ArrayList集合

ArrayList集合，底层实现：采用数组的结构实现的。（最大的特点：内存连续）。
也会叫做变长数组。

	优点：遍历集合中的元素，效率很高
	缺点：更改集合中的元素，效率相对低。
	
JDK1.2版本

二、LinkedList集合

LinkedList集合：底层实现：采用双向链表的结构实现。
生活中的链表：
	珍珠项链，手链，自行车的链条。。
	
	优点：更改集合中的元素，效率很高。
	缺点：遍历集合中的元素，效率相对低。
	
queue：队伍，队列，行列
	生活中买电影票，排队
	生活中买火车票，排队
	
deque：double -ended queue，双端队列

LinkedList实现类，区别于ArrayList，除了实现List接口，还实现了Deque接口。

LinkedList实现类：
	实现的接口：
		List接口----------------------------------->Collection
		Deque(双端队列)接口----->Queue(队列)接口------>Collection
		
模拟栈的结构：后进先出(LIFO)，栈顶元素，
	push()，压栈，入栈，pop(),弹栈，出栈
模拟队列的结构：先进先出(FIFO)，队头元素
	offer(),poll()

栈的结构特点：

队列的结构特点：

public static void main(String[] args) {
		LinkedList<String> l1 = new LinkedList<>();
		
		l1.add("aaa");
		l1.add(0, "bbb");//List
		System.out.println(l1);
		l1.addFirst("ccc");//向容器的开头，添加元素,Deque
		System.out.println(l1);
		l1.addLast("ddd");//向容器的末尾，添加元素,Deque
		System.out.println(l1);
		
		System.out.println(l1.element());//获取容器中的第一个元素，不删除
		System.out.println(l1);
		
		System.out.println(l1.getFirst());//效果同element()
		System.out.println(l1);
		
		System.out.println(l1.getLast());//获取最后一个元素
		System.out.println(l1);
		
		l1.offer("eee");//向容器后添加元素
		System.out.println(l1);
		
		System.out.println(l1.peek());//效果同element()
		System.out.println(l1);
		
		System.out.println(l1.poll());//获取容器中的第一个元素，并从容器中删除
		System.out.println(l1);
		
		System.out.println(l1.pop());//获取栈顶元素，并移出。
		System.out.println(l1);
		
		
	}

public static void main(String[] args) {
		/*
		 * 栈：一种数据结构。存储数据的特点：LIFO
		 * 后进先出
		 */
		
		LinkedList<String> stack = new LinkedList<>();
		stack.push("aaa");//入栈，压栈，将元素存入到栈中
		stack.push("bbb");
		stack.push("ccc");
		System.out.println(stack);
		
		//获取-->弹栈，出栈，永远出的是栈顶元素----大白话：获取
		String s1 = stack.pop();
		System.out.println(s1);//弹栈，出栈,ccc
		System.out.println(stack);
		System.out.println(stack.pop());//bbb
		System.out.println(stack);
		System.out.println(stack.pop());//aaa
		System.out.println(stack);//空栈
//		System.out.println(stack.pop()); //空栈，不能再弹了，否则异常：java.util.NoSuchElementException
		
		
		stack.push("fff");
		System.out.println(stack);
	}

public static void main(String[] args) {
		/*
		 * 使用LinkedList模拟队列的存储：特点FIFO
		 * First In First Out
		 * 
		 * 消息队列：
		 */
		
		LinkedList<String> l2 = new LinkedList<>();
		l2.offer("aaa");//向队伍中添加元素，默认在队尾添加，效果同很多方法都能够实现：add(),addLast()....
		l2.offer("bbb");
		l2.offer("ccc");
		System.out.println(l2);
		
		System.out.println(l2.poll());//获取队头元素，并移除,,,aaa
		System.out.println(l2);
		System.out.println(l2.poll());//bbb
		System.out.println(l2);
		
	}

【扩展知识1】

数据结构：存储的数据的组织特点。

线性表，链表，树。。。。

栈：Stack，这种数据结构的特点？

last In First Out，简称LIFO，后进先出。

队列：queue，

First in First out，简称FIFO，先进先出。

【扩展知识2】

Vector：向量

对比ArrayList，LinkedList，Vector实现类

A：ArrayList，底层采用数组结构的实现的。（内存中连续空间）。jdk1.2
	只实现了List接口，功能都是List接口中规定的。
	优缺点：
		优点：遍历访问元素，效率很高
		缺点：插入或删除元素，效率相对低。
B：LinkedList，底层采用双向链表结构实现的。（元素在内存中不挨着，元素之间的指向）。jdk1.2
	实现了List接口的同时，还实现了Deque接口，所以有这两个接口中的功能。
	优缺点：
		优点：插入或删除元素，效率很高。
		缺点：遍历访问元素，效率相对低。
注意点：
	如果一个集合，频繁的添加或删除元素，建议选择LinkedList。
	如果一个集合，绝大多数的操作就是遍历查询，建议选择ArrayList。
	如果要模拟栈，队列等结构，建议选择LinkedList。
	
C：Vector，是ArrayList的前身。也是数组的结构。古老的类。从jdk1.0的版本就有了。
	线程安全，效率低，后来被ArrayList替代了。
	ArrayList和LinkedList都是线程不安全的，效率高。Collections工具类，可以获取线程安全的集合。