一、List：、有顺序以线性方式存储,可以存放重复对象
线程安全方法：List list = Collections.synchronizedList(new LinkedList(...));
LinkedList：双向链表实现存储 索引数据慢插入数度较快 线程不安全（比安全性能好）
ArrayList:数组方式存储数据 索引数据快插入数据慢 线程不安全
Vector:数组方式存储数据 索引数据快插入数据慢 线程安全
Stack：继承自Vector，实现一个后进先出的堆栈
ArrayList:
import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) { List books = new ArrayList(); //向books集合中添加三个元素 books.add(new String("11111111111")); books.add(new String("22222222222")); books.add(new String("33333333333")); System.out.println(books); //将新字符串对象插入在第二个位置 books.add(1 , new String("44444444444")); for (int i = 0 ; i < books.size() ; i++ ) { System.out.println(books.get(i)); } //删除第三个元素 books.remove(2); System.out.println(books); //判断指定元素在List集合中位置：输出1，表明位于第二位 System.out.println(books.indexOf(new String("44444444444"))); //① //将第二个元素替换成新的字符串对象 books.set(1, new String("LittleHann")); System.out.println(books); //将books集合的第二个元素（包括） //到第三个元素（不包括）截取成子集合 System.out.println(books.subList(1 , 2)); } }
Result:
[11111111111, 22222222222, 33333333333] 11111111111 44444444444 22222222222 33333333333 [11111111111, 44444444444, 33333333333] 1 [11111111111, LittleHann, 33333333333] [LittleHann]
Stack:
import java.util.Stack; public class Main { public static void main(String[] args) { Stack v = new Stack(); //依次将三个元素push入"栈" v.push("11"); v.push("22"); v.push("33"); System.out.println(v); //访问第一个元素，但并不将其pop出"栈" System.out.println(v.peek()); System.out.println(v); //pop出第一个元素 System.out.println(v.pop()); System.out.println(v); } }
Result:
[11, 22, 33] 33 [11, 22, 33] 33 [11, 22]
LinkedList:
import java.util.LinkedList; public class Main { public static void main(String[] args) { LinkedList books = new LinkedList(); //将字符串元素加入队列的尾部(双端队列) books.offer("11"); //将一个字符串元素加入栈的顶部(双端队列) books.push("22"); //将字符串元素添加到队列的头(相当于栈的顶部) books.offerFirst("33"); System.out.println(books); //访问、并不删除栈顶的元素 System.out.println(books.peekFirst()); //访问、并不删除队列的最后一个元素 System.out.println(books.peekLast()); //将栈顶的元素弹出"栈" System.out.println(books.pop()); //下面输出将看到队列中第一个元素被删除 System.out.println(books); //访问、并删除队列的最后一个元素 System.out.println(books.pollLast()); //下面输出将看到队列中只剩下中间一个元素： System.out.println(books); } }
Result:
[33, 22, 11] 33 11 33 [22, 11] 11 [22]
PriorityQueue:
PriorityQueue pq = new PriorityQueue(); //下面代码依次向pq中加入四个元素 pq.offer(6); pq.offer(-3); pq.offer(9); pq.offer(0); //输出pq队列，并不是按元素的加入顺序排列， //而是按元素的大小顺序排列，输出[-3, 0, 9, 6] System.out.println(pq); //访问队列第一个元素，其实就是队列中最小的元素：-3 System.out.println(pq.poll());
Result:
[-3, 0, 9, 6]
-3
PriorityQueue不允许插入null元素，它还需要对队列元素进行排序
ArrayDeque:
import java.util.ArrayDeque; public class Main { public static void main(String[] args) { ArrayDeque stack = new ArrayDeque(); //依次将三个元素push入"栈" stack.push("11"); stack.push("22"); stack.push("33"); System.out.println(stack); //访问第一个元素，但并不将其pop出"栈" System.out.println(stack.peek()); System.out.println(stack); //pop出第一个元素 System.out.println(stack.pop()); System.out.println(stack); } }
结果：
[33, 22, 11] 33 [33, 22, 11] 33 [22, 11]
List集合类应用场景：
1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、LinkedList(基于链的线性表)是线性表的两种典型实现 2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用) 3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。所以的内部以数组作为底层实现的集合在随机访问时性能最好。 4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能 5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好