第07章 集合

/*****************
***第七章 集合
*******知识点:
**************1.Collection和Iterator接口
******************1.1 Collection接口简介
******************1.2 Iterator接口简介
******************1.3 Map接口简介
**************2.Set接口
******************2.1 HashSet类
******************2.2 TreeSet类
******************2.3 EnumSet类
**************3.List接口
******************3.1 ArrayList类
******************3.2 LinkedList类
******************3.3 Vector类
******************3.4 Stack类
**************4.Queue接口
******************4.1 PriorityQueue类
**************5.Map接口
******************5.1 HashMap类
******************5.2 Hashtable类
******************5.3 SortedMap接口
******************5.4 TreeMap类
******************5.5 WeakHashMap类
******************5.6 IdentityHashMap类
******************5.7 EnumMap类
**************6.集合操作工具类
******************6.1 排序操作
******************6.2 查找，替换操作
******************6.3 同步控制
******************6.4 总结
*/
import java.util.*;

/*
*  演示需用类
*/
class Person implements Comparable{
    private int id;
    private String name;
    Person(){
        this.id = 0;
        this.name = "无名氏";
    }
    
    Person(int id, String name){
        this.id = id;
        this.name = name;
    }
    
    public String toString(){
        return "id:" + id + ",name:" +name;
    }
    
    //重写接口中的方法  用于比较
    public int compareTo(Object o){
        Person p = (Person) o;
        int result = id < p.id ? 1 : (id == p.id ? 0 : -1); //降序
        //int result = id > p.id ? 1 : (id == p.id ? 0 : -1); //降序
        if(result == 0){
            result =  name.compareTo(p.name);//注意区别：这里调用String的compareTo方法
        }
        return result;
    }
}

/*
*  演示枚举类
*/
enum MyEnum{
    BLACK,WIHTE,RED,BLUE,GREEN
}

public class test7{
    public static void main(String[] args){
        showDemo("1.Collection和Iterator接口");
        demoCollectionAndIterator(); //1.Collection和Iterator接口
        
        showDemo("2.Set接口");
        demoSet(); //2.Set接口
        
        showDemo("3.List接口");
        demoList(); //3.List接口
        
        showDemo("4.Queue接口");
        demoQueue(); //4.Queue接口
        
        showDemo("5.Map接口");
        demoMap(); //5.Map接口
        
        showDemo("6.集合操作工具类");
        demoTools(); //6.集合操作工具类
    }
    
    /**1.Collection和Iterator接口**/
    public static void demoCollectionAndIterator(){
        /**1.1 Collection接口简介**/
        //Collection接口是集合父接口之一  实现子接口有 Set接口、List接口
        //其中Set接口：不能包含重复的元素
        //List接口：一个有序的集合
        
        /**1.2 Iterator接口简介**/
        //Iterator接口是迭代器
        //用于遍历集合中的元素
        
        /**1.3 Map接口简介**/
        //Map接口是集合父接口之一   实现子类有SortMap、HashMap
        //包含了key-value  俗称键值对 其中  key不能重复
    }
    
    /**2.Set接口**/
    public static void demoSet(){
        //Set接口：不能包含重复的元素、允许包含值为null的元素但只能有一个
        
        /**2.1 HashSet类**/
        //HashSet类按照哈希算法来存取集合中的对象，存取速度比较快
        System.out.println("演示HashSet类=======");
        HashSet h_HashSet = new HashSet();
        Person p1 = new Person();
        h_HashSet.add("1");//字符串
        h_HashSet.add('2');//字符
        h_HashSet.add(3);//整型
        h_HashSet.add(true);//布尔型
        h_HashSet.add(1.0);
        h_HashSet.add(new Integer(3));//不会被添加  因为重复了
        h_HashSet.add(p1);//对象
        System.out.println("集合长度为：" + h_HashSet.size());//获取集合长度
        
        Iterator i_Iterator = h_HashSet.iterator();//得到遍历的迭代器
        while(i_Iterator.hasNext()){
            Object o = (Object)(i_Iterator.next());//通过迭代器返回元素  注意返回为Object类型
            System.out.println("集合元素：" + o);//需注意如果是自定义的类型  需要重写toString方法
        }
        
        System.out.println("判断集合是否为空：" + h_HashSet.isEmpty());//判断集合是否为空
        h_HashSet.remove(3);//删除元素
        h_HashSet.remove((float)1.0);//不能删除元素  类型不匹配
        
        System.out.println("集合长度为：" + h_HashSet.size());//获取集合长度
        i_Iterator  = h_HashSet.iterator();
        while(i_Iterator.hasNext()){
            Object o = (Object)(i_Iterator.next());//通过迭代器返回元素  注意返回为Object类型
            System.out.println("集合元素：" + o);
        }
        
        System.out.println(h_HashSet);//将集合打印出来
        
        /**2.2 TreeSet类**/
        //TreeSet类是一个有序集合,元素将按照升序排列,缺省是按照自然排序进行排列。
        //所以该集合中的元素要实现Comparable接口或者有一个自定义的比较器
        //另外集合中的元素存储顺序跟加入的顺序无关
        System.out.println("演示TreeSet类=======");
        TreeSet t_TreeSet1 = new TreeSet();
        t_TreeSet1.add("aaaa");
        t_TreeSet1.add("ccc");
        t_TreeSet1.add("ac");
        t_TreeSet1.add("bc");
        Iterator i_Iterator_TreeSet = t_TreeSet1.iterator();
        while(i_Iterator_TreeSet.hasNext()){
            Object o =  i_Iterator_TreeSet.next();
            System.out.println("集合对象：" + o);//注意输出结果跟加入顺利对比  发现无关
        }
        
        System.out.println("集合中第一个对象:" + (Object)t_TreeSet1.first());//返回第一个元素
        System.out.println("集合中第一个对象:" + (Object)t_TreeSet1.last());//返回最后一个元素
        
        System.out.println("返回不小于acd的集合对象：" + (Object)t_TreeSet1.ceiling("acd"));
        //返回一个不小于acd的集合元素(非随机 就是一个且最接近的一个)
        
        Person p1_TreeSet = new Person();
        Person p2_TreeSet = new Person(0,"aaa");
        Person p3_TreeSet = new Person(1,"aaa");
        
        TreeSet t_TreeSet2 = new TreeSet();
        t_TreeSet2.add(p1_TreeSet);
        t_TreeSet2.add(p2_TreeSet);
        t_TreeSet2.add(p3_TreeSet);
        
        System.out.println("集合中所有对象:" + t_TreeSet2);
        
        
        /**2.3 EnumSet类**/
        //这个类是1.5开始有的
        //目前个人使用量几乎为零,很少使用
        //其使用方式和普通的Set没有区别，只是构造方法有一些特殊的而已
        //多种添加集合元素方式
        System.out.println("演示EnumSet类=======");
        
        //第一种创建一个指定类型的空集合 然后再添加元素
        EnumSet<MyEnum> e_EnumSet1 = EnumSet.noneOf(MyEnum.class);
        e_EnumSet1.add(MyEnum.BLACK);
        e_EnumSet1.add(MyEnum.RED);
        e_EnumSet1.add(MyEnum.BLUE);
        System.out.println("e_EnumSet集合中的对象：" + e_EnumSet1);
        
        //第二种创建一个指定类型的所有数据集合
        EnumSet<MyEnum> e_EnumSet2 = EnumSet.allOf(MyEnum.class);
        System.out.println("e_EnumSet集合中的对象：" + e_EnumSet2);
        
        //第三种创建一个指定类型的指定初始化数据的集合
        EnumSet<MyEnum> e_EnumSet3 = EnumSet.of(MyEnum.WIHTE,MyEnum.GREEN);
        System.out.println("e_EnumSet集合中的对象：" + e_EnumSet3);
        
        //第四种创建一个指定类型的指定数据范围的集合
        EnumSet<MyEnum> e_EnumSet4 = EnumSet.range(MyEnum.WIHTE,MyEnum.BLUE);//从WIHTE到BLUE 的所有元素
        System.out.println("e_EnumSet集合中的对象：" + e_EnumSet4);
        
        
        //总结：
        // 1.HashSet 速度快  且使用居多
        // 2.TreeSet 自动实现排序(需要为元素实现比较器) 
        // 3.EnumSet  枚举   然并卵  
        // 最后对时间效率有要求使用  HashSet   对排序有要求使用  TreeSet  EnumSet(忘了它吧)
    }
    
    /**3.List接口**/
    public static void demoList(){
        //List接口:一个有序的集合 对插入的顺序有序
        
        /**3.1 ArrayList类**/
        //1.基于数组实现的List类
        //2.查找和定位操作快
        //3.添加和删除操作慢
        //4.线程不安全
        System.out.println("演示ArrayList类=======");
        ArrayList a_ArrayList = new ArrayList();//默认10个长度  后面可以动态加载
        for(int i = 0; i < 10; i++){
            a_ArrayList.add(i); //加载元素
        }
        
        //使用foreach遍历集合
        for(Object j :a_ArrayList){
            System.out.println("元素：" + j);
        }
        
        //使用get方法遍历    
        for(int i= 0 ;i < 10 ; i++){
            System.out.println("元素：" + a_ArrayList.get(i));
        }    
        //推荐使用后者遍历    
        System.out.println(a_ArrayList);//将所有元素打印出来
        //更多方法使用详见API
        
        
        /**3.2 LinkedList类**/
        //1.基于链表实现的List类
        //2.查找和定位操作慢
        //3.添加和删除操作快
        //4.线程不安全
        //使用跟ArrayList相似  具体使用时查看API即可   需注意实现的方式采用的是链表
        System.out.println("演示LinkedList类=======");
        
        /**3.3 Vector类**/
        //1.基于数组实现的List类
        //2.线程安全
        //3.已经被ArrayList类取代得差不多了
        //使用跟ArrayList相似  具体使用时查看API即可  一般不会使用 毕竟ArrayList几乎可以取代它了无论是从执行效率还是功能上
        System.out.println("演示Vector类=======");
        
        /**3.3 Stack类**/
        //1.Vector类的子类
        //2.实现模拟栈操作
        System.out.println("演示Stack类=======");
        Stack s_Stack = new Stack();
        System.out.println("是否为空栈：" + s_Stack.isEmpty());
        for(int i = 0 ;i < 10; i++){
            s_Stack.push("元素" + i);//入栈
        }
        System.out.println("栈元素有：" + s_Stack);
        String str_Stack = "元素3";
        System.out.println("元素3在第：" + (s_Stack.search((Object) str_Stack)) + "位上");//返回在堆栈中的位置  以1开始
        
        System.out.println("栈顶元素是：" + s_Stack.peek());
        
        //删除前先判断是否为空栈
        if(!s_Stack.isEmpty()){
            System.out.println("移除栈顶元素是：" + s_Stack.pop());
        }
        System.out.println("栈元素有：" + s_Stack);
        
        //总结：
        //1.如果需要遍历List集合元素，对应ArrayList、Vector集合，则应该使用随机访问方法（get）来遍历集合元素，
        //  这样性能更好。对应LinkedList集合，则应采用迭代器（Iterator）来遍历集合元素。
        //2.如果需要经常执行插入、删除操作来改变集合大小，则应该使用LinkedList集合，而不是ArrayList
        //3.如果需要查询和定位操作比较频繁时，则应该使用ArrayList集合，而不是LinkedList
        //4.如果多条线程需要同时访问List集合中的元素，可以考虑使用Vector这个同步实现。
        //  或者使用ArrayList然后再手动设置加锁(推荐后者)
    }
    
    /**4.Queue接口**/
    public static void demoQueue(){
        //Queue接口：优先队列集合
        //本质上就是一个最小堆
        //很少用到  了解即可
        
        /**4.1 PriorityQueue类**/
    }
    
    /**5.Map接口**/
    public static void demoMap(){
        //Map接口：实现键值对的接口
        
        /**5.1 HashMap类**/
        System.out.println("演示HashMap类=======");
        //不同步,故线程不安全
        //一键值 (键不同时，值可以相同  但键不能相同 可以为null)
         // 初始化随机种子
        Random r = new Random();
        // 新建HashMap
        HashMap map_HashMap = new HashMap();
        // 添加操作
        map_HashMap.put("one", r.nextInt(10));
        map_HashMap.put("two", r.nextInt(10));
        map_HashMap.put("two", r.nextInt(10));//不会被添加因为存在该键了
        map_HashMap.put(null, null);//可以为空
        map_HashMap.put("two1", r.nextInt(10));
        map_HashMap.put("three", r.nextInt(10));
        // 打印出map
        System.out.println("map_HashMap:"+map_HashMap );
        
        // 通过entrySet-Iterator遍历key-value
        System.out.println("通过entrySet-Iterator遍历key-value");
        Iterator iter_HashMap1 = map_HashMap.entrySet().iterator();
        while(iter_HashMap1.hasNext()) {
            Map.Entry entry = (Map.Entry)iter_HashMap1.next();
            System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
        }
        
        //通过keyset - Iterator遍历key-value
        System.out.println("通过keyset - Iterator遍历key-value");
        Iterator iter_HashMap2 = map_HashMap.keySet().iterator();
        while (iter_HashMap2.hasNext()){
            Object key = iter_HashMap2.next();
            Object val = map_HashMap.get(key);
            System.out.println("next : "+ key +" - "+ val);
        }        
        // HashMap的键值对个数        
        System.out.println("size:"+map_HashMap.size());
        // containsKey(Object key) :是否包含键key
        System.out.println("contains key two : "+map_HashMap.containsKey("two"));
        System.out.println("contains key five : "+map_HashMap.containsKey("five"));
        // containsValue(Object value) :是否包含值value
        System.out.println("contains value 0 : "+map_HashMap.containsValue(new Integer(0)));
        // remove(Object key) ： 删除键key对应的键值对
        map_HashMap.remove("three");
        System.out.println("map:"+map_HashMap );
        // clear() ： 清空HashMap
        map_HashMap.clear();
        // isEmpty() : HashMap是否为空
        System.out.println((map_HashMap.isEmpty()?"map_HashMap is empty":"map_HashMap is not empty") );
        
        
        //两种遍历方式  推荐entrySet-Iterator这种方法  效率要高点
        //对于keySet其实是遍历了2次，一次是转为iterator，一次就从hashmap中取出key所对于的value。
        //而entryset只是遍历了1次，他把key和value都放到了entry中，所以就快了。
        
        /**5.2 Hashtable类**/
        //用法跟HashMap 差不多
        //区别：
        //1.Hashtable 是同步的 即线程安全 在多线程下可以直接使用  而HashMap则要手动设置同步
        //2.Hashtable 不管key  或者value 均不允许出现null
        //3.继承不同   Hashtable ——Dictionary    而HashMap——AbstractMap 
        //4.初始化大小和扩容方式不同
        //5.历史遗留问题导致Hashtable 还使用Enumeration方式遍历元素
        //最后推荐使用HashMap
        
        /**5.3 SortedMap接口**/
        // 保证按照键的升序排列的映射，可以按照键的自然顺序（参见 Comparable 接口）进行排序， 
        //或者通过创建有序映射时提供的比较器进行排序
        //所以所有的键必须是可以比较的
        
        /**5.4 TreeMap类**/
        //TreeMap是SortedMap接口的基于红黑树的实现
        //此类保证了映射按照升序顺序排列关键字， 根据使用的构造方法不同，可能会按照键的类的自然顺序进行排序
        //注意1：此实现不是同步的。不是线程安全的。
        //注意2：TreeMap是用键来进行升序顺序来排序的。通过Comparable 或 Comparator来排序。
        //注意3：由所有此类的“collection 视图方法”所返回的迭代器都是快速失败的。
        //注意4：和HashMap一样，如果插入重复的元素，后面的元素会覆盖前面的。
        //注意5: 键不可以为null,但是值可以为null
        System.out.println("演示TreeMap类=======");
        Random r_TreeMap = new Random();
        TreeMap t_TreeMap = new TreeMap();
        Person p_TreeMap1 = new Person();
        Person p_TreeMap2 = new Person(1,"aaaa");
        Person p_TreeMap3 = new Person(2,"aaaa");
        Person p_TreeMap4 = new Person(0,"aaaa");
        t_TreeMap.put(r_TreeMap.nextInt(10),p_TreeMap1);
        t_TreeMap.put(r_TreeMap.nextInt(10),p_TreeMap2);
        t_TreeMap.put(r_TreeMap.nextInt(10),p_TreeMap3);
        t_TreeMap.put(r_TreeMap.nextInt(10),p_TreeMap4);
        t_TreeMap.put(r_TreeMap.nextInt(10),null); //键不可以为null 值可以
        System.out.println("集合中元素有：" + t_TreeMap);
        
        for(Object o:t_TreeMap.values()){
            System.out.println("元素值：" + o);
        }
        //判断是否存在键
        System.out.println("是否包含键值为3的键:" + t_TreeMap.containsKey(new Integer(3)));
        
        //判断是否存在值
        System.out.println("是否包含p_TreeMap1对象:" + t_TreeMap.containsValue((Object)p_TreeMap1));//是否存在p_TreeMap1
        System.out.println("是否包含:" + t_TreeMap.containsValue(new Person()));//重新new对象跟原有对象不一样
        
        //判断是否存在值
        System.out.println("是否包含new Person(4,1111)对象:" + t_TreeMap.containsValue(new Person(4,"1111")));
        
        
        /**5.5 WeakHashMap类**/
        //WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，
        //如果一个key不再被外部所引用，那么该key可以被GC回收。
        //一般很少用到
        //用法想见API  跟HashMap用法差不多
        
        /**5.6 IdentityHashMap类**/
        // IdentityHashMap类是一种允许key 的内容可以重复的集合类
        //一般很少用到
        //用法想见API  跟HashMap用法差不多
        
        /**5.7 EnumMap类**/
        //1. 使用EnumMap时，必须指定枚举类型。
        //2. key不能为null
        //3. EnumMap内部以数组实现，性能更好。
        System.out.println("演示EnumMap类=======");
        EnumMap e_EnumMap = new EnumMap(MyEnum.class);
        e_EnumMap.put(MyEnum.BLACK,"黑色");
        e_EnumMap.put(MyEnum.WIHTE,"白色");
        e_EnumMap.put(MyEnum.RED,"红色");
        System.out.println("集合对象有：" + e_EnumMap);
        Iterator i_EnumMap = e_EnumMap.entrySet().iterator();
        while(i_EnumMap.hasNext()){
            Map.Entry entry_EnumMap = (Map.Entry)i_EnumMap.next();
            System.out.println("对象——key:" + entry_EnumMap.getKey()+ ",value:"+entry_EnumMap.getValue());
        }
        
    }
    
    /**6.集合操作工具类**/
    public static void demoTools(){
        //Collections类是一个集合操作工具类
        /**6.1 排序操作**/
        Person  p_Collections1 = new Person(1,"黄");
        Person  p_Collections3 = new Person(3,"李");
        Person  p_Collections2 = new Person(2,"赵");
        Person  p_Collections4 = new Person(4,"钱");
        List l_Array = new ArrayList();
        l_Array.add(p_Collections1);
        l_Array.add(p_Collections2);
        l_Array.add(p_Collections3);
        l_Array.add(p_Collections4);
        
        System.out.println("集合对象：" + l_Array);
        //排序(升序)
        Collections.sort(l_Array);
        System.out.println("排序后，集合对象：" + l_Array);
        
        //反转(执行排序后再执行反转 相当于降序)
        Collections.reverse(l_Array);
        System.out.println("反转后，集合对象：" + l_Array);
        
        
        //混乱排序
        Collections.shuffle(l_Array);//每次结果可能不一样
        System.out.println("混乱排序后，集合对象：" + l_Array);
        
        /**6.2 查找，替换操作**/
        //查找  指定元素查找  返回索引
        System.out.println("查找str_Collections元素的位置:" + Collections.binarySearch(l_Array,p_Collections1,null));
        
        //交换  指定位置交换
        System.out.println("交换前集合对象：" + l_Array);
        Collections.swap(l_Array,1,2);
        System.out.println("交换后集合对象：" + l_Array);
        
        //替换  指定元素替换
        Person p_Collections5 = new Person(5,"王");
        System.out.println("替换前集合对象：" + l_Array);
        Collections.replaceAll(l_Array,p_Collections4,p_Collections5);
        System.out.println("替换后集合对象：" + l_Array);
        
        /**6.3 同步控制**/
        //使用该工具类的同步方法返回可同步的集合对象
        Collection c=Collections.synchronizedCollection(new ArrayList());
        List l=Collections.synchronizedList(new ArrayList());
        Set s=Collections.synchronizedSet(new HashSet());
        Map m=Collections.synchronizedMap(new HashMap());
        
        /**6.4 总结**/
        //1.Set类
            //1.1 如果希望按照元素插入集合的顺序进行提取元素，用LinkedHashSet，它的元素按添加的顺序存储
            //1.2 一般使用HashSet，因为它的效率比LinkedHashSet高
            //1.3 TreeSet（集合元素有排序关系）
        //2.List类
            //2.1 ArrayList使用数组实现的动态扩展容量的list  定位查找操作效率快,不同步
            //2.2 LinkedList链式实现的list,增加修改效率快,不同步
            //2.3 Vector 同步版的ArrayList,因为同步,故效率不如ArrayList
            //2.4 Stack继承Vector,模拟实现栈
        //3.Map类
            //3.1 键值对同List和Set不同
            //3.2 HashMap：效率高
            //3.3 TreeMap：排序性
        //4.Collections类
            //4.1 提供了许多静态的方法来管理集合
        //5.Arrays类 
           //5.1 提供了对数组排序，查找，比较，填充元素的各种静态方法。
        
    }
    
    
    /*
    *    抽取打印演示函数  用于打印演示功能提示
    */    
    public static void showDemo(String demoStr){
        System.out.println("演示:" + demoStr);
    }

}