import java.util.ArrayList;import java.util.HashSet;import java.util.Iterator;import java.util.LinkedHashSet;import java.util.List;import java.util.Set;import java.util.TreeSet;

/** * 演示各种Set的使用 * 存入Set的每个元素必须是唯一的，因为Set不保存重复元素。*/public class TestSet {

    /**     * 初始化Set的元素     * @param set*/    public static void init(Set set){        if (set != null){            set.add("aaa");            set.add("ccc");            set.add("bbb");            set.add("eee");            set.add("ddd");        }    }    /**     * 输出set的元素     * @param set*/    public static void output(Set set){        if (set != null){            //使用迭代器遍历Set，也只有这一种方法            Iterator it = set.iterator();            while (it.hasNext()){                System.out.print(it.next() + " ");            }        }        System.out.println();    }    /**     * 使用HashSet*/    public static void testHashSet(){        Set mySet = new HashSet();        init(mySet);        System.out.println("使用HashSet: ");        output(mySet);    }    /**     * 使用TreeSet*/    public static void testTreeSet(){        Set mySet = new TreeSet();        init(mySet);        System.out.println("使用TreeSet: ");        output(mySet);    }    /**     * 使用LinkedHashSet*/    public static void testLinkedHashSet(){        Set mySet = new LinkedHashSet();        init(mySet);        System.out.println("使用LinkedHashSet: ");        output(mySet);    }    public static void main(String[] args) {        TestSet.testHashSet();        TestSet.testTreeSet();        TestSet.testLinkedHashSet();

        Set mySet = new HashSet();        init(mySet);        //Set不允许元素重复        mySet.add("aaa");        mySet.add("bbb");        System.out.println("为mySet加入aaa, bbb元素后: ");        output(mySet);        //删除元素        mySet.remove("aaa");        System.out.println("mySet删除aaa元素后: ");        output(mySet);        //增加另外一个集合中的所有元素        List list = new ArrayList();        list.add("aaa");        list.add("aaa");        list.add("fff");        mySet.addAll(list);        System.out.println("mySet添加另外一个集合的所有元素后: ");        output(mySet);        //删除除了另外一个集合包含的以外的所有元素        mySet.retainAll(list);        System.out.println("mySet删除除了另外一个集合包含的以外的所有元素后: ");        output(mySet);        //删除另外一个集合包含的所有元素        mySet.removeAll(list);        System.out.println("mySet删除另外一个集合包含的所有元素后: ");        output(mySet);        //获取Set中元素的个数        System.out.println("mySet中当前元素的个数: " + mySet.size());        //判断Set中元素个数是否为0        System.out.println("mySet中当前元素为0？  " + mySet.isEmpty());

        /**         * （1）Set不允许重复元素，因此加入Set的Object必须定义equals()方法以确保对象的唯一性。         * （2）HashSet采用散列函数对元素进行排序，是专门为快速查询而设计的。存入HashSet的对象必须定义hashCode()。         * （3）TreeSet采用红黑树的数据结构进行排序元素，能保证元素的次序，使用它可以从Set中提取有序的序列。         * 需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。         * （4）LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的插入的次序，在使用迭代器遍历Set时，结果会按元素插入的次序显示。*/    }}

import java.util.ArrayList;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.ListIterator;import java.util.Stack;import java.util.Vector;

/** * 演示各种List的使用 * List是能维护元素的次序，它允许元素重复*/public class TestList {

    /**     * 初始化一个List     * @param list*/    public static void init(List list){        if(list != null){            list.add("aaa");            list.add("ccc");            list.add("bbb");            list.add("eee");            list.add("ddd");        }    }    /**     * 输出List的内容     * @param list*/    public static void output(List list){        if (list != null){            //根据列表下标遍历，使用list.size()获取列表中元素的个数            for (int i=0; i<list.size(); i++){                System.out.print(list.get(i) + "  ");            }            //或者用迭代器遍历            Iterator it  = list.iterator();            Object value = null;            while (it.hasNext()){                value = it.next();                //System.out.println(value);            }        }        System.out.println();    }    /**     * 使用ArrayList*/    public static void testArrayList(){        List list = new ArrayList();        init(list);        System.out.println("使用ArrayList: ");        output(list);    }    /**     * 使用Vector*/    public static void testVector(){        List list = new Vector();        init(list);        System.out.println("使用Vector: ");        output(list);    }    /**     * 使用LinkedList*/    public static void testLinkedList(){        List list = new LinkedList();        init(list);        System.out.println("使用LinkedList: ");        output(list);    }

    public static void main(String[] args) {        TestList.testArrayList();        TestList.testVector();        TestList.testLinkedList();

        List list = new ArrayList();        init(list);        //List支持元素重复        list.add("aaa");        list.add("bbb");        System.out.println("插入元素aaa, bbb后：");        output(list);        //指定元素插入的位置        list.add(1, "fff");        System.out.println("在下标为1处插入fff后：");        output(list);        List list2 = new ArrayList();        list2.add("ggg");        list2.add("hhh");        //将另一列表中的元素插入到列表中        list.addAll(list2);        System.out.println("添加list2的元素后：");        output(list);

        //判断列表是否包含某一元素//通过元素的equals方法，判断元素是否相等        System.out.println("list包含aaa? " + list.contains("aaa"));        //判断列表中是否包含了另外一个列表中的所有元素。        System.out.println("list包含list2中的所有元素? " + list.containsAll(list2));        //定位一个元素在列表中最先出现的位置        System.out.println("aaa在list中第一次出现的位置: " + list.indexOf("aaa"));        //定位一个元素在列表中最后出现的位置        System.out.println("aaa在list中最后一次出现的位置: " + list.lastIndexOf("aaa"));

        //更新列表中某个位置的元素值        list.set(2, "xxx");        System.out.println("更新位置为2的元素为xxx后：");        output(list);        //删除列表中的某个元素，只删除第一次出现的那个        list.remove("aaa");        System.out.println("删除元素aaa后：");        output(list);        //删除列表中指定位置的元素        list.remove(1);        System.out.println("删除下标为1的元素后：");        output(list);        //删除列表中的其他元素，只保留另一个列表中包含的元素        list.retainAll(list2);        System.out.println("删除除list2包含的以外的元素后：");        output(list);        //删除列表中在另一列表中也包含了的元素        list.removeAll(list2);        System.out.println("删除list2包含的元素后：");        output(list);

        //清空列表        list.clear();        //判断列表中是否有数据        System.out.println("清空List后，list为空么?  " + list.isEmpty());        init(list);        //用列表中的某些元素构造一个新的列表        list2 = list.subList(1,3);        System.out.println("用list的第1个到第3个元素构造一个新的List:");        output(list2);

        //用List特有的遍历器ListIterator遍历列表//与普通的Iterator不用，它允许两个方向遍历列表        ListIterator listIt = list.listIterator();        System.out.println("正向遍历列表");        while (listIt.hasNext()){            System.out.print(listIt.next());        }         System.out.println();        System.out.println("反向遍历列表");        while (listIt.hasPrevious()){            System.out.print(listIt.previous());        }         System.out.println();        //也可以使用ListIterator从List中间插入和删除元素，//只能在遍历器当前位置添加和删除。        listIt.add("newadd");        System.out.println("用ListIterator往列表中添加元素newadd后: ");        output(list);        listIt.next();        listIt.remove();//remove方法移除next方法最近返回的元素。        System.out.println("用ListIterator删除列表中元素后: ");        output(list);

        //LinkedList自定义的方法        LinkedList linklist = new LinkedList();        init(linklist);        //添加元素到列表头        linklist.addFirst("fff");        System.out.println("把fff放到列表头后：");        output(linklist);        //添加元素到列表尾        linklist.addLast("eee");        System.out.println("把eee放到列表尾后：");        output(linklist);        //获取表头元素        System.out.println("列表头元素：" + linklist.getFirst());        //获取表尾元素        System.out.println("列表尾元素：" + linklist.getLast());        //删除列表头的元素        linklist.removeFirst();        System.out.println("删除列表头元素后：");        output(linklist);        //删除列表尾的元素        linklist.removeLast();        System.out.println("删除列表尾元素后：");        output(linklist);

        //堆栈Stack类，它继承自Stack类        Stack myStack =  new Stack();        //插入元素，是插入到尾部        myStack.push("aaa");        myStack.push("bbb");        myStack.push("ccc");        myStack.push("ddd");        myStack.push("aaa");        myStack.push("ddd");        System.out.println("堆栈中的元素是: ");        output(myStack);        System.out.println("堆栈尾部元素: " + myStack.peek());        System.out.println("弹出堆栈尾部元素: " + myStack.pop());

        /**         * （1）ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能含有“空隙”。         * 当数组大小不满足时会增加存储能力，将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行拷贝，移动，代价比较高。因此，它适合随即查找和遍历，不适合插入合删除。         * （2）Vector与ArrayList一样，也是通过数组实现的。不同的是它支持线程的同步，         * 即一时刻只有一个线程能够写Vector，避免多线程同时写引起的不一致性。但实现同步需要很高的花费，         * 因此，访问它比访问ArrayList慢。         * （3）LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随即访问和遍历速度比较慢。另外，它还提供了List没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。         * （4）因为ArrayList和Vector都是用数组实现的，所以，在添加和插入时，最好从表尾操作，而不要从中间或者表头开始，以避免数组移动引起的开销！         * （5）可以为每个List生成ListIterator，支持双向遍历List，而且能够在ListIterator位置插入和删除元素。         * （6）堆栈类继承Vector，它总是对列表的尾部数据进行操作，采用了先进后出的策略，自定义了插入、查看和弹出元素三个方法。*/    }}

import java.util.HashMap;import java.util.Hashtable;import java.util.Iterator;import java.util.LinkedHashMap;import java.util.Map;import java.util.TreeMap;

/** * 演示各个Map的实现类*/public class TestMap {

    /**     * 初始化一个Map     * @param map*/    public static void init(Map map){        if (map != null){            String key = null;            for (int i=5; i>0; i--){                key = new Integer(i).toString() + ".0";                map.put(key, key.toString());                //Map中的键是不重复的，如果插入两个键值一样的记录，//那么后插入的记录会覆盖先插入的记录                map.put(key, key.toString() + "0");            }        }    }    /**     * 输出一个Map     * @param map*/    public static void output(Map map){        if (map != null){            Object key = null;            Object value = null;            //使用迭代器遍历Map的键，根据键取值            Iterator it = map.keySet().iterator();            while (it.hasNext()){                key = it.next();                value = map.get(key);                System.out.println("key: " + key + "; value: " + value );            }            //或者使用迭代器遍历Map的记录Map.Entry            Map.Entry entry = null;            it = map.entrySet().iterator();            while (it.hasNext()){                //一个Map.Entry代表一条记录                entry = (Map.Entry)it.next();                //通过entry可以获得记录的键和值//System.out.println("key: " + entry.getKey() + "; value: " + entry.getValue());            }        }    }    /**     * 判断map是否包含某个键     * @param map     * @param key     * @return*/    public static boolean containsKey(Map map, Object key){        if (map != null){            return map.containsKey(key);        }        return false;    }    /**     * 判断map是否包含某个值     * @param map     * @param value     * @return*/    public static boolean containsValue(Map map, Object value){        if (map != null){            return map.containsValue(value);        }        return false;    }    /**     * 演示HashMap*/    public static void testHashMap(){        Map myMap = new HashMap();        init(myMap);        //HashMap的键可以为null        myMap.put(null,"ddd");        //HashMap的值可以为null        myMap.put("aaa", null);        output(myMap);    }    /**     * 演示Hashtable*/    public static void testHashtable(){        Map myMap = new Hashtable();        init(myMap);        //Hashtable的键不能为null//myMap.put(null,"ddd");//Hashtable的值不能为null//myMap.put("aaa", null);        output(myMap);    }    /**     * 演示LinkedHashMap*/    public static void testLinkedHashMap(){        Map myMap = new LinkedHashMap();        init(myMap);        //LinkedHashMap的键可以为null        myMap.put(null,"ddd");        //LinkedHashMap的值可以为null        myMap.put("aaa", null);        output(myMap);    }    /**     * 演示TreeMap*/    public static void testTreeMap(){        Map myMap = new TreeMap();        init(myMap);        //TreeMap的键不能为null//myMap.put(null,"ddd");//TreeMap的值不能为null//myMap.put("aaa", null);        output(myMap);    }

    public static void main(String[] args) {        System.out.println("采用HashMap");        TestMap.testHashMap();        System.out.println("采用Hashtable");        TestMap.testHashtable();        System.out.println("采用LinkedHashMap");        TestMap.testLinkedHashMap();        System.out.println("采用TreeMap");        TestMap.testTreeMap();

        Map myMap = new HashMap();        TestMap.init(myMap);        System.out.println("新初始化一个Map: myMap");        TestMap.output(myMap);        //清空Map        myMap.clear();        System.out.println("将myMap clear后，myMap空了么?  " + myMap.isEmpty());        TestMap.output(myMap);        myMap.put("aaa", "aaaa");        myMap.put("bbb", "bbbb");        //判断Map是否包含某键或者某值        System.out.println("myMap包含键aaa?  "+ TestMap.containsKey(myMap, "aaa"));        System.out.println("myMap包含值aaaa?  "+ TestMap.containsValue(myMap, "aaaa"));        //根据键删除Map中的记录        myMap.remove("aaa");        System.out.println("删除键aaa后，myMap包含键aaa?  "+ TestMap.containsKey(myMap, "aaa"));        //获取Map的记录数        System.out.println("myMap包含的记录数:  " + myMap.size());    }

}