List-Collection的子接口，可重复集，并且有序，根据下表操作元素

ArrayList (线性数据表) 使用数组实现，查询更快
1.E set(int index, E e) 将给定的元素插入到指定的位置，返回值为原位置上的元素，相当于替换元素操作

List<String> list = new ArrayList<String>();
list.add("one");list.add("two");list.add("three");list.add("four");
System.out.println(list);//[one,two,three,four]
String old = list.set(1, "2");
System.out.println(old);//two
System.out.println(list);//[one,2,three,four]

2.E get(int index) 获取给定下标的元素

String str = list.get(2);//获取第三个元素
System.out.println(str);//three

3.List提供了重载的add和remove方法，分别用于插入元素到指定位置和删除指定位置的元素的方法

list.add(1,"thero");//将thero插入到第一个位置，该位置以后元素向后挪动位置
System.out.println(list);//[one,thero,2,three,four]
String deleted = list.remove(2);
System.out.println(deleted);//2
System.out.println(list);//[one,thero,three,four]

4.for循环遍历List

for(int i=0;i<list.size();i++){
  String str = list.get(i);
  System.out.println(str);//one thero three four
}

5.List subList(int start, int end) 取子集，含头不含尾

List<String> subList = list.subList(0, 2);
System.out.println(subList);//[one,thero]
List<Integer> list2 = new ArrayList<Integer>();
for(int i=0;i<10;i++){
     list2.add(i);
}
System.out.println(list2);//[1,2,3,4,5,6,7,8,9]
//取子集3-6，并扩大10倍
List<Integer> subList2 = list2.subList(2,6);
System.out.println(subList2);//[3,4,5,6]
for(int i=0;i<subList2.size();i++){
     sublist2.set(i, subList2.get(i)*10);
}
//对子集的修改，就是对原集合的修改
System.out.println(list2);//[1,2,30,40,50,60,7,8,9]
//批量删除一组元素，30-60
list2.subList(2, 6).clear();
System.out.println(list2);//[1,2,7,8,9]

LinkedList（链表）

LinkedList和ArrayList一样都实现了List接口，相比ArrayList而言，LinkedList执行增删操作的效率更高，这是由于LinkedList是由一个双向列表实现的，列表中的每个元素是一个节点，每个节点都持有对上一个和下一个元素的引用，删除操作可以不用移动其他元素的位置，只需让持有该元素引用的元素不在持有，转而持有下一个元素的引用即可。其操作方式和ArrayList相同。
因此在选择ArrayList和LinkedList时，需要按照具体需求而定，如果是需要快速的查找元素则选择ArrayList，如果需要快速大量的增删元素则选择LinkedList。

Map-java.util 提供的一种存储元素的形式

Map中的元素以一种Key-Value的方式存储，称为键值对，每一个key映射一个value，Map是Dictionary的替代者，主要的作用是快速的查找，就像现实生活中的字典一样。Map和List没有本质上的关系。Map主要的实现类有HashMap和TreeMap，这里主要介绍常用的HashMap。
HashMap 散列表
1.构造方法
HashMap提供了两种构造方法，带参和不带参构造，和其他集合或者队列一样，带参构造依靠传入一个Map来实现初始化或者复制操作

Map<String, Integer> map1 = new HashMap<String, Integer>();
Map<String, Integer> map2 = new HashMap<String, Integer>(map1);

2.V put(K k, V v) 将给定的key-value对存入到Map中，Map要求key不可以重复，如果put的键值对的key不存在与Map中，则返回一个null，若是key已存在，则相当于替换value操作，添加新value，将原来的value返回

map1.put("语文", 98);map1.put("数学", 90);
map1.put("外语", 98);map1.put("体育", 89);
System.out.println(map1);//{语文=98，数学=90，外语=98，体育=89}
Integer history= map1.put("历史", 92);
System.out.println(history);//null
Integer math = map1.put("数学", 100);
System.out.println(math);//90

3.V get(K k) 根据给定的key返回对应的value，若不存在给定的value，则返回null

englishScore = map1.get("外语");
System.out.println(englishScore);//98

4.V remove(K k) 根据给定的key删除当前Map中的key-value对，返回值为删除的value

Integer score = map1.remove("语文");
System.out.println(score);//98
System.out.println(map1);//{数学=100，外语=98，体育=89，历史", 92}

Map的遍历 遍历Map有三种方式，遍历key，遍历key-value对，遍历value（不常用）
1.Set<K> keySet() 该方法会将返回Map中所有的key并存入一个Set集合，由于Map中的key不允许重复，而Set集合的特性便是不可重复，所以用Set接收

Set<String> keySet = map1.keySet();
for(String key : keySet){
    System.out.println("key:"+key);//key:体育key:数学key:语文key:外语
}

2.Set<Entry> entrySet 遍历每一组键值对，Entry是Map接口的一个内部接口，每一组键值对都可以通过一个Entry实例来表示，Entry也支持泛型参数，它有两个内部方法，K getKey()和 V getValue(),可以将一个Entry实例的key和value返回。entrySet方法就是将Map中的每一组键值对通过Entry实例返回为一个Set集合，由于Map中键值对是不可重复的，所以用Set集合来接收

Set<Entry<String, Integer>>  entrySet= map1.entrySet();
for(Entry<String, Integer> entry: entrySet){
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("key:"+key);//key:体育key:数学key:语文key:外语
    System.out.println("value:"+value);
    //value:99value:97value:98value90
}

3.Collection values() 返回Map中所有的value

Collection<Integer> c = map1.values();
for(Integer value : c){
    System.out.println("value:"+value);//value:99value:97value:98value90
}

Queue-队列 Collection接口的子接口

Queue是一种将元素赋予优先级的数据结构，存取元素必须遵循FIFO（First in First out）先进先出的原则，这种结构类似于排队，先来后到，先offer的元素会排在第一位，取出元素时也从第一个开始。我们Windows系统的进程列表就是一个队列，先创建的进程会排在前面。
由于队列增删元素必须从队首开始，所以为了提高增删的效率，我们一般使用链表LinkedList来实现Queue接口
1.boolean offer<E> 添加元素，添加成功返回true

Queue<String> queue = new LinkedList<String>();
queue.offer("one");queue.offer("two");
queue.offer("three");queue.offer("four");
System.out.println(queue);//[one, two, three, four, five, six]

2.E poll() 出队操作，从队首获取一个元素，获取该元素后，该元素就从队列中删除了

String str = queue.poll();
System.out.println(str);//one
System.out.println(queue);//[two, three, four, five, six]

3.E peek() 引用队首元素，但是不做删除操作 peek（瞟一眼的意思，非常形象）

String str1 = queue.peek();
System.out.println(str1);//two
System.out.println(queue);//[two, three, four, five, six]

4.遍历一个队列

//for循环遍历
for(int i=queue.size();i>0;i--){
    String str = queue.poll();
    System.out.println(str);
}
//while循环遍历
while(queue.size()>0){
    String str = queue.poll();
    System.out.println(str);
}
System.out.println("遍历结束："+queue.size());//0

Deque和Stack
Deque是一个双端队列，两端都可以进出栈，通常我们只从它的一端进行进出操作，而这样就形成了栈Stack，栈就像一个弹夹一样，要遵循现进后出的原则，或者后进先出。而通常我们利用这一特征来实现后退功能，比如Windows的文件管理系统就是典型的栈。
1.void push(E e) 进栈操作

Deque<String> stack = new LinkedList<String>();
stack.push("one");stack.push("two");
stack.push("three");stack.push("four");
System.out.println(stack);//[four, three, two, one]

2.void pop(E e) 出栈操作

while(stack.size()>0){
    String str = stack.pop();
    System.out.println(str);//four three two one
}
System.out.println(stack.size());//0