Java学习第六篇:集合类

一.Java集合类框架

Java集合大致可分为Set、List和Map三种体系，其中Set代表无序、不可重复的集合；List代表有序、重复的集合；而Map则代表具有映射关系的集合；从Java5以后，Java又增加了Queue体系集合，代表一种队列集合的实现。

Java的集合类主要由两个接口派生而来：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含一些子接口或实现类。Collection和Map接口、子接口及其实现类的继承树如下图所示。对于Set、List、Queue和Map四种集合，最常用的是HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList和HashMap、TreeMap等。

二.Collection和Iterator接口

1.Collection接口

Collection接口是List、Set和Queue接口的父接口，该接口里定义的方法既可用于Set集合，也可以用于操作List和Queue集合。Collection接口里定义的方法见Java API文档。

import java.util.*;
public class CollectionTest {
    public static void main(String[] args) {
        Collection c=new ArrayList();
        //虽然集合里不能放基本类型的值,但Java支持自动装箱
        //关于自动装箱,见http://www.cnblogs.com/danne823/archive/2011/04/22/2025332.html
        //添加元素
        c.add("孙悟空");
        c.add(6);
        System.out.println("c集合的元素个数为:"+c.size());

        //删除指定元素
        c.remove(6);
        System.out.println("c集合的元素个数为:"+c.size());
        //判断是否包含指定字符串
        System.out.println("c集合是否包含\"孙悟空\"字符串:"+c.contains("孙悟空"));

        c.add("Java");
        System.out.println("c的集合元素:"+c);

        Collection books=new HashSet();
        books.add("Java");
        books.add("C++");
        System.out.println("c集合是否完全包含books集合?"+c.containsAll(books));

        //用c集合减去books集合里的元素
        c.removeAll(books);
        System.out.println("c的集合元素:"+c);

        //删除c集合里的所有元素
        c.clear();
        System.out.println("c的集合元素:"+c);

        System.out.println("books的集合元素:"+books);
        //books集合里只剩下c集合里也包含的元素
        books.retainAll(c);
        System.out.println("books的集合元素:"+books);
    }
}

运行结果:

c集合的元素个数为:2
c集合的元素个数为:1
c集合是否包含"孙悟空"字符串:true
c的集合元素:[孙悟空, Java]
c集合是否完全包含books集合?false
c的集合元素:[孙悟空]
c的集合元素:[]
books的集合元素:[C++, Java]
books的集合元素:[]

2.Iterator接口

Iterator则主要用于遍历Collection集合中的元素，Iterator对象称为迭代器。Iterator接口里定义了如下三个方法：

aaarticlea/jpeg;base64,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" alt="" />

import java.util.*;
public class IteratorTest {
    public static void main(String[] args) {
        //创建集合
        Collection books=new HashSet();
        books.add("Java");
        books.add("C++");
        books.add("JavaScript");

        //获取books集合对应的迭代器
        Iterator iterator=books.iterator();
        while(iterator.hasNext()) {
            //iterator.next()方法返回的数据类型是Object类型
            //需要强制类型转换
            String book=(String)iterator.next();
            System.out.println(book);
            if(book.equals("Java")) {
                //从集合中删除上一次next方法返回的元素
                iterator.remove();
            }
        }

        //输出集合
        System.out.println(books);
    }
}

运行结果:

C++
JavaScript
Java
[C++, JavaScript]

注：当使用Iterator迭代访问Collection集合元素时，Collection集合里的元素不能被改变，只能通过Iterator的remove方法删除上一次next方法返回的集合元素才可以；否则将会引发java.util.ConcurrentModificationException异常。

import java.util.*;
public class IteratorErrorTest {
    public static void main(String[] args) {
        //创建集合
        Collection books=new HashSet();
        books.add("Java");
        books.add("C++");
        books.add("JavaScript");

        //获取books集合对应的迭代器
        Iterator iterator=books.iterator();
        while(iterator.hasNext()) {
            String book=(String)iterator.next();
            System.out.println(book);
            if(book.equals("C++")) {
                //使用Iterator迭代过程中,不可以修改集合元素,只能通过迭代器修改
                //下面的代码引发异常
                books.remove(book);
            }
        }
    }
}

运行结果:

3.使用foreach循环变量集合元素

除了使用迭代器Iterator接口迭代访问Collection集合元素之外，使用foreach循环遍历更加便捷。

import java.util.*;
public class ForeachTest {
    public static void main(String[] args) {
        //创建集合
        Collection books=new HashSet();
        books.add("C++");
        books.add("Java");
        books.add("JavaScript");

        //foreach循环遍历
        for (Object obj : books) {
            String book=(String)obj;
            System.out.println(book);
        }
    }
}

运行结果:

C++
JavaScript
Java

注：当使用foreach循环迭代访问集合元素时，同样不能改变该集合，否则将引发ConcurrentModificationException异常。

三.Set集合

Set集合不允许包含相同的元素，Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回的是true，Set就不会接受这两个对象；反之，只要两个对象用equals方法比较返回false，Set就会接受这两个对象。

import java.util.*;
public class SetTest {
    public static void main(String[] args) {
        //创建集合
        Set books=new HashSet();
        //添加
        books.add(new String("Java"));
        //books集合两次添加的字符串对象明显不是同一个对象(因为两次都调用了new关键字创建字符串)
        //这两个字符串使用==运算符判断肯定返回false，但通过equals方法比较则返回true，所以添加失败
        boolean result=books.add(new String("Java"));
        //集合里只有一个元素
        System.out.println(result+"--->"+books);
    }
}

运行结果:

false--->[Java]

1.HashSet集合

(1).HashSet集合的特点

①不能保证元素的排列顺序，顺序有可能发生变化;

②HashSet不是同步的，如果多个线程同时访问HashSet，则必须通过代码保证其同步;

③集合元素可以为null.

(2).HashSet判断集合元素相同的标准

当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的HashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。如果两个元素通过equals()方法比较返回true，但它们的hashCode()方法返回值不相等，HashSet将会把它们存储在不同的位置，依然可以添加成功。

import java.util.*;
public class HashSetTest {
    public static void main(String[] args) {
        HashSet books=new HashSet();
        books.add(new A());
        books.add(new A());
        books.add(new B());
        books.add(new B());
        books.add(new C());
        books.add(new C());
        System.out.println(books);
    }
}

//类A重写了equals,但没有重写hashCode
class A {
    public boolean equals(Object obj) {
        return true;
    }
}

//类B重写了hashCode,但没有重写equals
class B {
    public int hashCode() {
        return 1;
    }
}

//类C重写了equals和hashCode
class C {
    public boolean equals(Object obj) {
        return true;
    }
    public int hashCode() {
        return 2;
    }
}

运行结果:

[B@1, B@1, C@2, A@1afae45, A@39443f]

2.LinkedHashSet集合

LinkedHashSet使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。LinkedHashSet需要维护元素的插入顺序，因此性能低于HashSet，但在迭代访问Set里的全部元素时将有很好的性能，因为它以链表来维护内部的顺序。

import java.util.*;
public class LinkedHashSetTest {
    public static void main(String[] args) {
        //创建集合
        LinkedHashSet books=new LinkedHashSet();
        books.add("Java");
        books.add("C++");
        System.out.println(books);

        books.remove("Java");
        books.add("Java");
        System.out.println(books);
    }
}

运行结果:

[Java, C++]
[C++, Java]

3.TreeSet集合

TreeSet可以确保集合元素处于排序状态，与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素。

import java.util.*;
public class TreeSetTest {
    public static void main(String[] args) {
        //创建集合
        TreeSet nums=new TreeSet();
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);
        //输出集合元素
        System.out.println(nums);
        //输出第一个元素
        System.out.println(nums.first());
        //输出最后一个元素
        System.out.println(nums.last());
        //返回小于4的子集,不包含4
        System.out.println(nums.headSet(4));
        //返回大于5的子集,如果set中包含5,子集中也包含5
        System.out.println(nums.tailSet(5));
        //返回大于等于-3、小于4的子集
        System.out.println(nums.subSet(-3, 4));
    }
}

运行结果:

[-9, 2, 5, 10]
-9
10
[-9, 2]
[5, 10]
[2]

TreeSet支持两种排序方法：自然排序和定制排序。在默认情况下，TreeSet采用自然排序。

(1).自然排序

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排序，这种方式就是自然排序。当一个对象调用该方法与另一个对象进行比较时，例如obj1.compareTo(obj2)，如果该方法返回0，则表明这两个对象相等；如果该方法返回一个正整数，则表明obj1大于obj2；如果该方法返回一个负整数，则表面obj1小于obj2.

如果向TreeSet添加的对象是程序员自定义类对象，则前提是用户自定义类实现了Comaprable接口；对于TreeSet集合而言，判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较返回0----如果返回0，则认为它们相等，否则认为它们不相等。

import java.util.*;
public class TreeSetTest2 {
    public static void main(String[] args) {
        TreeSet set=new TreeSet();
        Z z1=new Z(6);
        set.add(z1);
        //虽然是同一个对象,但依然添加成功,因为compareTo方法返回的不是0
        //所以自定义类重写compareTo和equals方法时,当equals方法返回true时,
        //compareTo方法应返回0
        System.out.println(set.add(z1));
        System.out.println(set);
        ((Z)(set.first())).age=9;
        System.out.println(((Z)(set.last())).age);
    }
}

class Z implements Comparable {
    int age;
    public Z(int age) {
        this.age=age;
    }

    //重写equals
    public boolean equals(Object obj) {
        return true;
    }

    //重写compareTo
    public int compareTo(Object obj) {
        return 1;
    }
}

运行结果:

true
[Z@55e55f, Z@55e55f]
9

import java.util.*;
public class TreeSetTest3 {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet();
        ts.add(new R(5));
        ts.add(new R(-3));
        ts.add(new R(9));
        ts.add(new R(-2));
        //打印TreeSet
        System.out.println(ts);
        //取出第一个元素
        R first=(R)ts.first();
        //对第一个元素的count赋值
        first.count=20;
        //取出最后一个元素
        R last=(R)ts.last();
        //对最后一个元素的count赋值
        last.count=-2;
        //打印TreeSet
        System.out.println(ts);
        //删除元素
        System.out.println(ts.remove(new R(-2)));
        System.out.println(ts);
        System.out.println(ts.remove(new R(5)));
        System.out.println(ts);
    }
}

class R implements Comparable {
    int count;
    public R(int count) {
        this.count=count;
    }

    //override
    public String toString() {
        return "R[count:"+count+"]";
    }

    //override
    public boolean equals(Object obj) {
        if(this==obj) {
            return true;
        }
        if(obj!=null && obj.getClass()==R.class) {
            R r=(R)obj;
            if(r.count==this.count) {
                return true;
            }
        }
        return false;
    }

    //Override
    public int compareTo(Object obj) {
        // TODO Auto-generated method stub
        R r=(R)obj;
        return this.count>r.count ? 1 :
                this.count<r.count ? -1 :0;
    }
}

运行结果:

[R[count:-3], R[count:-2], R[count:5], R[count:9]]
[R[count:20], R[count:-2], R[count:5], R[count:-2]]
false
[R[count:20], R[count:-2], R[count:5], R[count:-2]]
true
[R[count:20], R[count:-2], R[count:-2]]

(2).定制排序

如果要实现定制排序，例如降序排列，则可以通过Comparator接口帮助。该接口里包含一个int compare(T o1,T o2)方法，该方法用于比较o1和o2的大小，如果返回正整数，则o1大于o2；如果返回0，则o1等于o2；如果返回负整数，则o1小于o2.

import java.util.*;
public class TreeSetTest4 {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet(new Comparator() {
            //定制排序
            //@Override
            public int compare(Object obj1, Object obj2) {
                M m1=(M)obj1;
                M m2=(M)obj2;
                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);
    }
}

class M {
    int age;

    public M(int age) {
        this.age=age;
    }

    public String toString() {
        return "M[age:"+age+"]";
    }
}

运行结果:

[M[age:9], M[age:5], M[age:-3]]

4.EnumSet集合

EnumSet是一个专门为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。

import java.util.*;
public class EnumSetTest {
    public static void main(String[] args) {
        //创建一个EnumSet集合,集合元素就是Season枚举类的全部枚举值
        EnumSet es1=EnumSet.allOf(Season.class);
        System.out.println(es1);

        //创建一个空的EnumSet集合,指定其集合元素是Season类的枚举值
        EnumSet es2=EnumSet.noneOf(Season.class);
        System.out.println(es2);
        //添加元素
        es2.add(Season.WINTER);
        es2.add(Season.SPRING);
        System.out.println(es2);

        //以指定枚举值创建EnumSet集合
        EnumSet es3=EnumSet.of(Season.SUMMER,Season.WINTER);
        System.out.println(es3);

        //以某范围枚举值创建EnumSet集合
        EnumSet es4=EnumSet.range(Season.SUMMER, Season.WINTER);
        System.out.println(es4);

        //es5+es4=Season枚举类的全部枚举值
        EnumSet es5=EnumSet.complementOf(es4);
        System.out.println(es5);
    }
}

enum Season {
    SPRING,SUMMER,FALL,WINTER
}

运行结果:

[SPRING, SUMMER, FALL, WINTER]
[]
[SPRING, WINTER]
[SUMMER, WINTER]
[SUMMER, FALL, WINTER]
[SPRING]

5.各Set集合性能比较

四.List集合

List作为Collection接口的子接口，当然可以使用Collection接口里全部方法。而且由于List是有序集合，因此List集合里增加了一些根据索引来操作集合元素的方法，具体方法见Java API文档。

import java.util.*;
public class ListTest {
    public static void main(String[] args) {
        //创建集合对象
        List books=new ArrayList();

        //添加
        books.add("Java");
        books.add("C++");
        books.add("JavaScript");
        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集合中的位置
        System.out.println(books.indexOf(new String("Ajax")));

        //将第二个元素替换为新的字符串
        books.set(1, new String("PHP"));
        System.out.println(books);

        //截取子集合,第二个元素(包括)到第三个元素(不包括)
        System.out.println(books.subList(1, 2));
    }
}

运行结果:

[Java, C++, JavaScript]
Java
Ajax
C++
JavaScript
[Java, Ajax, JavaScript]
1
[Java, PHP, JavaScript]
[PHP]

1.ListIterator接口

List集合除了提供Iterator接口外，还提供了ListIterator接口，ListIterator接口在Iterator接口基础上增加了如下方法：

aaarticlea/jpeg;base64,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" alt="" />

import java.util.*;
public class ListIteratorTest {
    public static void main(String[] args) {
        String[] books={"Java","C++"};
        List booksList=new ArrayList();
        for(int i=0; i<books.length; i++) {
            booksList.add(books[i]);
        }

        //ListIterator接口
        ListIterator lit=booksList.listIterator();
        while(lit.hasNext()) {
            System.out.println(lit.next());
            lit.add("------分隔符------");
        }
        System.out.println("======反向迭代======");
        while(lit.hasPrevious()) {
            System.out.println(lit.previous());
        }
    }
}

运行结果:

Java
C++
======反向迭代======
------分隔符------
C++
------分隔符------
Java

从上面程序可以看出，使用ListIterator迭代List集合时，开始也需要采用正向迭代，即先使用next()方法进行迭代，在迭代过程中可以使用add()方法向上依次迭代元素后面添加一个新元素。

2.ArrayList和Vector实现类

ArrayList和Vector用法几乎完全相同，但有个显著区别：ArrayList是线程不安全的，当多个线程访问同一个ArrayList集合时，如果超过一个线程修改ArrayList集合，则程序必须手动保证集合的同步性；但Vector集合则是线程安全的。因为Vector是线程安全的，所以性能比ArrayList要低。实际上，即使需要保证List集合线程安全，也同样不推荐使用Vector实现类。后面会介绍一个Collections工具类，它可以将一个ArrayList变成线程安全的。

Vector还提供了一个Stack子类，用于模拟栈的数据结构，提供了如下方法：

aaarticlea/jpeg;base64,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" alt="" />

import java.util.*;
public class VectorTest {
    public static void main(String[] args) {
        Stack v=new Stack();
        v.push("Java");
        v.push("C++");
        v.push("PHP");
        System.out.println(v);

        System.out.println(v.peek());
        System.out.println(v);

        System.out.println(v.pop());
        System.out.println(v);

    }
}

运行结果:

[Java, C++, PHP]
PHP
[Java, C++, PHP]
PHP
[Java, C++]

五.Queue集合

1.PriorityQueue实现类

PriorityQueue保存队列元素的顺序并不是按加入队列的顺序，而是按队列元素的大小进行重新排序。因此当调用peek()方法或poll()方法取出队列元素时，并不是取出最先进入队列的元素，而是取出队列中最小的元素。

import java.util.*;
public class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue pq=new PriorityQueue();
        //添加
        pq.offer(6);
        pq.offer(-3);
        pq.offer(9);
        pq.offer(0);

        //输出
        System.out.println(pq);

        //访问第一个元素
        System.out.println(pq.peek());
    }
}

运行结果:

[-3, 0, 9, 6]
-3
PriorityQueue不允许插入null元素，它需要对队列元素进行排序，PriorityQueue的元素有两种排序方式：自然排序和定制排序。PriorityQueue队列对元素的要求和TreeSet对元素的要求基本一致，因此关于使用自然排序和定制排序参考TreeSet。

2.Deque接口与ArrayDeque实现类

Deque接口是Queue接口的子接口，它代表一个双端队列，Deque接口里定义方法允许从两端来操作队列的元素。另外，Deque不仅可以当成双端队列使用，而且可以当成栈来使用，所以当需要使用栈这种数据结构时，推荐使用ArrayDeque或LinkedList，而不是Stack。

import java.util.*;
/**
 * 将ArrayDeque当成栈使用
 */
public class ArrayDequeTest {
    public static void main(String[] args) {
        ArrayDeque st=new ArrayDeque();
        //元素push进栈
        st.push("Java");
        st.push("C++");
        st.push("PHP");
        //输出
        System.out.println(st);
        //访问第一个元素
        System.out.println(st.peek());
        System.out.println(st);
        //pop出第一个元素
        System.out.println(st.pop());
        System.out.println(st);
    }
}

运行结果:

[PHP, C++, Java]
PHP
[PHP, C++, Java]
PHP
[C++, Java]

3.LinkedList实现类

LinkedList类是List接口的实现类，这就意味着它是一个List集合，可以根据索引随机访问集合中的元素。除此之外，LinkedList还实现了Deque接口，因此它可以当作双端队列使用，自然也可以当作栈使用。

import java.util.*;
public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList books=new LinkedList();
        //将字符串加入队列尾部
        books.offer("Java");

        //将字符串加入栈顶部
        books.push("C++");

        //将字符串加入队列的头部
        books.offerFirst("PHP");

        //输出
        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());

        //输出
        System.out.println(books);
    }
}

运行结果:

PHP
C++
Java
PHP
Java
PHP
[C++, Java]
Java
[C++]

4.性能比较

(1).如果需要遍历List集合元素，对于ArrayList、Vector集合，应该使用随机访问方法(get)来遍历集合元素，这样性能更好；对于LinkedList集合，则应使用迭代器(Iterator)来遍历集合元素。

(2).如果需要经常执行插入、删除操作来改变List集合的大小，则应该使用LinkedList集合，而不是ArrayList。

(3).如果有多个线程需要同时访问List集合中的元素，开发者可考虑使用Collections将集合包装成线程安全的集合。

六.Map集合

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组用于保存Map里的value，key和value之间存在单向的一对一的关系，即通过指定的key，总能找到唯一的、确定的value。

1.HashMap和Hashtable实现类

HashMap和Hashtable存在两点显著区别：

①Hashtable是线程安全的Map实现，但HashMap是线程不安全的实现，所以HashMap比Hashtable性能高一点。

②Hashtable不允许使用null作为key和value，但HashMap可以使用null作为key或value。

HashMap、Hashtable判断两个key相等的标准是：两个key通过equals()方法比较返回true，两个key的hashCode值也相等。

HashMap、Hashtable判断两个value相等的标准是：只要两个对象同equals()方法比较返回true。

import java.util.*;
public class HashtableTest {
    public static void main(String[] args) {
        Hashtable ht=new Hashtable();
        ht.put(new A(60000), "Java");
        ht.put(new A(87563), "C++");
        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.println(ht.get(key));
        }
    }
}

class A {
    int count;

    public A(int count) {
        this.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;
    }

    public int hashCode() {
        return this.count;
    }
}

class B {
    public boolean equals(Object obj) {
        return true;
    }
}

运行结果:

{com.map.A@ea60=Java, com.map.A@1560b=C++, com.map.A@4d0=com.map.B@55e55f}
true
true
com.map.A@ea60------>Java
com.map.A@1560b------>C++

2.LinkedHashMap实现类

LinkedHashMap需要维护元素的插入顺序，因此性能低于HashMap的性能；但因为它以链表来维护内部的顺序，所以在迭代访问Map里的全部元素时有较好的性能。

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

        System.out.println("========================");
        //迭代遍历scores中的key-value对
        for(Iterator it=scores.keySet().iterator(); it.hasNext(); ) {
            Object key=it.next();
            System.out.println(key+ "------>"+scores.get(key));
        }
    }
}

运行结果:

语文----->80
英语----->82
数学----->76
========================
语文------>80
英语------>82
数学------>76

3.使用Properties读写属性文件

Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件，也可以把属性文件中的"属性名=属性值"加载到Map对象中。

import java.io.*;
import java.util.*;
public class PropertiesTest {
    public static void main(String[] args) throws Exception {
        Properties props=new Properties();
        //向Properties中添加属性
        props.setProperty("username", "admin");
        props.setProperty("password", "123456");

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

        //新建一个Properties对象
        Properties props2=new Properties();
        props2.setProperty("gender", "male");

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

        System.out.println(props2);
    }
}

运行结果:

{password=123456, gender=male, username=admin}

上面程序还在当前路径下生成一个a.ini文件，该文件内容如下：

#comment line
#Wed Dec 11 15:52:48 CST 2013
password=123456
username=admin

4.SortedMap接口和TreeMap实现类

正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类。所以具体可以参考SortedSet和TreeSet。

import java.util.*;
public class TreeMapTest {
    public static void main(String[] args) {
        TreeMap tm=new TreeMap();
        tm.put(new R(3), "Java");
        tm.put(new R(-5), "C++");
        tm.put(new R(9), "PHP");
        System.out.println(tm);

        //返回第一个key-value对
        System.out.println(tm.firstEntry());

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

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

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

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

class R implements Comparable {
    int count;
    public R(int count) {
        this.count=count;
    }

    //@override
    public String toString() {
        return "R[count:"+count+"]";
    }

    //@override
    public boolean equals(Object obj) {
        if(obj==this) {
            return true;
        }
        if(obj!=null && obj.getClass()==R.class) {
            R r=(R)obj;
            return (this.count==r.count);
        }
        return false;
    }

    //@Override
    public int compareTo(Object obj) {
        R r=(R)obj;
        return this.count>r.count ? 1 :
                this.count<r.count ? -1 : 0;
    }
}

运行结果:

{R[count:-5]=C++, R[count:3]=Java, R[count:9]=PHP}
R[count:-5]=C++
R[count:9]
R[count:3]
R[count:-5]=C++
{R[count:-5]=C++, R[count:3]=Java}

5.WeakHashMap实现类

WeakHashMap与HashMap的用法基本相似，与HashMap的区别在于，HashMap的key保留了对实际对象的强引用，但WeakHashMap的key只保留对实际对象的弱引用。

关于Java中强引用，软引用，弱引用和虚引用的介绍，请见http://java.chinaitlab.com/oop/716371.html 与 http://www.cnblogs.com/blogoflee/archive/2012/03/22/2411124.html

import java.util.*;
public class WeakHashMapTest {
    public static void main(String[] args) {
        WeakHashMap whm=new WeakHashMap();
        //三个key都是匿名的字符串对象,没有其他引用
        whm.put(new String("语文"), new String("良好"));
        whm.put(new String("数学"), new String("及格"));
        whm.put(new String("英语"), new String("中等"));

        //该key是一个系统缓存的字符串对象
        whm.put("Java", new String("优秀"));
        System.out.println(whm);

        //通知系统垃圾回收
        System.gc();
        System.runFinalization();
        System.out.println(whm);
    }
}

运行结果:

{Java=优秀, 数学=及格, 英语=中等, 语文=良好}
{Java=优秀}

6.IdentityHashMap实现类

IdentityHashMap实现类与HashMap基本相似，区别在于IdentityHashMap比较两个key相等是用==运算符，而HashMap是通过equals()方法。

import java.util.*;
public class IdentityHashMapTest {
    public static void main(String[] args) {
        IdentityHashMap ihm=new IdentityHashMap();
        ihm.put(new String("语文"), 89);
        ihm.put(new String("语文"), 89);

        ihm.put("Java", 93);
        ihm.put("Java", 98);

        System.out.println(ihm);
    }
}

运行结果:

{语文=89, Java=98, 语文=89}

7.EnumMap实现类

import java.util.*;
public class EnumMapTest {
    public static void main(String[] args) {
        EnumMap en=new EnumMap(Season.class);
        en.put(Season.SUMMER, "夏天");
        en.put(Season.SPRING, "春天");

        System.out.println(en);
    }
}

enum Season {
    SPRING,SUMMER,FALL,WINTER
}

运行结果:

{SPRING=春天, SUMMER=夏天}

8.性能比较

七.操作集合的工具类: Collections

Java提供了一个操作Set、List和Map等集合的工具类：Collections，该工具类提供了大量的方法对集合元素进行排序、查询和修改操作，还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。

1.排序

具体方法见Java API文档。

import java.util.*;
public class SortTest {
    public static void main(String[] args) {
        ArrayList nums=new ArrayList();
        nums.add(2);
        nums.add(-5);
        nums.add(3);
        nums.add(0);
        System.out.println(nums);

        //反转
        Collections.reverse(nums);
        System.out.println(nums);

        //排序
        Collections.sort(nums);
        System.out.println(nums);

        //随机打乱
        Collections.shuffle(nums);
        System.out.println(nums);
    }
}

运行结果:

[2, -5, 3, 0]
[0, 3, -5, 2]
[-5, 0, 2, 3]
[0, 2, 3, -5]

2.查找、替换操作

具体方法见Java API文档。

import java.util.*;
public class SearchTest {
    public static void main(String[] args) {
        ArrayList nums=new ArrayList();
        nums.add(2);
        nums.add(-5);
        nums.add(3);
        nums.add(0);
        System.out.println(nums);

        //输出最大,最小元素
        System.out.println(Collections.max(nums));
        System.out.println(Collections.min(nums));

        //用1替换0
        Collections.replaceAll(nums, 0, 1);
        System.out.println(nums);

        //返回-5出现的次数
        System.out.println(Collections.frequency(nums, -5));

        //二分查找-5在集合中的位置
        Collections.sort(nums);
        System.out.println(nums);
        System.out.println(Collections.binarySearch(nums, -5));
    }
}

运行结果:

[2, -5, 3, 0]
3
-5
[2, -5, 3, 1]
1
[-5, 1, 2, 3]
0

3.同步控制

Collections类中提供了多个synchronizedXxx()方法，该方法可以将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时线程安全的问题。

import java.util.*;
public class SynchronizedTest {
    public static void main(String[] args) {
        //创建List,Set,Map的线程安全版本
        List list=Collections.synchronizedList(new ArrayList());
        Set set=Collections.synchronizedSet(new HashSet());
        Map map=Collections.synchronizedMap(new HashMap());
    }
}

4.设置不可变集合

Collections提供了如下三类方法来返回一个不可变的集合：

aaarticlea/jpeg;base64,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" alt="" />

import java.util.*;
public class UnmodifiableTest {
    public static void main(String[] args) {
        //创建一个空的、不可边的List对象
        List list=Collections.emptyList();

        //创建一个只有一个元素,不变的Set对象
        Set set=Collections.singleton("Java");

        //创建一个普通的Map对象
        Map scores=new HashMap();
        scores.put("Chinese", 80);
        scores.put("English", 90);

        //返回普通的Map对象对应的不可变版本
        Map unmodifiableMap=Collections.unmodifiableMap(scores);

        //下面将出现异常
        list.add("Test");
        set.add("Test");
        unmodifiableMap.put("Math", 100);
    }
}