Java三大集合(1)

一. Set集合

1.HashSet集合，LinkedHashSet集合

@Test
public void test01() {
    //基本重复标准:equal()返回true
    Set<String> set;
    //根据hashCode()判断重复及排序
    HashSet<String> hashset = new HashSet<String>();
    //根据hashCode()判断重复,根据插入顺序排序
    LinkedHashSet linkedHashset = new LinkedHashSet<String>();

    hashset.add("b");
    hashset.add("a");
    hashset.remove("c");
    Iterator<String> t = hashset.iterator();
    while(t.hasNext()) {
        System.out.println(t.next());
    }
}

2.TreeSet集合

@Test
public void test02() {
    //根据compareTo()判断重复及排序
    //自然排序:元素对象实现Comparable接口,重写compareTo()
    TreeSet<Integer> treeSet = new TreeSet<Integer>();
    //定制排序:实现Comparator接口,作为创建集合的参数
    TreeSet<Entity> treeSet2 = new TreeSet<Entity>(new Comparator<Entity>(){
        @Override
        public int compare(Entity o1, Entity o2) {
            int subNum = o1.num-o2.num;
            return subNum;
        }
    });
    treeSet2.add(new Entity(1));
    treeSet.add(1);
    treeSet.add(2);
    //第一个元素
    treeSet.first();
    //最后一个元素
    treeSet.last();
    //元素小于2的子集
    treeSet.headSet(2);
    //元素大于等于2的子集
    treeSet.tailSet(2);
    //元素大于等于1,小于2的子集
    treeSet.subSet(1, 2);
}

public class Entity {
    public int num;
    public Entity(int num) {
        this.num = num;
    }
}

3.EnumSet集合

public void test03() {
    //只能存放指定的枚举对象，按在枚举中的顺序排序
    //全部枚举值
    EnumSet es1 = EnumSet.allOf(Season.class);
    //空元素
    EnumSet es2 = EnumSet.noneOf(Season.class);
    //指定枚举值
    EnumSet es3 = EnumSet.of(Season.spring, Season.summer);
    //指定枚举值区间
    EnumSet es4 = EnumSet.range(Season.spring, Season.fall);
    //剩下的枚举值
    EnumSet es5 = EnumSet.complementOf(es4);

    es2.add(Season.summer);
    es1.removeAll(es2);
}

4.集合总结

1. 性能：EnumSet > HashSet = LinkedHashSet > TreeSet
2. 特点总结：
   (1)HashSet：添加，删除操作
   (2)LinkedHashSet：遍历
   (3)TreeSet：排序
   (4)EnumSet：枚举值
3. 四种集合都是线程不安全

二. List集合

1.ArrayList集合，Vector集合

@Test
public void test01() {
    //两个集合功能相同
    ArrayList<String> box = new ArrayList<String>();
    Vector<String> vector = new Vector<String>();

    box.add("a");
    box.add(0,"b");
//  box.remove(1);
    box.set(0, "A");
    box.get(0);
    box.indexOf("A");
    List<String> subBox = box.subList(0, 1);
}

2.Stack集合

public void test02() {
    //增加了堆栈相关方法
    Stack<String> box = new Stack<String>();

    //在右端添加顶部元素,结果[a,b]
    box.push("a");
    box.add("b");
    //访问顶部元素
    box.peek();
    //推出顶部元素
    box.pop();
}

3.LinkedList集合，ArrayDeque集合

@Test
public void test03() {
    //两种集合方法一样,都实现Deque接口(双向队列)
    LinkedList<String> box = new LinkedList<String>();
    ArrayDeque<String> deque = new ArrayDeque<String>();

    //在左端添加顶部元素,结果[c,b,a]
    box.push("a");
    box.offerFirst("b");
    box.addFirst("c");
    //添加底部元素,结果[c,b,a,d,e,f,g]
    box.offer("d");
    box.offerLast("e");
    box.add("f");
    box.addLast("g");   

    //访问顶部元素
    box.peek();
    box.peekFirst();
    //访问底部元素
    box.peekLast();

    //推出顶部元素
    box.pop();
    box.pollFirst();
    box.poll();
    //推出底部元素
    box.pollLast();
}

4.集合总结
(1) 实现方式：Vector，Stack，ArrayList，ArrayDeque采用数组。LinkedList采用双向链表。
(2) 线程安全：Vector，Stack安全。ArrayList，ArrayDeque，LinkedList不安全。
(3) 特点总结：Stack集合可以当栈。ArrayDeque集合，LinkedList集合可以当双向队列。
(4)时间复杂度：数组集合查改遍历效率高。链表集合增删效率高。
(5)空间复杂度：数组集合预留空间容量。链表集合元素本事消耗空间。
(6)遍历方式：
(数组集合)for>iterator>>foreach>>(链表集合)iterator>foreach>>>for

三.Map集合

1.HashMap集合，HashTable集合，LinkedHashMap集合

@Test
public void test01() {
    //根据equal()和hashCode()判断key相等，根据hashCode排序
    HashMap<Integer,String> map = new HashMap<Integer,String>();
    //同上，线程安全，key和value不支持null
    Hashtable<String,String> table = new Hashtable<String,String>();
    //根据equal()和hashCode()判断key相等，根据插入顺序排序
    LinkedHashMap<Integer,String> map2 = new LinkedHashMap<Integer,String>();
    //复制所有键值对到map
    map.putAll(new HashMap());
    map.put(1,"a");
    map.put(null, null);
    //替换key对应的value
    map.replace(null, "b");
    //根据equals()和hashCode()判断是否相同key
    map.containsKey(1);
    //根据equals()判断是否含相同value
    map.containsValue("a");

    //遍历集合
    for(Entry<Integer,String> entry :map.entrySet()) {
        entry.getValue();
        entry.getKey();
        entry.setValue("");
    }
    //遍历集合
    for(Integer key : map.keySet()) {
        map.get(key);
    }
    map2.put(null,null);
}

2.TreeMap集合

@Test
public void test02() {
    //自然排序:key类要实现Comparable接口
    TreeMap<Bean, String> map = new TreeMap<Bean,String>();
    //定制排序:Comparator接口的对象作为集合的参数
    TreeMap<Bean, String> map2 = new TreeMap<Bean,String>(new Comparator<Bean>(){
        @Override
        public int compare(Bean o1, Bean o2) {
            return o1.count - o2.count;
        }
    });
    Bean b1 = new Bean(3);
    Bean b2 = new Bean(2);
    map.put(b1,"b1");
    map.put(b2, null);
    //获取key的各种方法
    map.firstKey();
    map.lowerKey(b2);
    //获取键值对的各种方法
    Entry<Bean, String> entry = map.lastEntry();
    entry = map.ceilingEntry(b1);
}

class Bean implements Comparable<Bean>{
    public int count;
    public Bean(int count) {
        this.count = count;
    }
    @Override
    public int compareTo(Bean bean) {
        return this.count-bean.count;
    }
}

3.WeakHashMap集合

@Test
public void test03() {
    //只保存对key对象的弱引用，若对象被回收，键值对也会被清除
    WeakHashMap<String, Integer> map = new WeakHashMap<String,Integer>();
    map.put(null, null);
    map.put(new String("b"), 2);
    System.gc();
    //打印{null=null}
    System.out.println(map);
}

4.IdentityHashMap集合

@Test
public void test04() {
    //key为同一个对象才视为相等
    IdentityHashMap<Integer,String> map = new IdentityHashMap<Integer, String>();
    map.put(128, "a");
    map.put(128,"b");
    //打印{128=b, 128=a}
    System.out.println(map);
}

5.EnumMap集合

@Test
public void test05() {
    //key只能为枚举类
    EnumMap<Season, String> map = new EnumMap<Season, String>(Season.class);
    map.put(Season.spring, "春天")
}

四.集合列表