Java语言基础集合

集合，有时也被称作容器（container），是对象的持有者，它们可以以有助于高效访问的形式来存储和组织对象。

1.Collection接口：集合的根接口。

　　Set：不包含重复元素的集合，不维护元素的顺序。加入Set的元素必须定义equals方法来确保对象的唯一性。它有3个实现类：HashSet、LinkedHashSet和TreeSet。

　　HashSet采用散列函数对元素进行排序，是为快速查询设计的。存入其中的元素要定义hashCode方法。TreeSet采用红黑树的数据结构进行元素排序。存入自定义类时，TreeSet需要维护元素的存储顺序，因此自定义类要实现Comparable接口并定义compareTo方法。LinkedSet内部使用散列加快查询速度，同时使用链表维护元素的插入次序，使用迭代器遍历Set时，结果按元素的插入次序显示。

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时，结果会按元素插入的次序显示。
     */
    }
}

List能够维护元素的次序，并且允许元素重复。有3个实现类：ArrayList、Vector和LinkedList。

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，它总是对列表的尾部数据进行操作，采用了先进后出的策略，自定义了插入、查看和弹出元素三个方法。
         */
    }
}

2.Map
   Map用于存储键值对，不允许键重复，值可以重复。
  （1）HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。 HashMap最多只允许一条记录的键为null，允许多条记录的值为null。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要同步，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。
   （2）Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，然而，这也导致了Hashtable在写入时会比较慢。
   （3）LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。 在遍历的时候会比HashMap慢。
   （4）TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。

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());
    }

}