常用集合框架整理

常用集合框架整理

java集合框架的体系结构：

List性质：有序且可重复，这里的有序为按添加的顺序排列，但不能自动排序
1：ArrayList因为底层为数组实现的，因此适合多查寻少增删。

import java.util.ArrayList;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1,-1};
        for (int i = 0; i < a.length; i++)
            list.add(a[i]);
        for (int value : list)
            System.out.print(value + "  ");
    }

}
// 8  7  2  5  4  3  2  1  -1  

2：LinkedList因为底层为双链表，因此适合多增删少查询

package zk.collection;

import java.util.LinkedList;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            list.add(a[i]);
        for (int value : list)
            System.out.print(value + "  ");
    }

}
// 8  7  2  5  4  3  2  1  -1  

Queue性质：先进先出
1：

package zk.collection;

import java.util.LinkedList;
import java.util.Queue;

public class Demo1 {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            queue.add(a[i]);
        for (int value : queue)
            System.out.print(value + "  ");
    }

}
// 8 7 2 5 4 3 2 1 -1

Set性质：元素无序，同理按添加的顺序来看无序，也不可以自动排序，不要被输出结果所迷惑，不过可去重
1：HashSet 性质同Set

package zk.collection;

import java.util.HashSet;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        Set<Integer> hs = new HashSet<Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            hs.add(a[i]);
        for (int value : hs)
            System.out.print(value + "  ");
    }

}
// -1  1  2  3  4  5  7  8  

2:TreeSet有序，且可以实现自动排序，并且可以去重

package zk.collection;

import java.util.Set;
import java.util.TreeSet;

public class Demo1 {
    public static void main(String[] args) {
        Set<Integer> ts = new TreeSet<Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            ts.add(a[i]);
        for (int value : ts)
            System.out.print(value+" ");
    }

}
// -1 1 2 3 4 5 7 8 

Map性质：以键值对的性质存在，key值不可重复，value可重复
1：HashMap 不能够进行自动排序，但不保证有序，下面代码就能充分体现出来，不要被迷惑

package zk.collection;

import java.util.HashMap;
import java.util.Map;

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer, Integer> hm = new HashMap<Integer, Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            hm.put(a[i], i);
        for (Map.Entry<Integer, Integer> entry : hm.entrySet())
            System.out.print(entry.getKey() + ":" + entry.getValue()+"| ");
    }

}
// -1:8|    1:7|    2:6|    3:5|    4:4|    5:3|    7:1|    8:0|    

2：TreeMap默认升序存储，按添加顺序来看便有序，同样可以自动排序，并且key值不可重复，value可重复

package zk.collection;

import java.util.Map;
import java.util.TreeMap;

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer, Integer> tm = new TreeMap<Integer, Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            tm.put(a[i], i);
        for (Map.Entry<Integer, Integer> entry : tm.entrySet())
            System.out.print(entry.getKey() + ":" + entry.getValue() + "|   ");
    }

}
// -1:8|    1:7|    2:6|    3:5|    4:4|    5:3|    7:1|    8:0|    

3：HashTable 实现的功能与HashMap类似，不过它确是线程安全的，当然ConcurrentHashMap也是线程安全的，完全可以替代HashTable，HashTable这个集合框架基本淘汰了，能不用就不用，当然在这简单说一下，它是无序的，也不可实现自动排序，对于key为null时会抛出异常，然而HashMap将null的hashCode值定为了0，从而将其存放在哈希表的第0个bucket中，因此不会抛出异常

package zk.collection;

import java.util.Hashtable;
import java.util.Map;

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer, Integer> tm = new Hashtable<Integer, Integer>();
        int a[] = { 8, 7, 2, 5, 4, 3, 2, 1, -1 };
        for (int i = 0; i < a.length; i++)
            tm.put(a[i], i);
        for (Map.Entry<Integer, Integer> entry : tm.entrySet())
            System.out.print(entry.getKey() + ":" + entry.getValue() + "|   ");
    }

}
// 8:0| 7:1|    5:3|    4:4|    3:5|    2:6|    -1:8|   1:7|