JAVA 中的Collection FrameWork

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

1. 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能
2. 实现了RandmoAccess接口，即提供了随机访问功能
3. 实现了Cloneable接口，即覆盖了函数clone()，能被克隆
4. 实现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);

遍历方式

1. 通过迭代器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总结：

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

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

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

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

Set

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

HashSet

1. 集合中的元素必须是确定的
2. 集合中的元素互不相同
3. 集合中的元素没有先后之分 不得进行排序操作

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

1. 基于散列表的实现
2. 插入和查询“键值对”的开销是固定的
3. 通过构造器设置容量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

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

TreeMap

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

WeakHashMap

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

IdentifyHashMap

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