Java集合体系总结 Set、List、Map、Queue

时间 2020-03-17

标签 java 集合体系总结 set list map queue 栏目 Java 繁體版

原文原文链接

1、java集合类基本概念java

有时咱们须要集中存放多个数据，通常状况下，数组就是一个很好的选择，前提是咱们事先已经明确知道咱们将要保存的对象的数量。一旦在数组初始化时指定了这个数组长度。这样数组长度就不可变了，若是咱们想要保存一个能够动态增加的数据，java集合类就是一个很好的设计方案。算法

集合类主要负责保存其余数据，因此集合类通常也被成为容器类。因此的集合类都位于java.util包下。数据库

1) Collection

一组服从某种规则的元素
 　　1.1) List必须保持元素特定的顺序
 　　1.2) Set不能有重复元素
 　　1.3) Queue保持一个队列(先进先出)的顺序
2) Map

一组成对的"键值对"对象

Collection 和Map的区别在于容器中每一个位置保存元素的个数编程

(1)Collection 每一个位置只能保存一个元素
(2)Map 保存的是“键值对”，就像一个小型数据库。咱们能够经过键找到对应的值

2、Java集合类架构层次关系数组

1.Iterface Iterable安全

迭代器接口，这是Collection类的父接口。实现这个Iterable接口的对象容许使用foreach进行遍历，也就是说，全部的Collection集合对象都具备“foreach可遍历性”。这个Iterable接口只有一个方法：iterator（）。他返回一个表明当前集合对象的泛型<T>迭代器，用于以后的遍历操做。数据结构

1.1 Collection 架构

Collection 是最基本的集合接口，一个Collection表明一组Object的集合，这些Object被称做Collection的元素。Collection是一个接口，用以提供规范定义，不能被实例化使用框架

1）Set函数

Set集合相似于一个桶，放进Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素。

Set判断两个对象相同不是使用”==“运算符，而是根据equals方法。也就是说，咱们在加入一个新元素时，若是这个新元素对象和Set中已有对你好进行注意equals比较都返回false，则Ser就会接受这个新元素对象，不然拒绝。

由于Set的这个制约，在使用Set集合时，应该注意两点：1是Set集合里的元素的实现类实现一个有效的equals（Object）方法 2对Set的构造函数，传入的Collection参数不能包含重复的元素

1.1）HashSet

HastSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，所以具备良好的存取和查找性能。当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode（）方法来获得该对象的hashCode值，而后根据该HashCode值决定该对象在HashSet的存储位置。

1.1.1）LinkedHashSet

LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不一样是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存。

当遍历LinkedHashSet集合里的元素是，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。

LinkedHashSet须要维护元素的插入顺序，所以性能略低于HashSet的性能，但在迭代访问Set所有元素时，将会有很好的性能。

1.2）SortedSet

此接口主要用于排序操做，即实现此接口的子类都属于排序的子类

1.2.1）TreeSet

TreeSet是Sorted接口的实现类，TreeSet能够确保集合元素属于排序状态

1.3）EnumSet

EnumSet是一个专门为美剧类设计的集合类，EnumSet中全部元素都必须是指定悲剧类型的的枚举值，该枚举类型在建立Enumset时显示或隐式的指定。EnumSet的集合元素也是有序的。

2）List

List集合表明一个元素有序，可重复的集合，集合中每一个元素都有其对应的顺序索引。List集合容许加入重复元素，由于他能够经过索引来访问指位置的集合元素，list集合默认按元素的添加顺序设置元素的索引

2.1）ArrayList

ArrayList是基于数组实现的List类，他封装了一个动态的增加的，容许再分配的Object[]数组。

2.2）Vector

Vector和ArrayList在用法上几乎彻底相同，但因为Vector是一个古老的集合，因此Vector提供一些方法名很长的方法，以后将Vector改成实现List接口，统一纳入集合框架体系铜

2.2.1）Stack

Stack是Vector提供的一个子类，用于模拟栈这种数据结构

2.3)LinkedList

implement List<E>,Deque<E>。实现List接口，能对他进行队列操做，便可以根据索引来随机访问集合中元素。同时他还实现Deque接口，即能将LinkedList当作双端队列使用。天然也能够被当作“栈来使用”。

1.2Map

Map用于保存具备“映射关系”数据，所以Map集合里保存着两组值，一组值用于保存Map里的key，另一组值用于保存Map里的value。key和value均可以是任何引用类型的数据。Map的key不容许重复，即同一个Map对象的任何两个Key经过equals方法比较结果老是返回false；

Map的这些实现类和子接口中key集的存储形式和Set集合彻底相同（即key不能重复）

Map的这些实现类和子接口中value集的存储形式和List很是相似（即value能够重复，根据索引来查找）

1）HashMap

和HashSet不能保证元素的顺序同样，HashMap也不能保证key-value对的顺序。而且相似于HashSet判断两个key是否相等的标准也是：两个key经过equals（）方法比较返回true。

同时两个key的hashCode值也必须相等。

1.1）LinkedHashMap

LinkedHashMap也使用双向链表来维护key-value对的顺序，与key-value对的插入顺序一致（注意和TreeMap对全部的key-value进行排序进行区份）

2）HashTable

2.1）properties

3）sortedMap

正如Ser接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类同样，Map接口也派生出一个SortedMap实现类

3.1)TreeMap

TreeMap就是一个红黑树数据结构，每个key-value对即做为红黑树一个节点。TreeMap存储key-value对（节点）时，须要根据key对及诶单进行排序。TreeMap能够包含保证全部的key-value对都处于有序状态。一样，TreeMap也有两种排序方式：天然排序，定制排序

3.Java集合类的Demo

1.Set

HashSet

import java.util.*

//类A的equals()方法老是返回true，但没有重写其hashCode()方法。不能保证当前对象是HashSet的惟一对象

class A
{
  public bollean equals(Object obj)
  {
   return true;

  }
}
//类B的hashCode()方法老是返回true，但没有重写其equals()方法。不能保证当前对象是HashSet的惟一对象
class B
{
  public bollean hashCode(Object obj)
  {
   return 1;

  }
}
//类C的hashCode()方法老是返回2,且有重写其equals()方法
class C
{
    public int hashCode()
    {
        return 2;
    }
    public boolean equals(Object obj)
    {
        return true;
    }
}

 
public class HashSetTest
{
  public static void main(String[] args)
  {
        HashSet books=new HashSet();
       
         //分别向books集合中添加两个A对象，两个B对象，两个C对象

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

结果

[B@1, B@1, C@2, A@3bc257, A@785d65]

能够看出，若是两个对象经过equals（）方法比较返回true，但这两个对象的hashCode方法返回不一样的hashCode值时，这将致使HashSet会把这两个对象保存在Hash表的不一样位置，从而使对象能够添加成功，这就与Set集合的规则有些出入了。因此，咱们要明确的是：equals（）决定是否能够加入HashSet，而hashCode（）决定存放的位置，他们二者必须同时知足才能容许一个新元素加入HashSet。

可是要注意的是：若是两个对象的hashCode相同，可是他们的equals返回值不一样，HashSet会在这个位置用链式结构来保存多个对象。而HashSet访问集合元素时也是根据元素的HashCode的值来快速定位的，这种链式结构会致使性能降低。

因此若是须要把某个类的对象保存到HashSet集合中，咱们在重写这个类的equasl（）方法和hashCode（）方法时，应该尽可能保证两个对象经过equals（）方法毕节哦返回true时，他们hashCode（）方法返回值也相等。

LinkedHashSet

import java.util.*;
public class LinkedHashSetTest
{
  public static void main(String[] args)
  {
    LinkedHashSet books=new LinkedHashSet();
    books.add('Java1');
    books.add('Java2');  
    System.out.println(books);
    //删除 Java1
    books.remove("Java1");
    //从新添加 Java1
    books.add("Java1");
    System.out.println(books);
  }
}

输出

[Java1, Java2]
[Java1, Java2]

元素顺序老是与添加顺序一致，同时要明白的是，LinkedHashSetTest是HashSet的子类，由于它不容许集合元素重复

TreeSet

import java.util.*;

public class Test
{
    public static void main(String[] args)
    {
        TreeSet nums = new TreeSet();
        //向TreeSet中添加四个Integer对象
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);

        //输出集合元素，看到集合元素已经处于排序状态
        System.out.println(nums);
        [-9, 2, 5, 10]
        //输出集合里的第一个元素
        System.out.println(nums.first());
        -9
        //输出集合里的最后一个元素
        System.out.println(nums.last());
        10
        //返回小于4的子集，不包含4
        System.out.println(nums.headSet(4));
        [-9, 2]
        //返回大于5的子集，若是Set中包含5，子集中还包含5
        System.out.println(nums.tailSet(5));
        [5, 10]
        //返回大于等于-3，小于4的子集。
        System.out.println(nums.subSet(-3 , 4));
        [2]
    }
}

与HashSet集合采用hash算法来决定元素的存储位置不一样，TreeSet采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方式：天然排序，定制排序

1.天然排序

TreeSet 会调用集合元素的compareTo（Object obj）方法来比较元素之间的过小关系，而后将集合元素按升序排序，即天然排序，若是试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口，不然程序会抛出异常。

当把一个对象加入TreeSet集合中时，TreeSet会调用该对象的compareTo（Object obj）方法与容器中的其余对象比较大小，而后根据红黑树结构找到他的存储位置。若是两个对象经过compareTo（Object obj）方法比较相等，新对象将没法添加到TreeSet集合中（牢记Set不容许重复的概念）。

注意：当须要把一个对象放入TreeSet中，重写改对象对应类的equals（）方法是，应该保证该方法时，应该保证该方法与compareTo（Object obj）方法有一致的结果，即若是有两个对象经过equals（）方法比较返回true时，这两个对象经过compareTo（Object obj）方法比较结果应该也为0（即相等）

对与Set来讲，它定义了equals()为惟一性判断的标准，而对于到了具体的实现，HashSet、TreeSet来讲，它们又会有本身特有的惟一性判断标准，只有同时知足了才能断定为惟一性

2.定制排序

TreeSet的天然排序是根据集合元素的大小，TreeSet将它们以升序排序。若是咱们须要实现定制排序，则能够经过Comparator接口。该接口里包含一个int compare（to1，to2）方法，该方法用户比较大小。

import java.util.*;

class M
{
    int age;
    public M(int age)
    {
        this.age = age;
    }
    public String toString()
    {
        return "M[age:" + age + "]";
    }
}

public class  Test
{
    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);
    }
}

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

输出

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

以上是Set集合类的Demo，下面讲讲如何选择这些集合类呢？

（1）HashSet的性能老是比TreeSet好（贴别是最经常使用的添加、查询元素等操做），由于TreeSet须要额外的红黑树算法来维护集合元素的次序。只有当须要一个保持排序的Set时，才应该使用TreeSet，不然都应该使用HashSet

（2）对于普通的插入，删除操做，LinkedHashSet比HashSet略慢一线，这是因为维护链表所带来的开销形成的。不过，由于有了连接的存在，遍历LinkedHashSet会更快

（3）EnumSet是全部Set实现类中性能最好的，但它只能保存一个枚举类的枚举值做为集合元素。

（4）HashSet，TreeSet，EnumSet都是“线程不安全”的。

2.List

ArrayList

若是一开始就知道ArrayList集合须要保存多少元素，则能够在建立他们时就指定大小，这样能够减小从新分配的次数，提供性能，ArrayList还提供了以下方法来从新分配Object[]数组。

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

import java.util.*;

public class Test {
    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));
    }
}

输出

[轻量级Java EE企业应用实战, 疯狂Java讲义, 疯狂Android讲义]
轻量级Java EE企业应用实战
疯狂Ajax讲义
疯狂Java讲义
疯狂Android讲义
[轻量级Java EE企业应用实战, 疯狂Ajax讲义, 疯狂Android讲义]
1
[轻量级Java EE企业应用实战, LittleHann, 疯狂Android讲义]
[LittleHann]

Stack

注意Stack的后进先出的特色

import java.util.*;

public class Test
{
    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);
    }
}

输出

[疯狂Java讲义, 轻量级Java EE企业应用实战, 疯狂Android讲义]
疯狂Android讲义
[疯狂Java讲义, 轻量级Java EE企业应用实战, 疯狂Android讲义]
疯狂Android讲义
[疯狂Java讲义, 轻量级Java EE企业应用实战]

LinkedList

import java.util.*;

public class Test
{
    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);
    }
}

输出

疯狂Android讲义
轻量级Java EE企业应用实战
疯狂Java讲义
疯狂Android讲义
疯狂Java讲义
疯狂Android讲义
[轻量级Java EE企业应用实战, 疯狂Java讲义]
疯狂Java讲义
[轻量级Java EE企业应用实战]

Queue

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

[疯狂Android讲义, 轻量级Java EE企业应用实战, 疯狂Java讲义]
疯狂Android讲义
[疯狂Android讲义, 轻量级Java EE企业应用实战, 疯狂Java讲义]
疯狂Android讲义
[轻量级Java EE企业应用实战, 疯狂Java讲义]

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

java提供的List就是一个“线性表接口”，ArrayList（基于数组的线性表），LinkedList（基于链的线性表）是线性表的两种典型实现

Queue表明了队列，Deque表明了双端队列（便可以做为队列使用，也能够做为栈使用）

由于数组以一块连续内存来保存全部的数组元素，因此数组在随机访问时性能最好。

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

遍历

咱们以前说过，Collection接口继承了Iterable接口，也就是说，咱们以上学习到的全部的Collection集合类都具备"可遍历性"

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

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

iteration

import java.util.*;

public class Test
{
    public static void main(String[] args)
    {
        //建立一个集合
        Collection books=new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        //获取books集合对应的迭代器
        Iterator it=books.iterator();
        while(it.hasNext())
        {
            String book=(String)it.next();
            System.out.println(book);
            if (book.equals("2"))
            {
                //从集合中删除上一次next方法返回的元素
                it.remove();
            }
            //对book变量赋值，不会改变集合元素自己
            book = "测试字符串";
        }
        System.out.println(books);

    }
}

输出

3
2
1
[3, 1]

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

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

foreach 实现遍历

import java.util.*;

public class Test
{
    public static void main(String[] args)
    {
        //建立一个集合
        Collection books = new HashSet();
        books.add(new String("1"));
        books.add(new String("2"));
        books.add(new String("3"));

        for (Object obj : books)
        {
            //此处的book变量也不是集合元素自己
            String book = (String)obj;
            System.out.println(book);
            if (book.equals("2"))
            {
                //下面代码会引起ConcurrentModificationException异常
                //books.remove(book);
            }
        }
        System.out.println(books);
    }
}

输出

3
2
1
[3, 2, 1]

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 Test
{
    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");
        }
    }
}

输出

{A@ea60=疯狂Java讲义, A@1560b=轻量级Java EE企业应用实战, A@4d0=B@547c9586}
true
true
A@ea60---->疯狂Java讲义
A@1560b---->轻量级Java EE企业应用实战

当使用自定义类做为HashMap，Hashtable的key时，若是重写该类的equals（Object obj）和hashCode（）方法，则应该保证两个方法的判断标准一致-当两个key经过equals（）方法比较返回true时，两个key的hashCode（）的返回值也应该相同。

LinkedHashMap

import java.util.*;

public class Test
{
    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));
        }
    }
}

输出

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

properties

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

public class Test
{
    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);
    }
}

输出

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

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

输出

{R[count:-5]=疯狂Java讲义, R[count:3]=轻量级Java EE企业应用实战, R[count:9]=疯狂Android讲义}
R[count:-5]=疯狂Java讲义
R[count:9]
R[count:3]
R[count:-5]=疯狂Java讲义
{R[count:3]=轻量级Java EE企业应用实战}

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

1) 两个key经过compareTo()方法返回0
2) equals()放回true

EnumMap

import java.util.*;

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}
public class  Test
{
    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);
    }
}

输出

{SPRING=春暖花开, SUMMER=夏日炎炎}

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

以上就是Map集合类的编程小demo。咱们来梳理一下思路

（1）HashMap和Hashtable的效率大体相同，由于它们的实现机制几乎彻底同样。但HashMap一般比Hashtable要快一点，由于Hashtable须要二外的线程同步控制

（2）TreeMap一般比HashMap，Hashtable要慢（尤为是在插入，删除key-value对要慢），由于TreeMap底层采用的