Collection FrameWork

Collection

层次结构中的根接口

Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的

常用子接口 List,Set,Queue

List

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组

Collections.sort() 排序数组 Collections.reverse()实现逆排序

List接口的常用子类有Vector,ArrayList,LinkedList

Vector：

基于数组（Array）的List

1.封装了数组所不具备的一些功能，性能也不可能超越数组 2.线程同步【多个线程对其读写会抛出异常】

Vector<Object> vector = new Vector<Object>(); vector.add(1);//整型 vector.add(0.3);//浮点型 vector.add("hello");//字符型 vector.add(Boolean.FALSE);//布尔型 System.out.println("Vector:"+vector); System.out.println("Size:" + vector.size()); vector.remove(1);//删除index处元素 System.out.println("Vector after remove:"+vector); vector.remove(vector.lastElement());//删除最后一个节点 vector.set(1,"world"); System.out.println("Vector after set:"+vector);

ArrayList

继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能实现了RandmoAccess接口，即提供了随机访问功能实现了Cloneable接口，即覆盖了函数clone()，能被克隆实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输

Vector和ArrayList用法均相同

不同点是 ArrayList允许多个线程读写

ArrayList<Double> arraylist = new ArrayList<Double>(); arraylist.add(1.0); arraylist.add(4.0); arraylist.add(5.0); arraylist.add(2.3); System.out.println("单纯的add表示从结尾加入元素：" + arraylist); System.out.println("size()能求出所含元素的个数：" + arraylist.size()); arraylist.remove(1); System.out.println("remove(1)表示删去第1个元素，由于计数从0开始，也就是4这个元素：" + arraylist); arraylist.remove(arraylist.size() - 1); System.out.println("删去最后一个元素的arraylist为：" + arraylist); arraylist.add(0, 1.8888); System.out.println("在第0个位置加入1.8888这个元素：" + arraylist); arraylist.set(0, 9.0); System.out.println("把第0个位置这个元素改为a：" + arraylist); Collections.sort(arraylist); System.out.println("如果arraylist不是抽象类型，则支持排序" + arraylist);

遍历方式

通过迭代器Iterator遍历 Double value = null; Iterator iterator = arraylist.iterator(); while (iterator.hasNext()){ value = (Double) iterator.next(); System.out.println(value); }

2.随机访问，通过索引值去遍历

for (int i=0;i<arraylist.size();i++){ System.out.println(arraylist.get(i)); }

3.foreach循环遍历

for (Double d:arraylist){ System.out.println(d); }

遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低

LinkedList

LinkedList不同于前面两种List，它不是基于数组的，而是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.

它每一个节点（Node）都包含两方面的内容： 1.节点本身的数据（data）； 2.下一个节点的信息（nextNode）。

所以当对LinkedList做添加，删除动作的时候就不用像基于数组的ArrayList一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了，这是LinkedList的优势。

LinkedList<Object> linkedList = new LinkedList<Object>(); //添加元素 linkedList.add("hello"); linkedList.add(111); linkedList.add(100.2200); linkedList.add(1,"world"); System.out.println(linkedList); System.out.println(linkedList.getFirst());//取首元素 System.out.println(linkedList.getLast());//取尾元素 List<Object> list = linkedList.subList(0,2);//从链表生成子表 System.out.println(list); //把链表当初栈或者队列来处理 linkedList.addFirst("first"); linkedList.addLast("last"); System.out.println(linkedList); //删除元素 linkedList.remove(linkedList.size()-1); linkedList.pop(); linkedList.removeFirst(); linkedList.removeLast();

Stack

Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法

Stack stack = new Stack(); // 创建堆栈对象 System.out.println("11111, absdder, 29999.3 三个元素入栈"); stack.push(new Integer(11111)); //向 栈中 压入整数 11111 printStack(stack); //显示栈中的所有元素 stack.push("absdder"); //向 栈中 压入 printStack(stack); //显示栈中的所有元素 stack.push(new Double(29999.3)); //向 栈中 压入 printStack(stack); //显示栈中的所有元素 String s = new String("absdder"); System.out.println("元素absdder在堆栈的位置"+stack.search(s)); System.out.println("元素11111在堆栈的位置"+stack.search(11111)); System.out.println("11111, absdder, 29999.3 三个元素出栈"); //弹出 栈顶元素 System.out.println("元素"+stack.pop()+"出栈"); printStack(stack); //显示栈中的所有元素 System.out.println("元素"+stack.pop()+"出栈"); printStack(stack); //显示栈中的所有元素 System.out.println("元素"+stack.pop()+"出栈"); printStack(stack); //显示栈中的所有元素 private static void printStack(Stack<Integer> stack ){ if (stack.empty()) System.out.println("堆栈是空的，没有元素"); else { System.out.print("堆栈中的元素："); Enumeration items = stack.elements(); // 得到 stack 中的枚举对象 while (items.hasMoreElements()) //显示枚举（stack ） 中的所有元素 System.out.print(items.nextElement()+" "); } System.out.println(); //换行 }

List总结：

所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]

所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]

所有的List中可以有null元素，例如[ tom,null,1 ]

基于Array的List（Vector，ArrayList）适合查询，而LinkedList 适合添加，删除操作

Set

Set是一种不包含重复的元素的无序 Collection。

HashSet

集合中的元素必须是确定的集合中的元素互不相同集合中的元素没有先后之分 不得进行排序操作 HashSet<Object> hashset = new HashSet<Object>(); hashset.add(1); hashset.add(1); hashset.add(5); hashset.add(2.3); System.out.println("单纯的add表示从结尾加入元素：" + hashset); System.out.println("size()能求出所含元素的个数：" + hashset.size()); hashset.remove(1); System.out.println("remove(1)表示删去'1'这个元素：" + hashset); hashset.remove("asd"); System.out.println("如果没有'asd'这个元素则remove什么都不做：" + hashset); hashset.add(1.8888); System.out.println("加入1.8888这个元素：" + hashset);

Map

HashMap

基于散列表的实现插入和查询“键值对”的开销是固定的通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。 HashMap<String,Object> hashMap = new HashMap<String, Object>(); hashMap.put("name","heqianqian"); hashMap.put("age",22); hashMap.put("educated",false); //1.entry遍历 for (Map.Entry<String, Object>entryMap:hashMap.entrySet()){ System.out.println("key="+entryMap.getKey()+" value="+entryMap.getValue()); } //2.foreach遍历keys或values for (String key:hashMap.keySet()){ System.out.println("key: "+key+" value="+hashMap.get(key)); } // for (Object value:hashMap.values()){ // System.out.println("value: "+value); // } //3.使用Iterator遍历 //3.1 使用泛型 Iterator<Map.Entry<String,Object>> iterator1=hashMap.entrySet().iterator(); while (iterator1.hasNext()){ Map.Entry<String,Object> entry = iterator1.next(); System.out.println("key="+entry.getKey()+" value="+entry.getValue()); } //3.1 不使用泛型 Map map = new HashMap(); Iterator entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = (Map.Entry) entries.next(); Integer key = (Integer)entry.getKey(); Integer value = (Integer)entry.getValue(); System.out.println("Key = " + key + ", Value = " + value); } //4.通过键找值遍历（效率低） Map<Integer, Integer> map1 = new HashMap<Integer, Integer>(); for (Integer key : map1.keySet()) { Integer value = map1.get(key); System.out.println("Key = " + key + ", Value = " + value); }

LinkedHashMap

取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序,只比HashMap慢一点迭代访问时更快，因为它使用链表维护内部次序。

TreeMap

基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。

WeakHashMap

弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。

IdentifyHashMap

使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。