对于这些常用的集合,建议还是需要先了解一下底层实现原理,这样在不同的使用场景下才能选择更好的方案。

Set介绍以及对比,常用方法:

package cn.review.day02;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet;

import org.junit.Test;

/**
 * Set集合复习
 * Set集合用于存储无序,不重复的元素,可以存储一个null值。
 * 其中Set集合主要分为:HashSet,LinkedSet,TreeSet
 * 
 * 集合性能分析:
 *         HashSet和TreeSet是Set集合中用得最多的I集合。HashSet总是比TreeSet集合性能好,因为HashSet不需要额维护元素的顺序。
 *        LinkedHashSet需要用额外的链表维护元素的插入顺序,因此在插入时性能比HashSet低,但在迭代访问(遍历)时性能更高。
 *        因为插入的时候即要计算hashCode又要维护链表,而遍历的时候只需要按链表来访问元素。
 * @author dyq
 *
 */
public class ReviewSet {
    @Test
    public void setTest() {
        /**
         * HashSet:实现了set接口,存储元素是无序的,从底层代码可以看到是用HashMap来实现的,是一个value相同key不同的HashMap
         * 使用hashCode的算法来存储元素,因此具有比较好的读写性能,是非线程安全的。
         */
        HashSet<String> hashSet = new HashSet<String>();
        hashSet.add("aaa");
        hashSet.add("bbb");
        hashSet.add("ccc");
        hashSet.add("ddd");
        Iterator<String> iter0 = hashSet.iterator();
        while(iter0.hasNext()) {
            System.out.println(iter0.next()+"=====");
        }
        System.out.println(hashSet);
        /**
         * LinkedHashSet:从底层代码可以看到继承了HashSet,实现了Set接口。
         * LinkedHashSet存储元素使用一个链表来维护元素的插入顺序,读取的时候按照插入顺序读取。
         * LinkedHashSet本质上也是从LinkedHashMap而来,LinkedHashSet的所有方法都继承自HashSet, 而它能维持元素的插入顺序的性质则继承自LinkedHashMap。
         * 同时LinkedHashSet是非线程安全的。
         * 
         */
        LinkedHashSet<String> lhSet = new LinkedHashSet<String>();
        lhSet.add("aaa");
        lhSet.add("bbb");
        lhSet.add("ccc");
        Iterator<String> iter = lhSet.iterator();
        while(iter.hasNext()) {
            System.out.println(iter.next()+"------");
        }
        System.out.println(lhSet);
        /**
         * TreeSet:从源码中可以看到,TreeSet实现了NavigableSet集合,而NavigableSet继承于SortedSet。
         * TreeSet底层是用TreeMap来实现的,其原理是红黑树,默认是自然升序排序,同时也可以定制排序,需要关联一个 Comparator对象,由Comparator提供排序逻辑。
         * 因为会默认调用compareTo比较元素大小,做升序排序,所以TreeSet只允许存储同一类元素。
         * TreeSet同样是非线程安全的。
         */
        //本集合使用自定义排序倒序排序。
        TreeSet<Integer> treeSet = new TreeSet<Integer>(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                int a1 = (Integer)o1;
                int a2 = (Integer)o2;
                return a1<a2?1:a1>a2?-1:0;
            }
        });
        treeSet.add(3);
        treeSet.add(1);
        treeSet.add(8);
        treeSet.add(2);
        System.out.println(treeSet);
    }
    
    /**
     * 获取字符串的hashCode值
     */
    @Test
    public void hashCodeTest() {
        String str = "aa";
        String str1 = "aa";
        System.out.println(str.hashCode());
        System.out.println(str1.hashCode());
    }

}

List介绍以及对比,常用方法:

package cn.review.day02;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;

import org.junit.Test;

/**
 * List集合
 * List是继承于Collection接口,除了Collection通用的方法以外,扩展了部分只属于List的方法。
 * List是一个有序的集合,和set不同的是,List允许存储项的值为空,也允许存储相等值的存储项.
 * List包含:ArrayList,LinkedList,Vector
 * @author dyq
 *
 */
public class ReviewList {
    
    @Test
    public void listTest() {
        /**
         * ArrayList:底层是一个数组实现的列表,由于数据是存入数组中的,因此也跟数组的特点一样,查询很快,但是中间部分的插入和删除都很。
         * 适用于多查找的场景 
         * 非线程安全的。
         */
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("1111");
        arrayList.add("2222");
        System.out.println(arrayList.toString());
        
        /**
         * LinkedList:底层是由链表实现,插入和删除方便,适用于多次数据替换的场景
         */
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("1111");
        linkedList.add("2222");
        System.out.println(linkedList.toString());
        /**
         * Vector:Vector就是ArrayList的线程安全版,它的方法前都加了synchronized锁,其他实现逻辑都相同。
         * 由于锁的原因导致Vector要比ArrayList慢。
         */
        Vector<String> vector = new Vector<String>();
        vector.add("3333");
        vector.add("4444");
        System.out.println(vector.toString());
    }
}

Map介绍以及对比,常用方法:

package cn.review.day02;

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

import org.junit.Test;

/**
* Map:用于保存具有映射关系的数据,key-value形式,key不能重复。
* Map---实现Map        
* Map.Entry--Map的内部类,描述Map中的按键/数值对。   
* SortedMap---扩展Map,使按键保持升序排列   
* 
* 常用Map类型介绍:HashMap,HashTable,LinkedHashMap,TreeMap
*     
* @author dyq
*
*/
public class ReviewMap {
   @Test
   public void mapTest() {
       /**
        * HashMap:非同步的,所以是线程不安全的,异步的所以读写速度都很快。
        * HashMap中允许key或者value为null
        */
       HashMap<String, String> hashMap = new HashMap<String,String>();
       hashMap.put("1","aaa");
       hashMap.put(null,null);
       for(Map.Entry<String, String> entry : hashMap.entrySet()) {
           System.out.println(entry.getKey()+"---"+entry.getValue());
       }
       
       /**
        * Hashtable:查看源码发现,其方法使用synchronized关键字修饰,为同步的,线程安全的,所以读写速度都会变慢。
        * Hashtable中不允许key或者value的值为null。
        */
       Hashtable<String,String> hashTable = new Hashtable<String,String>();
       hashTable.put("1","aaa");
       hashTable.put("2","bbb" );
       for(Map.Entry<String, String> entry :hashTable.entrySet()) {
           System.out.println(entry.getKey()+"--"+entry.getValue());
       }
       /**
        * LinkedHashMap:查看源码发现,继承了HashMap,其底层使用双向链表维护键值对的顺序,迭代顺序与键值对插入的顺序一致。
        * LinkedHashMap需要维护插入时候的顺序,所以性能低于HashMap,但是在迭代元素的时候有很好的性能,因为它是用链表来
        * 维护内部的顺序。
        */
       LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<String,String>();
       linkedHashMap.put("1","aaa");
       linkedHashMap.put("2","bbb");
       for(Map.Entry<String, String> entry : linkedHashMap.entrySet()) {
           System.out.println(entry.getKey()+"--"+entry.getValue());
       }
       /**
        * TreeMap:查看源码发现,继承了SortedMap,基于红黑树对所有的key进行排序,有两种排序 方式:自然排序和定制排序。
        * 自定义排序需要关联一个Comparator对象,重写compare方法。
        */
       TreeMap<String, String> treeMap = new TreeMap<String,String>(new Comparator<String>() {
           @Override
           public int compare(String o1, String o2) {
               return o2.compareTo(o1);
           }
       });
       treeMap.put("1", "aaa");
       treeMap.put("2", "bbb");
       for(Map.Entry<String, String> entry:treeMap.entrySet()) {
           System.out.println(entry.getKey()+"--"+entry.getValue());
       }
       
   }
}