Map、Set、List、Queue、Stack的特点与用法2

2. 定制排序

TreeSet的自然排序是根据集合元素的大小，TreeSet将它们以升序排序。如果我们需要实现定制排序，则可以通过Comparator接口的帮助(类似PHP中的array_map回调处理函数的思想)。该接口里包含一个int compare(T o1， T o2)方法，该方法用于比较大小

import java.util.*;class M{    int age;    public M(int age)    {        this.age = age;    }    public String toString()    {        return "M[age:" + age + "]";    }}public class TreeSetTest4{    public static void main(String[] args)     {        TreeSet ts = new TreeSet(new Comparator()        {            //根据M对象的age属性来决定大小            public int compare(Object o1, Object o2)            {                M m1 = (M)o1;                M m2 = (M)o2;                return m1.age > m2.age ? -1                    : m1.age < m2.age ? 1 : 0;            }        });            ts.add(new M(5));        ts.add(new M(-3));        ts.add(new M(9));        System.out.println(ts);    }}

看到这里，我们需要梳理一下关于排序的概念

1) equals、compareTo决定的是怎么比的问题，即用什么field进行大小比较2) 自然排序、定制排序、Comparator决定的是谁大的问题，即按什么顺序(升序、降序)进行排序它们的关注点是不同的，一定要注意区分

EnumSet

 

import java.util.*;enum Season{    SPRING,SUMMER,FALL,WINTER}public class EnumSetTest{    public static void main(String[] args)     {        //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值        EnumSet es1 = EnumSet.allOf(Season.class);        //输出[SPRING,SUMMER,FALL,WINTER]        System.out.println(es1);        //创建一个EnumSet空集合，指定其集合元素是Season类的枚举值。        EnumSet es2 = EnumSet.noneOf(Season.class);         //输出[]        System.out.println(es2);         //手动添加两个元素        es2.add(Season.WINTER);        es2.add(Season.SPRING);        //输出[SPRING,WINTER]        System.out.println(es2);        //以指定枚举值创建EnumSet集合        EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER);         //输出[SUMMER,WINTER]        System.out.println(es3);        EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER);         //输出[SUMMER,FALL,WINTER]        System.out.println(es4);        //新创建的EnumSet集合的元素和es4集合的元素有相同类型，        //es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值        EnumSet es5 = EnumSet.complementOf(es4);         //输出[SPRING]        System.out.println(es5);    }}

以上就是Set集合类的编程应用场景。那么应该怎样选择何时使用这些集合类呢？

1) HashSet的性能总是比TreeSet好(特别是最常用的添加、查询元素等操作)，因为TreeSet需要额外的红黑树算法来维护集合元素的次序。只有当需要一个保持排序的Set时，才应该使用TreeSet，否则都应该使用HashSet2) 对于普通的插入、删除操作，LinkedHashSet比HashSet要略慢一点，这是由维护链表所带来的开销造成的。不过，因为有了链表的存在，遍历LinkedHashSet会更快3) EnumSet是所有Set实现类中性能最好的，但它只能保存同一个枚举类的枚举值作为集合元素4) HashSet、TreeSet、EnumSet都是"线程不安全"的，通常可以通过Collections工具类的synchronizedSortedSet方法来"包装"该Set集合。SortedSet s = Collections.synchronizedSortedSet(new TreeSet(...));

 

0x2: List

ArrayList

如果一开始就知道ArrayList集合需要保存多少元素，则可以在创建它们时就指定initialCapacity大小，这样可以减少重新分配的次数，提供性能，ArrayList还提供了如下方法来重新分配Object[]数组

1) ensureCapacity(int minCapacity): 将ArrayList集合的Object[]数组长度增加minCapacity2) trimToSize(): 调整ArrayList集合的Object[]数组长度为当前元素的个数。程序可以通过此方法来减少ArrayList集合对象占用的内存空间

import java.util.*;public class ListTest{    public static void main(String[] args)     {        List books = new ArrayList();        //向books集合中添加三个元素        books.add(new String("轻量级Java EE企业应用实战"));        books.add(new String("疯狂Java讲义"));        books.add(new String("疯狂Android讲义"));        System.out.println(books);        //将新字符串对象插入在第二个位置        books.add(1 , new String("疯狂Ajax讲义"));        for (int i = 0 ; i < books.size() ; i++ )        {            System.out.println(books.get(i));        }        //删除第三个元素        books.remove(2);        System.out.println(books);        //判断指定元素在List集合中位置：输出1，表明位于第二位        System.out.println(books.indexOf(new String("疯狂Ajax讲义")));  //①        //将第二个元素替换成新的字符串对象        books.set(1, new String("LittleHann"));        System.out.println(books);        //将books集合的第二个元素（包括）        //到第三个元素（不包括）截取成子集合        System.out.println(books.subList(1 , 2));    }

Stack

注意Stack的后进先出的特点

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

LinkedList

import java.util.*;public class LinkedListTest{    public static void main(String[] args)     {        LinkedList books = new LinkedList();        //将字符串元素加入队列的尾部(双端队列)        books.offer("疯狂Java讲义");        //将一个字符串元素加入栈的顶部(双端队列)        books.push("轻量级Java EE企业应用实战");        //将字符串元素添加到队列的头(相当于栈的顶部)        books.offerFirst("疯狂Android讲义");        for (int i = 0; i < books.size() ; i++ )        {            System.out.println(books.get(i));        }        //访问、并不删除栈顶的元素        System.out.println(books.peekFirst());        //访问、并不删除队列的最后一个元素        System.out.println(books.peekLast());        //将栈顶的元素弹出"栈"        System.out.println(books.pop());        //下面输出将看到队列中第一个元素被删除        System.out.println(books);        //访问、并删除队列的最后一个元素        System.out.println(books.pollLast());        //下面输出将看到队列中只剩下中间一个元素：        //轻量级Java EE企业应用实战        System.out.println(books);    }}

从代码中我们可以看到，LinkedList同时表现出了双端队列、栈的用法。功能非常强大

 

0x3: Queue

PriorityQueue

import java.util.*;public class PriorityQueueTest{    public static void main(String[] args)     {        PriorityQueue pq = new PriorityQueue();        //下面代码依次向pq中加入四个元素        pq.offer(6);        pq.offer(-3);        pq.offer(9);        pq.offer(0);        //输出pq队列，并不是按元素的加入顺序排列，        //而是按元素的大小顺序排列，输出[-3, 0, 9, 6]        System.out.println(pq);        //访问队列第一个元素，其实就是队列中最小的元素：-3        System.out.println(pq.poll());    }}

PriorityQueue不允许插入null元素，它还需要对队列元素进行排序，PriorityQueue的元素有两种排序方式

1) 自然排序:采用自然顺序的PriorityQueue集合中的元素对象都必须实现了Comparable接口，而且应该是同一个类的多个实例，否则可能导致ClassCastException异常2) 定制排序创建PriorityQueue队列时，传入一个Comparator对象，该对象负责对队列中的所有元素进行排序关于自然排序、定制排序的原理和之前说的TreeSet类似

 ArrayDeque

import java.util.*;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);    }}

以上就是List集合类的编程应用场景。我们来梳理一下思路

1. java提供的List就是一个"线性表接口"，ArrayList(基于数组的线性表)、LinkedList(基于链的线性表)是线性表的两种典型实现2. Queue代表了队列，Deque代表了双端队列(既可以作为队列使用、也可以作为栈使用)3. 因为数组以一块连续内存来保存所有的数组元素，所以数组在随机访问时性能最好。所以的内部以数组作为底层实现的集合在随机访问时性能最好。4. 内部以链表作为底层实现的集合在执行插入、删除操作时有很好的性能5. 进行迭代操作时，以链表作为底层实现的集合比以数组作为底层实现的集合性能好

我们之前说过，Collection接口继承了Iterable接口，也就是说，我们以上学习到的所有的Collection集合类都具有"可遍历性"

Iterable接口也是java集合框架的成员，它隐藏了各种Collection实现类的底层细节，向应用程序提供了遍历Collection集合元素的统一编程接口:

1) boolean hasNext(): 是否还有下一个未遍历过的元素2) Object next(): 返回集合里的下一个元素3) void remove(): 删除集合里上一次next方法返回的元素

iterator实现遍历:

import java.util.*;public class IteratorTest{    public static void main(String[] args)     {        //创建一个集合        Collection books = new HashSet();        books.add("轻量级Java EE企业应用实战");        books.add("疯狂Java讲义");        books.add("疯狂Android讲义");        //获取books集合对应的迭代器        Iterator it = books.iterator();        while(it.hasNext())        {            //it.next()方法返回的数据类型是Object类型，            //需要强制类型转换            String book = (String)it.next();            System.out.println(book);            if (book.equals("疯狂Java讲义"))            {                //从集合中删除上一次next方法返回的元素                it.remove();            }            //对book变量赋值，不会改变集合元素本身            book = "测试字符串";            }        System.out.println(books);    }}

从代码可以看出，iterator必须依附于Collection对象，若有一个iterator对象，必然有一个与之关联的Collection对象。

除了可以使用iterator接口迭代访问Collection集合里的元素之外，使用java5提供的foreach循环迭代访问集合元素更加便捷

foreach实现遍历:

import java.util.*;public class ForeachTest{    public static void main(String[] args)     {        //创建一个集合        Collection books = new HashSet();        books.add(new String("轻量级Java EE企业应用实战"));        books.add(new String("疯狂Java讲义"));        books.add(new String("疯狂Android讲义"));        for (Object obj : books)        {            //此处的book变量也不是集合元素本身            String book = (String)obj;            System.out.println(book);            if (book.equals("疯狂Android讲义"))            {                //下面代码会引发ConcurrentModificationException异常                //books.remove(book);                  }        }        System.out.println(books);    }}

除了Collection固有的iterator()方法，List还额外提供了一个listIterator()方法，该方法返回一个ListIterator对象，ListIterator接口继承了Iterator接口，提供了专门操作List的方法。ListIterator接口在Iterator接口的继承上增加了如下方法:

1) boolean hasPrevious(): 返回该迭代器关联的集合是否还有上一个元素2) Object previous(): 返回该迭代器的上一个元素(向前迭代)3) void add(): 在指定位置插入一个元素

ListIterator实现遍历:

import java.util.*;public class ListIteratorTest{    public static void main(String[] args)     {        String[] books = {            "疯狂Java讲义",            "轻量级Java EE企业应用实战"        };        List bookList = new ArrayList();        for (int i = 0; i < books.length ; i++ )        {            bookList.add(books[i]);        }        ListIterator lit = bookList.listIterator();        while (lit.hasNext())        {            System.out.println(lit.next());            lit.add("-------分隔符-------");        }        System.out.println("=======下面开始反向迭代=======");        while(lit.hasPrevious())        {            System.out.println(lit.previous());        }    }}

 

0x4: Map

HashMap、Hashtable

import java.util.*;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()的返回值也应该相同

LinkedHashMap

import java.util.*;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));        }    }}

Properties

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对

TreeMap

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)));    }}

从代码中可以看出，类似于TreeSet中判断两个元素是否相等的标准，TreeMap中判断两个key相等的标准是: 

1) 两个key通过compareTo()方法返回02) equals()放回true

我们在重写这两个方法的时候一定要保证它们的逻辑关系一致。

再次强调一下:

Set和Map的关系十分密切，java源码就是先实现了HashMap、TreeMap等集合，然后通过包装一个所有的value都为null的Map集合实现了Set集合类

WeakHashMap

import java.util.*;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);    }}

如果需要使用WeakHashMap的key来保留对象的弱引用，则不要让key所引用的对象具有任何强引用，否则将失去使用WeakHashMap的意义

IdentityHashMap

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);    }} 

EnumMap

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和指定枚举类关联起来

以上就是Map集合类的编程应用场景。我们来梳理一下思路

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