Java集合类: Set、List、Map、Queue使用场景梳理

一、Set 

package com.demo;

import java.util.HashSet;

/**
 * Created by Ranjx on 2018/7/22.
 * 无序，不允许重复
 * 采用hash算法来决定元素的存储位置不同
 */
public class HashSetTest {

    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
       /* A1 a1 = new A1();
        System.out.println("al hashCode=" + a1.hashCode() + ",a1 equals=" + a1.equals(a1));
        A1 a2 = new A1();
        System.out.println("a2 hashCode=" + a2.hashCode() + ",a2 equals=" + a2.equals(a2));
        hashSet.add(a1);
        hashSet.add(a2);

        B1 b1 = new B1();
        System.out.println("b1 hashCode=" + b1.hashCode() + ",b1 equals=" + b1.equals(b1));
        B1 b2 = new B1();
        System.out.println("b2 hashCode=" + b2.hashCode() + ",b2 equals=" + b2.equals(b2));
        hashSet.add(b1);
        hashSet.add(b2);

        C1 c1 = new C1();
        System.out.println("c1 hashCode=" + c1.hashCode() + ",c1 equals=" + c1.equals(c1));
        C1 c2 = new C1();
        System.out.println("c2 hashCode=" + c2.hashCode() + ",c2 equals=" + c2.equals(c2));
        hashSet.add(c1);
        hashSet.add(c2);
        System.out.print(hashSet);*/

        hashSet.add("a");
        hashSet.add("b");
        hashSet.add("c");
        hashSet.add("a");
        System.out.print(hashSet);

        hashSet.remove("a");
        System.out.print(hashSet);
        hashSet.add("a");
        System.out.print(hashSet);
    }

}

package com.demo;

import java.util.LinkedHashSet;

/**
 * Created by Ranjx on 2018/7/22.
 * 有序，按照元素添加顺序显示，不允许重复
 * 采用hash算法来决定元素的存储位置不同
 */
public class LinkedHashSetTest {

    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("java");
        linkedHashSet.add("java");
        linkedHashSet.add("jsp");
        linkedHashSet.add("jquery");
        System.out.println(linkedHashSet);

        linkedHashSet.remove("java");
        System.out.println(linkedHashSet);

        linkedHashSet.add("java");
        System.out.println(linkedHashSet);
    }
}

package com.demo;

import java.util.TreeSet;

/**
 * Created by Ranjx on 2018/7/22.
 * 采用红黑树的数据结构来存储集合元素，不允许重复
 * TreeSet支持两种排序方式: 自然排序、定制排序
 * TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，
 * 然后将集合元素按升序排序，即自然排序。
 * 如果试图把一个对象添加到TreeSet时，
 * 则该对象的类必须实现Comparable接口，否则程序会抛出异常。
 */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet nums = new TreeSet();
        nums.add(5);
        nums.add(4);
        nums.add(2);
        nums.add(3);
        nums.add(1);
        nums.add(-9);

        //输出集合元素，看到集合元素已经处于排序状态
        System.out.println("所有集合：" + nums);
        //输出集合第一个元素
        System.out.println("集合第一个元素：" + nums.first());
        //输出集合最后一个元素
        System.out.println("集合最后一个元素：" + nums.last());
        //返回小于4的集合，不包含4
        System.out.println("集合小于4，不包含4：" + nums.headSet(4));
        //返回大于3的子集
        System.out.println("集合大于3，包含3：" + nums.tailSet(3));
        //返回大于等于1，小于4的子集。
        System.out.println("集合大于等于1，小于4的子集" + nums.subSet(1 , 4));
    }
}

package com.demo;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * Created by Ranjx on 2018/7/22.
 * TreeSet排序
 * 升序、降序
 */
public class TreeSetCompare {

    public static void main(String[]args) {
        TreeSet ts = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Man m1 = (Man) o1;
                Man m2 = (Man) o2;
                return m1.age > m2.age ? -1 :m1.age < m2.age ? 1 : 0;
            }
        });
        ts.add(new Man(1));
        ts.add(new Man(4));
        ts.add(new Man(5));
        ts.add(new Man(2));
        ts.add(new Man(3));
        System.out.println(ts);
    }
}

package com.demo;

import java.util.EnumSet;

/**
 * Created by Ranjx on 2018/7/22.
 * 不可重复
 */
public class EnumSetTest {
    public static void main(String[] args) {
        //创建一个EnumSet集合，集合元素就是Color枚举类的全部枚举值
        EnumSet es1 = EnumSet.allOf(Color.class);
        System.out.println(es1);
        //创建一个EnumSet空集合，指定其集合元素是Color类的枚举值。
        EnumSet es2 = EnumSet.noneOf(Color.class);
        System.out.println(es2);
        //手动添加两个元素
        es2.add(Color.RED);
        es2.add(Color.ORANGE);
        System.out.println(es2);
        //以指定枚举值创建EnumSet集合
        EnumSet es3 = EnumSet.of(Color.RED,Color.ORANGE);
        System.out.println(es3);
        //创建EnumSet集合，从Color.RED到Color.YELLOR为止
        EnumSet es4 = EnumSet.range(Color.RED,Color.YELLOR);
        System.out.println(es4);
        //创建EnumSet集合,去掉重复的枚举
        EnumSet es5 = EnumSet.complementOf(es4);
        System.out.println(es5);
    }
}

1) HashSet的性能总是比TreeSet好(特别是最常用的添加、查询元素等操作)，因为TreeSet需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet

2) 对于普通的插入、删除操作，LinkedHashSet比HashSet要略慢一点，这是由维护链表所带来的开销造成的。不过，因为有了链表的存在，遍历LinkedHashSet会更快

3) EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素

4) HashSet、TreeSet、EnumSet都是"线程不安全"的，通常可以通过Collections工具类的synchronizedSortedSet方法来"包装"该Set集合。 SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

二、List

package com.demo.collection;

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

/**
 * Created by Ranjx on 2018/7/22.
 * List 有序集合，可重复
 */
public class ListTest{

    public static void main(String[] args) {
        //向books集合中添加三个元素
        List books = new ArrayList();
        books.add("Java");
        books.add("Java");
        books.add("C++");
        books.add("Android");
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.add(1,"node");
        for (int i=0;i<books.size();i++) {
            System.out.println(books.get(i));
        }
        System.out.println(books);
        //将新字符串对象插入在第二个位置
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置
        int seq = books.indexOf("Java");
        System.out.println(seq);
        //到第2个元素（不包括）截取成子集合
        System.out.println(books.subList(0 , 1));
    }
}

package com.demo.collection;

import java.util.Stack;

/**
 * Created by Ranjx on 2018/7/23.
 * Stack的后进先出的特点
 */
public class StackTest {
    public static void main(String[] args) {
        Stack v = new Stack();
        v.add("Java");
        v.add("JavaEE");
        v.add("Android");
        //输出：[Java, JavaEE, Android]
        System.out.println(v);
        //访问第一个元素，但并不将其pop出"栈"，输出：Android
        System.out.println(v.peek());
        //依然输出：[Java, JavaEE, Android]
        System.out.println(v);
        //pop出第一个元素，输出：Android
        System.out.println(v.pop());
        //输出：[Java, JavaEE]
        System.out.println(v);
    }
}

 

package com.demo.collection;

import java.util.LinkedList;

/**
 * Created by Ranjx on 2018/7/23.
 * LinkedList同时表现出了双端队列、栈的用法
 */
public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList books = new LinkedList();
        //将字符串元素加入队列的尾部(双端队列)
        books.offer("Java");
        //将一个字符串元素加入栈的顶部(双端队列)
        books.push("JavaEE");
        //将字符串元素添加到队列的头(相当于栈的顶部)
        books.offerFirst("Android");
        for (int i = 0; i < books.size() ; i++ ) {
            System.out.println(books.get(i));
        }
        System.out.println(books);
        //访问、并不删除栈顶的元素
        System.out.println(books.peekFirst());
        //访问、并不删除队列的最后一个元素
        System.out.println(books.peekLast());
        //将栈顶的元素弹出"栈"
        System.out.println(books.pop());
        //下面输出将看到队列中第一个元素被删除
        System.out.println(books);
        //访问、并删除队列的最后一个元素
        System.out.println(books.pollLast());
        //下面输出将看到队列中只剩下中间一个元素：
        System.out.println(books);
    }
}

三、Queue 

package com.demo.collection;

import java.util.PriorityQueue;

/**
 * Created by Ranjx on 2018/7/23.
 *
 * PriorityQueue不允许插入null元素，它还需要对队列元素进行排序
 * 不是按元素的加入顺序排列
 * 按元素的大小顺序排列
 *
 * 1) 自然排序:
 *    采用自然顺序的PriorityQueue集合中的元素对象
 *    都必须实现了Comparable接口，而且应该是同一个
 *    类的多个实例，否则可能导致ClassCastException异常
 * 2) 定制排序
 *    创建PriorityQueue队列时，传入一个Comparator对象，
 *    该对象负责对队列中的所有元素进行排序
 *    关于自然排序、定制排序的原理和之前说的TreeSet类似
 */
public class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        pq.add(1);
        pq.add(0);
        pq.add(-6);
        pq.add(2);
        pq.add(9);
        //输出queue队列，并不是按元素的加入顺序排列，
        //而是按元素的大小顺序排列，输出[-6, 1, 0, 2, 9]
        System.out.println(pq);
        //访问队列第一个元素，其实就是队列中最小的元素：-6
        System.out.println(pq.poll());
    }
}

package com.demo.collection;

import java.util.ArrayDeque;

/**
 * Created by Ranjx on 2018/7/23.
 */
public class ArrayDequeTest {
    public static void main(String[]args) {
        ArrayDeque stack = new ArrayDeque();
        //依次将三个元素push入"栈"
        stack.push("疯狂Java讲义");
        stack.push("轻量级Java EE企业应用实战");
        stack.push("疯狂Android讲义");
        //输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(stack);
        //访问第一个元素，但并不将其pop出"栈"，输出：疯狂Android讲义
        System.out.println(stack.peek());
        //依然输出：[疯狂Java讲义, 轻量级Java EE企业应用实战 , 疯狂Android讲义]
        System.out.println(stack);
        //pop出第一个元素，输出：疯狂Android讲义
        System.out.println(stack.pop());
        //输出：[疯狂Java讲义, 轻量级Java EE企业应用实战]
        System.out.println(stack);
    }
}

1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、LinkedList(基于链的线性表)是线性表的两种典型实现

2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用)

3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。所以的内部以数组作为底层实现的集合在随机访问时性能最好。

4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能

5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好

 

package com.demo.collection;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

/**
 * Created by Ranjx on 2018/7/23.
 * Collection接口继承了Iterable接口，也就是说，
 * 我们以上学习到的所有的Collection集合类都具有"可遍历性"
 *
 * iterator必须依附于Collection对象，
 * 若有一个iterator对象，必然有一个与之关联的Collection对象
 * 除了可以使用iterator接口迭代访问Collection集合里的元素之外，
 * 使用java5提供的foreach循环迭代访问集合元素更加便捷
 *
 * 1) boolean hasNext(): 是否还有下一个未遍历过的元素
 * 2) Object next(): 返回集合里的下一个元素
 * 3) void remove(): 删除集合里上一次next方法返回的元素
 */
public class IteratorTest {
    public static void main(String[] args) {
        Collection books = new HashSet();
        books.add("java");
        books.add("javaEE");
        books.add("android");
        System.out.println(books);
        //iterator实现遍历
        Iterator it = books.iterator();
        while (it.hasNext()) {
            String book = (String)it.next();
            if(book.equals("java")){
                it.remove();
            }
            System.out.println(book);
        }
        //foreach实现遍历
        for (Object obj : books) {
            System.out.println(obj);
        }
        System.out.println(books);
    }
}

package com.demo.collection;

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

/**
 * Created by Ranjx on 2018/7/23.
 * List额外提供了一个listIterator()方法，
 * 该方法返回一个ListIterator对象，ListIterator接口
 * 继承了Iterator接口，提供了专门操作List的方法。ListIterator接口
 * 在Iterator接口的继承上增加了如下方法:
 * 1) boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素
 * 2) Object previous(): 返回该迭代器的上一个元素(向前迭代即反向迭代)
 * 3) void add(): 在指定位置插入一个元素
 */
public class ListIteratorTest {
    public static void main(String[] args) {
        String[] books = {"java","javaee"};
        List bookList = new ArrayList();
        for (int i=0;i<books.length;i++) {
            bookList.add(books[i]);
        }
        //foreach实现遍历
        for (Object obj : bookList) {
            System.out.println(obj);
        }
        //iterator实现遍历
        ListIterator lit = bookList.listIterator();
        while (lit.hasNext()) {
            System.out.println(lit.next());
            lit.add("-------分隔符-------");
        }
        System.out.println("=======下面开始反向迭代=======");
        //iterator反向迭代实现遍历
        while (lit.hasPrevious()) {
            System.out.println(lit.previous());
        }
    }
}

四、Map 

class A
{
    int count;
    public A(int count)
    {
        this.count = count;
    }
    //根据count的值来判断两个对象是否相等。
    public boolean equals(Object obj)
    {
        if (obj == this)
            return true;
        if (obj!=null &&
            obj.getClass()==A.class)
        {
            A a = (A)obj;
            return this.count == a.count;
        }
        return false;
    }
    //根据count来计算hashCode值。
    public int hashCode()
    {
        return this.count;
    }
}

class B
{
    //重写equals()方法，B对象与任何对象通过equals()方法比较都相等
    public boolean equals(Object obj)
    {
        return true;
    }
}

public class HashtableTest
{
    public static void main(String[] args) 
    {
        Hashtable ht = new Hashtable();
        ht.put(new A(60000) , "疯狂Java讲义");
        ht.put(new A(87563) , "轻量级Java EE企业应用实战");
        ht.put(new A(1232) , new B());
        System.out.println(ht);

        //只要两个对象通过equals比较返回true，
        //Hashtable就认为它们是相等的value。
        //由于Hashtable中有一个B对象，
        //它与任何对象通过equals比较都相等，所以下面输出true。
        System.out.println(ht.containsValue("测试字符串"));  //①

        //只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等
        //Hashtable即认为它们是相同的key，所以下面输出true。
        System.out.println(ht.containsKey(new A(87563)));   //②

        //下面语句可以删除最后一个key-value对
        ht.remove(new A(1232));    //③

        //通过返回Hashtable的所有key组成的Set集合，
        //从而遍历Hashtable每个key-value对
        for (Object key : ht.keySet())
        {
            System.out.print(key + "---->");
            System.out.print(ht.get(key) + "\n");
        }
    }
}

 当使用自定义类作为HashMap、Hashtable的key时，如果重写该类的equals(Object obj)和hashCode()方法，则应该保证两个方法的判断标准一致--当两个key通过equals()方法比较返回true时，两个key的hashCode()的返回值也应该相同

public class LinkedHashMapTest
{
    public static void main(String[] args) 
    {
        LinkedHashMap scores = new LinkedHashMap();
        scores.put("语文" , 80);
        scores.put("英文" , 82);
        scores.put("数学" , 76);
        //遍历scores里的所有的key-value对
        for (Object key : scores.keySet())
        {
            System.out.println(key + "------>" + scores.get(key));
        }
    }
}

import java.util.*;
import java.io.*;

public class PropertiesTest
{
    public static void main(String[] args) throws Exception
    {
        Properties props = new Properties();
        //向Properties中增加属性
        props.setProperty("username" , "yeeku");
        props.setProperty("password" , "123456");

        //将Properties中的key-value对保存到a.ini文件中
        props.store(new FileOutputStream("a.ini"), "comment line");   //①

        //新建一个Properties对象
        Properties props2 = new Properties();
        //向Properties中增加属性
        props2.setProperty("gender" , "male");

        //将a.ini文件中的key-value对追加到props2中
        props2.load(new FileInputStream("a.ini") );    //②
        System.out.println(props2);
    }
}

Properties还可以把key-value对以XML文件的形式保存起来，也可以从XML文件中加载key-value对

import java.util.*;

class R implements Comparable
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R[count:" + count + "]";
    }
    //根据count来判断两个对象是否相等。
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj!=null
            && obj.getClass()==R.class)
        {
            R r = (R)obj;
            return r.count == this.count;
        }
        return false;
    }
    //根据count属性值来判断两个对象的大小。
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        return count > r.count ? 1 :
            count < r.count ? -1 : 0;
    }
}
public class TreeMapTest
{
    public static void main(String[] args) 
    {
        TreeMap tm = new TreeMap();
        tm.put(new R(3) , "轻量级Java EE企业应用实战");
        tm.put(new R(-5) , "疯狂Java讲义");
        tm.put(new R(9) , "疯狂Android讲义");

        System.out.println(tm);

        //返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());

        //返回该TreeMap的最后一个key值
        System.out.println(tm.lastKey());

        //返回该TreeMap的比new R(2)大的最小key值。
        System.out.println(tm.higherKey(new R(2)));

        //返回该TreeMap的比new R(2)小的最大的key-value对。
        System.out.println(tm.lowerEntry(new R(2)));

        //返回该TreeMap的子TreeMap
        System.out.println(tm.subMap(new R(-1) , new R(4)));
    }
}

import java.util.*;

/**
*如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让key所引用的对象具有任何强引用，否则将失*去使用WeakHashMap的意义
*/
public class WeakHashMapTest
{
    public static void main(String[] args) 
    {
        WeakHashMap whm = new WeakHashMap();
        //将WeakHashMap中添加三个key-value对，
        //三个key都是匿名字符串对象（没有其他引用）
        whm.put(new String("语文") , new String("良好"));
        whm.put(new String("数学") , new String("及格"));
        whm.put(new String("英文") , new String("中等"));

        //将WeakHashMap中添加一个key-value对，
        //该key是一个系统缓存的字符串对象。"java"是一个常量字符串强引用
        whm.put("java" , new String("中等"));
        //输出whm对象，将看到4个key-value对。
        System.out.println(whm);
        //通知系统立即进行垃圾回收
        System.gc();
        System.runFinalization();
        //通常情况下，将只看到一个key-value对。
        System.out.println(whm);
    }
}

import java.util.*;

public class IdentityHashMapTest
{
    public static void main(String[] args) 
    {
        IdentityHashMap ihm = new IdentityHashMap();
        //下面两行代码将会向IdentityHashMap对象中添加两个key-value对
        ihm.put(new String("语文") , 89);
        ihm.put(new String("语文") , 78);

        //下面两行代码只会向IdentityHashMap对象中添加一个key-value对
        ihm.put("java" , 93);
        ihm.put("java" , 98);
        System.out.println(ihm);
    }
}

import java.util.*;

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}
public class EnumMapTest
{
    public static void main(String[] args) 
    {
        //创建一个EnumMap对象，该EnumMap的所有key
        //必须是Season枚举类的枚举值
        EnumMap enumMap = new EnumMap(Season.class);
        enumMap.put(Season.SUMMER , "夏日炎炎");
        enumMap.put(Season.SPRING , "春暖花开");
        System.out.println(enumMap);
    }
}

//与创建普通Map有所区别的是，创建EnumMap是必须指定一个枚举类，从而将该EnumMap和指定枚举类关联起来

1) HashMap和Hashtable的效率大致相同，因为它们的实现机制几乎完全一样。但HashMap通常比Hashtable要快一点，因为Hashtable需要额外的线程同步控制
2) TreeMap通常比HashMap、Hashtable要慢(尤其是在插入、删除key-value对时更慢)，因为TreeMap底层采用红黑树来管理key-value对
3) 使用TreeMap的一个好处就是： TreeMap中的key-value对总是处于有序状态，无须专门进行排序操作