JAVA容器类库

1、数组将数字与对象联系起来，保存类型明确的对象，查询对象时不需要对结果进行转换，可以是多维的，可以保存基本类型数据。但是数组一旦生成，其容量就不能再改变。
2、JAVA提供了集合类来解决这个问题，其中基本的类型有List、Set、Queue、Map四种，List、Set、Queue继承了Collection接口保存单一的元素，而Map保存相关联的键值对。使用Java泛型就可以指定容器中存放的对象类型，当向集合类对象中添加元素时，就可以自动调整其尺寸。容器不能持有基本类型，但是自动包装机制会进行自动转换。
3、如果要进行大量的随机访问，就使用ArrayList；如果经常从表中插入删除元素，就使用LinkedList。
ArrayList增删查改如下所示

public class ListTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));
        System.out.println(list);
        list.add(6);
        System.out.println(list.contains(6));
        int num = list.get(2);
        System.out.println(num);
        System.out.println(list.indexOf(num));
        List<Integer> sub = list.subList(1,4);
        System.out.println(sub);
        System.out.println(list.containsAll(sub));
        list.removeAll(sub);
        System.out.println(list);
    }
}/*output
[1, 2, 3, 4, 5]
true
3
2
[2, 3, 4]
true
[1, 5, 6]
*/

4、LinkedList实现了栈，可以直接作为栈使用，出栈、入栈、取栈顶元素的操作如下所示。

public class StackTest {
    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4,5,6);
        LinkedList<Integer> list2 = new LinkedList<Integer>(list1);
//        System.out.println(list1);
        System.out.println(list2);
        list2.addFirst(7);
        System.out.println(list2);
        list2.addFirst(8);
        System.out.println(list2);
        int top = list2.getFirst();
        System.out.println(top);
        System.out.println(list2);
        int top1 = list2.removeFirst();
        System.out.println(top1);
        System.out.println(list2);
        System.out.println(list2.isEmpty());
    }
}/*output
[1, 2, 3, 4, 5, 6]
[7, 1, 2, 3, 4, 5, 6]
[8, 7, 1, 2, 3, 4, 5, 6]
8
[8, 7, 1, 2, 3, 4, 5, 6]
8
[7, 1, 2, 3, 4, 5, 6]
false
*/

5、LinkedList还实现了Queue接口，因此可以作为队列的一种实现，出队、入队、取队头元素的操作如下所示。

public class QueueTest {
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<Integer>();
        Random rand = new Random(47);
        for(int i=0; i < 10; i++) {
            q.offer(rand.nextInt(i + 10));
        }
        System.out.println(q);
        q.offer(5);
        System.out.println(q);
        int top = q.peek();
        System.out.println("top=" + top + "q=" + q);
        int top1 = q.poll();
        System.out.println("top=" + top + "q=" + q);
    }
}/*
[8, 1, 1, 1, 5, 14, 3, 1, 0, 1]
[8, 1, 1, 1, 5, 14, 3, 1, 0, 1, 5]
top=8  q=[8, 1, 1, 1, 5, 14, 3, 1, 0, 1, 5]
top=8  q=[1, 1, 1, 5, 14, 3, 1, 0, 1, 5]
*/

peek()与element()都将在不移除的情况下返回队头，但是peek方法在队列为空的时候返回null，element方法在队列为空的时候抛出异常。pool()和remove()会移除队头元素并且返回，但是pool方法会在队列为空时返回null，remove方法会在队列为空时抛出异常。
6、Map是将对象与对象相关联的设计。HashMap用于快速访问，TreeMap保持键始终处于排队状态，LinkedHashMap保持元素的插入顺序，但也通过散列提供了快速访问能力。Map的增删查改操作如下所示。

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("China","Beijing");
        map.put("Janpan","Tokyo");
        System.out.println(map);
        String str = map.get("China");
        System.out.println(str);
        map.put("Janpan","dongjing");
        System.out.println(map);
        Set<String> key = map.keySet();
        System.out.println(key);
        Collection<String> values = map.values();
        System.out.println(values);
        map.remove("Janpan");
        System.out.println(map);
    }
}/*output
{China=Beijing, Janpan=Tokyo}
Beijing
{China=Beijing, Janpan=dongjing}
[China, Janpan]
[Beijing, dongjing]
{China=Beijing}
*/

7、Set不接受重复元素。HashSet用于快速访问，TreeSet保持键始终处于排队状态，LinkedHashSet保持元素的插入顺序。Set的增删查改操作如下所示。

public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.addAll(Arrays.asList("A B C D A".split(" ")));
        System.out.println(set);
        Boolean flag = set.contains("A");
        System.out.println(flag);
        set.remove("A");
        System.out.println(set);
        System.out.println(set.contains("A"));
        set.add("E");
        set.add("Q");
        System.out.println(set);
    }
}/*output
[A, B, C, D]
true
[B, C, D]
false
[Q, B, C, D, E]
*/