java (10) 集合类

1.集合概述

集合按照存储结构可以分为两类，即单列集合 Collection 和双列集合 Map。
* Collection 用于存储一系列符合某种规则的元素，它有两个重要的自接口，分别是List和Set。
    --List 的特点是元素有序、元素可重复。List接口的主要实现类有 ArrayList 和 LinkeList
    --Set  的特点是元素无序、元素不可重复。Set 接口的主要实现类有 HashSet 和 TreeSet

* Map    用于存储具有键(Key)、值(Value)映射关系的元素。Map接口的主要实现类有HashMap 和 TreeMap。

2.实例
2.1 ArrayList 实例

package test02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class ArrayListExamples {

    public static void main(String[] args) {
        
        //创建一个空的数组链表对象list，list用来存放String类型的数据
        ArrayList<String> list = new ArrayList<String>();
        
        //添加元素到list对象中
        list.add("Item01");
        list.add("Item02");
        list.add(2,"Item03"); //将会把Item03字符串增加到list的第3个位置
        list.add("Item04");
        
        // 显示数组链表中的内容
        System.out.println("The arraylist contains the following elements: " + list);        
        
        // 检查元素的位置
        int pos = list.indexOf("Item2");
        System.out.println("The index of Item2 is: " + pos);

        // 检查数组链表是否为空
        boolean check = list.isEmpty();
        System.out.println("Checking if the arraylist is empty: " + check);

        // 获取链表的大小
        int size = list.size();
        System.out.println("The size of the list is: " + size);

        // 检查数组链表中是否包含某元素
        boolean element = list.contains("Item5");
        System.out.println("Checking if the arraylist contains the object Item5: "+ element);

        // 获取指定位置上的元素
        String item = list.get(0);
        System.out.println("The item is the index 0 is: " + item);

        
        // 遍历arraylist中的元素
        // 第1种方法: 循环使用元素的索引和链表的大小
        System.out.println("Retrieving items with loop using index and size list");
        for (int i = 0; i < list.size(); i++) {
            System.out.println("Index: " + i + " - Item: " + list.get(i));
        }

        // 第2种方法:使用foreach循环
        System.out.println("Retrieving items using foreach loop");
        for (String str : list) {
            System.out.println("Item is: " + str);
        }

        // 第三种方法:使用迭代器
        // hasNext(): 返回true表示链表链表中还有元素
        // next(): 返回下一个元素
        System.out.println("Retrieving items using iterator");
        for (Iterator<String> it = list.iterator(); it.hasNext();) {
            System.out.println("Item is: " + it.next());
        }

        // 替换元素
        list.set(1, "NewItem");
        System.out.println("The arraylist after the replacement is: " + list);

        // 移除元素
        // 移除第0个位置上的元素
        list.remove(0);

        // 移除第一次找到的 "Item3"元素
        list.remove("Item3");
        System.out.println("The final contents of the arraylist are: " + list);

        // 转换 ArrayList 为 Array
        String[] simpleArray = list.toArray(new String[list.size()]);
        System.out.println("The array created after the conversion of our arraylist is: "+ Arrays.toString(simpleArray));        
    
    }
}

2.2 LinkedList 实例

2.2.1 LinkedList遍历方式   

package test02;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;

public class LinkedListThruTest {
    public static void main(String[] args) {
        // 通过Iterator遍历LinkedList
        iteratorLinkedListThruIterator(getLinkedList());

        // 通过快速随机访问遍历LinkedList
        iteratorLinkedListThruForeach(getLinkedList());

        // 通过for循环的变种来访问遍历LinkedList
        iteratorThroughFor2(getLinkedList());

        // 通过PollFirst()遍历LinkedList
        iteratorThroughPollFirst(getLinkedList());

        // 通过PollLast()遍历LinkedList
        iteratorThroughPollLast(getLinkedList());

        // 通过removeFirst()遍历LinkedList
        iteratorThroughRemoveFirst(getLinkedList());

        // 通过removeLast()遍历LinkedList
        iteratorThroughRemoveLast(getLinkedList());
    }

    //创建列表
    private static LinkedList getLinkedList() {
        LinkedList llist = new LinkedList();
        for (int i = 0; i < 100000; i++)
            llist.addLast(i);

        return llist;
    }

    /**
     * 通过快迭代器遍历LinkedList
     */
    private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();

        for (Iterator iter = list.iterator(); iter.hasNext();)
            iter.next();

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out
                .println("iteratorLinkedListThruIterator：" + interval + " ms");
    }

    /**
     * 通过快速随机访问遍历LinkedList
     */
    private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();

        int size = list.size();
        for (int i = 0; i < size; i++) {
            list.get(i);
        }
        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorLinkedListThruForeach：" + interval + " ms");
    }

    /**
     * 通过另外一种for循环来遍历LinkedList
     */
    private static void iteratorThroughFor2(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();

        for (Integer integ : list)
            ;

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughFor2：" + interval + " ms");
    }

    /**
     * 通过pollFirst()来遍历LinkedList
     */
    private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();
        while (list.pollFirst() != null)
            ;

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughPollFirst：" + interval + " ms");
    }

    /**
     * 通过pollLast()来遍历LinkedList
     */
    private static void iteratorThroughPollLast(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();
        while (list.pollLast() != null)
            ;

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughPollLast：" + interval + " ms");
    }

    /**
     * 通过removeFirst()来遍历LinkedList
     */
    private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();
        try {
            while (list.removeFirst() != null)
                ;
        } catch (NoSuchElementException e) {
        }

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughRemoveFirst：" + interval + " ms");
    }

    /**
     * 通过removeLast()来遍历LinkedList
     */
    private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
        if (list == null)
            return;

        // 记录开始时间
        long start = System.currentTimeMillis();
        try {
            while (list.removeLast() != null)
                ;
        } catch (NoSuchElementException e) {
        }

        // 记录结束时间
        long end = System.currentTimeMillis();
        long interval = end - start;
        System.out.println("iteratorThroughRemoveLast：" + interval + " ms");
    }

}

2.2.2 LinkedList的常用API示例

package test02;

import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;

public class LinkedListTest {
    public static void main(String[] args) {
        // 测试LinkedList的API
        testLinkedListAPIs();

        // 将LinkedList当作 LIFO(后进先出)的堆栈
        useLinkedListAsLIFO();

        // 将LinkedList当作 FIFO(先进先出)的队列
        useLinkedListAsFIFO();
    }

    /*
     * 测试LinkedList中部分API
     */
    private static void testLinkedListAPIs() {
        String val = null;
        // LinkedList llist;
        // llist.offer("10");
        // 新建一个LinkedList
        
        LinkedList llist = new LinkedList();
        // ---- 添加操作 ----
        // 依次添加1,2,3
        llist.add("1");
        llist.add("2");
        llist.add("3");

        // 将“4”添加到第一个位置
        llist.add(1, "4");

        System.out.println("
Test "addFirst(), removeFirst(), getFirst()"");        
        // (01) 将“10”添加到第一个位置。 失败的话，抛出异常！
        llist.addFirst("10");
        System.out.println("llist:" + llist);
        
        // (02) 将第一个元素删除。 失败的话，抛出异常！
        System.out.println("llist.removeFirst():" + llist.removeFirst());
        System.out.println("llist:" + llist);
        
        // (03) 获取第一个元素。 失败的话，抛出异常！
        System.out.println("llist.getFirst():" + llist.getFirst());

        
        System.out.println("
Test "offerFirst(), pollFirst(), peekFirst()"");
        // (01) 将“10”添加到第一个位置。 返回true。
        llist.offerFirst("10");
        System.out.println("llist:" + llist);
        
        // (02) 将第一个元素删除。 失败的话，返回null。
        System.out.println("llist.pollFirst():" + llist.pollFirst());
        System.out.println("llist:" + llist);
        
        // (03) 获取第一个元素。 失败的话，返回null。
        System.out.println("llist.peekFirst():" + llist.peekFirst());

        System.out.println("
Test "addLast(), removeLast(), getLast()"");
        // (01) 将“20”添加到最后一个位置。 失败的话，抛出异常！
        llist.addLast("20");
        System.out.println("llist:" + llist);
        
        // (02) 将最后一个元素删除。 失败的话，抛出异常！
        System.out.println("llist.removeLast():" + llist.removeLast());
        System.out.println("llist:" + llist);
        
        // (03) 获取最后一个元素。 失败的话，抛出异常！
        System.out.println("llist.getLast():" + llist.getLast());

        System.out.println("
Test "offerLast(), pollLast(), peekLast()"");
        // (01) 将“20”添加到第一个位置。 返回true。
        llist.offerLast("20");
        System.out.println("llist:" + llist);
        
        // (02) 将第一个元素删除。 失败的话，返回null。
        System.out.println("llist.pollLast():" + llist.pollLast());
        System.out.println("llist:" + llist);
        
        // (03) 获取第一个元素。 失败的话，返回null。
        System.out.println("llist.peekLast():" + llist.peekLast());

        // 将第3个元素设置300。不建议在LinkedList中使用此操作，因为效率低！
        llist.set(2, "300");
        // 获取第3个元素。不建议在LinkedList中使用此操作，因为效率低！
        System.out.println("
get(3):" + llist.get(2));

        // ---- toArray(T[] a) ----
        // 将LinkedList转行为数组
        String[] arr = (String[]) llist.toArray(new String[0]);
        for (String str : arr)
            System.out.println("str:" + str);

        // 输出大小
        System.out.println("size:" + llist.size());
        // 清空LinkedList
        llist.clear();
        // 判断LinkedList是否为空
        System.out.println("isEmpty():" + llist.isEmpty() + "
");

    }

    /**
     * 将LinkedList当作 LIFO(后进先出)的堆栈
     */
    private static void useLinkedListAsLIFO() {
        System.out.println("
useLinkedListAsLIFO");
        // 新建一个LinkedList
        LinkedList stack = new LinkedList();

        // 将1,2,3,4添加到堆栈中
        stack.push("1");
        stack.push("2");
        stack.push("3");
        stack.push("4");
        // 打印“栈”
        System.out.println("stack:" + stack);

        // 删除“栈顶元素”
        System.out.println("stack.pop():" + stack.pop());

        // 取出“栈顶元素”
        System.out.println("stack.peek():" + stack.peek());

        // 打印“栈”
        System.out.println("stack:" + stack);
    }

    /**
     * 将LinkedList当作 FIFO(先进先出)的队列
     */
    private static void useLinkedListAsFIFO() {
        System.out.println("
useLinkedListAsFIFO");
        // 新建一个LinkedList
        LinkedList queue = new LinkedList();

        // 将10,20,30,40添加到队列。每次都是插入到末尾
        queue.add("10");
        queue.add("20");
        queue.add("30");
        queue.add("40");
        
        // 打印“队列”
        System.out.println("queue:" + queue);

        // 删除(队列的第一个元素)
        System.out.println("queue.remove():" + queue.remove());

        // 读取(队列的第一个元素)
        System.out.println("queue.element():" + queue.element());

        // 打印“队列”
        System.out.println("queue:" + queue);
    }
}

2.3 HashMap 实例
2.3.1  HashMap 遍历方式   

package test02;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map.Entry;

public class HashMapDemo {

    public static void main(String[] args) {

        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("cn", "中国");
        hashMap.put("jp", "日本");
        hashMap.put("fr", "法国");

        System.out.println(hashMap);
        System.out.println("cn:" + hashMap.get("cn"));
        System.out.println(hashMap.containsKey("cn"));
        System.out.println(hashMap.keySet());
        System.out.println(hashMap.isEmpty());

        hashMap.remove("cn");
        System.out.println(hashMap.containsKey("cn"));

        // 采用Iterator遍历HashMap
        Iterator it = hashMap.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            System.out.println("key:" + key);
            System.out.println("value:" + hashMap.get(key));
        }

        // 遍历HashMap的另一个方法
        Set<Entry<String, String>> sets = hashMap.entrySet();
        for (Entry<String, String> entry : sets) {
            System.out.print(entry.getKey() + ", ");
            System.out.println(entry.getValue());
        }
    }
}

2.3.2 结合List和HashMap实现的例子

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map.Entry;

public class HashMapDemo {

    public static void main(String[] args) {

        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("cn", "中国");
        hashMap.put("jp", "日本");
        hashMap.put("fr", "法国");

        System.out.println(hashMap);
        System.out.println("cn:" + hashMap.get("cn"));
        System.out.println(hashMap.containsKey("cn"));
        System.out.println(hashMap.keySet());
        System.out.println(hashMap.isEmpty());

        hashMap.remove("cn");
        System.out.println(hashMap.containsKey("cn"));

        // 采用Iterator遍历HashMap
        Iterator it = hashMap.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            System.out.println("key:" + key);
            System.out.println("value:" + hashMap.get(key));
        }

        // 遍历HashMap的另一个方法
        Set<Entry<String, String>> sets = hashMap.entrySet();
        for (Entry<String, String> entry : sets) {
            System.out.print(entry.getKey() + ", ");
            System.out.println(entry.getValue());
        }
    }
}