本文转载自：http://www.cnblogs.com/frankliiu-java/articles/1944276.html 尊重原创html
介绍Java的实用工具类库java.util包。在这个包中，Java提供了一些实用的方法和数据结构。本章介绍Java的实用工具类库java.util包。在这个包中，Java提供了一些实用的方法和数据结构。例如，Java提供日期(Data)类、日历(Calendar)类来产生和获取日期及时间，提供随机数(Random)类产生各类类型的随机数，还提供了堆栈(Stack)、向量(Vector) 、位集合(Bitset)以及哈希表(Hashtable)等类来表示相应的数据结构。java
图1.1给出了java.util包的基本层次结构图。下面咱们将具体介绍其中几个重要的类。web
┌java.util.BitSet
│java.util.Calendar
│ └java.util.GregorianCalendar
│java.util.Date
│java.util.Dictionary
│ └java.util.Hashtable
│ └java.util.Properties
│java.util.EventObject
│java.util.ResourceBundle
┌普通类┤ ├java.util.ListResourceBundle
│ │ └java.util.PropertyResourceBundle
│ │java.util.Local
│ │java.util.Observable
│ │java.util.Random
│ │java.util.StringTokenizer
│ │java.util.Vector
│ │ └java.util.Stack
Java.util┤ └java.util.TimeZone
│ └java.util.SimpleTimeZone
│ ┌java.util.Enumeration
├接 口┤java.util.EventListener
│ └java.util.Observer
│ ┌java.util.EmptyStackException
└异常类┤java.util.MissingResourceException
│java.util.NoSuchElementException
└java.util.TooManyListenersException
图1.1 java.util包的基本层次结构算法
1.2 日期类Date编程
Java在日期类中封装了有关日期和时间的信息，用户能够经过调用相应的方法来获取系统时间或设置日期和时间。Date类中有不少方法在JDK1.0公布后已通过时了，在1.3中咱们将介绍JDK1.0中新加的用于替代Date的功能的其它类。
在日期类中共定义了六种构造函数。
(1)public Date()
建立的日期类对象的日期时间被设置成建立时刻相对应的日期时间。
例 Date today=new Date()；//today被设置成建立时刻相对应的日期时间。
(2)public Date (long date)
long 型的参数date能够经过调用Date类中的static方法parse(String s)来得到。
例 long l=Date.parse(“Mon 6 Jan 1997 13:3:00”);
Date day=new Date(l);
//day中时间为1997年 1月6号星期一，13:3:00。
(3)public Date(String s)
按字符串s产生一日期对象。s的格式与方法parse中字符串参数的模式相同。
例 Date day=new Date(“Mon 6 Jan 1997 13:3:00”);
//day 中时间为1997年1月6号星期一，13:3:00.
(4)public Date(int year,int month,int date)
(5)public Date(int year,int month,int date,int hrs,int min)
(6)public Date(int year,int month,int date,int hrs,int min,int sec)
按给定的参数建立一日期对象。
参数说明：
year的值为：需设定的年份-1900。例如需设定的年份是1997则year的值应为97，即1997-1900的结果。因此Date中可设定的年份最小为1900；
month的值域为0～11，0表明1月，11表表明12月；
date的值域在1～31之间；
hrs的值域在0～23之间。从午夜到第二天凌晨1点间hrs=0，从中午到下午1点间hrs=12；
min和sec的值域在0～59之间。
例 Date day=new Date(11,3,4);
//day中的时间为：04-Apr-11 12:00:00 AM
另外，还能够给出不正确的参数。
例 设定时间为1910年2月30日，它将被解释成3月2日。
Date day=new Date(10,1,30,10,12,34);
System.out.println(“Day’s date is:”+day);
//打印结果为：Day’s date is:Web Mar 02 10:13:34 GMT+08:00 1910
下面咱们给出一些Date类中经常使用方法。
(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
该方法将利用给定参数计算UTC值。UTC是一种计时体制，与GMT(格林威治时间)的计时体系略有差异。UTC计时体系是基于原子时钟的，而GTMT计时体系是基于天文学观测的。计算中使用的通常为GMT计时体系。
(2)public static long parse(String s)
该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(long date)时曾使用过这个方法。
字符串s有必定的格式，通常为：
(星期 日 年 时间GMT+时区)
若不注明时区，则为本地时区。
(3)public void setMonth(int month)
(4)public int getMonth()
这两个方法分别为设定和获取月份值。
获取的月份的值域为0～11，0表明1月，11表明12月。
(5)public String toString()数组
(6)public String toLocalString()
(7)public String toGMTString()浏览器
将给定日期对象转换成不一样格式的字符串。它们对应的具体的格式可参看例子8.1。
(8)public int getTimezoneOffset()bash
该方法用于获取日期对象的时区偏移量。
例1.1中对上面介绍的Date类中的基本方法进行了具体的应用，并打印了相应的结果。因为使用了一些过期的方法，因此编译时会有警告信息。另外，因为本例中的时间表示与平台有关，不一样的JDK版本对此处理不彻底相同，所以不一样版本的JDK执行本例的结果可能有细微差别。
例1.1 DateApp.java 数据结构
import java.lang.System;
import java.util.Date;
public class DateApp{
public static void main(String args[]){
Date today=new Date();
//today中的日期被设成建立时刻的日期和时间，假设建立时刻为1997年3月
//23日17时51分54秒。
System.out.println("Today's date is "+today);
//返回通常的时间表示法，本例中结果为
//Today's date is Fri May 23 17:51:54 1997
System.out.println("Today's date(Internet GMT)is:"
+today.toGMTString());
//返回结果为GMT时间表示法，本例中结果为
//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
System.out.println("Today's date(Locale) is:"
+today.toLocaleString());
//返回结果为本地习惯的时间表示法，结果为
//Today's date(Locale)is:05/23/97 17:51:54
System.out.println("Today's year is: "+today.getYear());
System.out.println("Today's month is: "+(today.getMonth()+1));
System.out.println("Today's date is: "+today.getDate());
//调用Date类中方法，获取年月日的值。
//下面调用了不一样的构造方法来建立Date类的对象。
Date day1=new Date(100,1,23,10,12,34);
System.out.println("Day1's date is: "+day1);
Date day2=new Date("Sat 12 Aug 1996 13:3:00");
System.out.println("Day2's date is: "+day2);
long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
Date day3= new Date(l);
System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
System.out.println("Day3's date(Locale)is: "
+day3.toLocaleString());
System.out.println("Day3's time zone offset is:"
+day3.getTimezoneOffset());
}
}
运行结果(JDK1.3版，与原文不一样，原文是JDK1.0版)：
E:/java/tutorial/java01>java DateApp
Today's date is Thu Dec 27 17:58:16 CST 2001
Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
Today's date(Locale) is:2001-12-27 17:58:16
Today's year is: 101
Today's month is: 12
Today's date is: 27
Day1's date is: Wed Feb 23 10:12:34 CST 2000
Day2's date is: Fri Aug 12 13:03:00 CST 1996
Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
Day3's date(Locale)is: 1996-8-5 13:03:00
Day3's time zone offset is:-480
E:/java/tutorial/java01>
1.3 日历类Calendardom
在早期的JDK版本中，日期(Date)类附有两大功能：(1)容许用年、月、日、时、分、秒来解释日期：(2)容许对表示日期的字符串进行格式化和句法分析。在JDK1.1中提供了类Calendar来完成第一种功能，类DateFormat来完成第二项功能。dateFormat是java.text包中的一个类。与Date类有所不一样的是，DateFormat类接受用各类语言和不一样习惯表示的日期字符串。本节将介绍java.util包中的类Calendar及其它新增长的相关的类。
类Calendar是一个抽象类，它完成日期(Date)类和普通日期表示法(即用一组整型域如YEAR，MONTH，DAY，HOUR表示日期)之间的转换。
因为所使用的规则不一样，不一样的日历系统对同一个日期的解释有所不一样。在JDK1.1中提供了Calendar类一个子类GregorianCalendar??它实现了世界上广泛使用的公历系统。固然用户也能够经过继承Calendar类，并增长所需规则，以实现不一样的日历系统。
第GregorianCalendar继承了Calendar类。本节将在介绍类GregorianCalendar的同时顺带介绍Calendar类中的相关方法。
类GregorianCalendar提供了七种构造函数：
(1)public GregorianCalendar()
建立的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间。
(2)public GregorianCalendar(TimeZone zone)
建立的对象中的相关值被设置成指定时区zone，缺省地点的当前时间。
(3)public GregorianCalendar(Locale aLocale)
建立的对象中的相关值被设置成缺省时区，指定地点aLocale的当前时间。
(4)public GregorianCalendar(TimeZone zone,Local aLocale)
建立的对象中的相关值被设置成指定时区，指定地点的当前时间。
上面使用到的类TimeZone的性质以下：
TimeZone是java.util包中的一个类，其中封装了有关时区的信息。每个时区对应一组ID。类TimeZone提供了一些方法完成时区与对应ID二者之间的转换。
(Ⅰ)已知某个特定的ID，能够调用方法
public static synchronized TimeZone getTimeZone(String ID)
来获取对应的时区对象。
例 太平洋时区的ID为PST，用下面的方法可获取对应于太平洋时区的时区对象：
TimeZone tz=TimeZone.getTimeZone(“PST”);
调用方法getDefault()能够获取主机所处时区的对象。
TimeZone tz=TimeZone.getDefault();
(Ⅱ)调用如下方法能够获取时区的ID
■public static synchronized String[] getavailableIDs(int rawOffset)
根据给定时区偏移值获取ID数组。同一时区的不一样地区的ID可能不一样，这是因为不一样地区对是否实施夏时制意见不统一而形成的。
例String s[]=TimeZone.getAvailableIDs(-7*60*60*1000);
打印s，结果为s[0]=PNT，s[1]=MST
■public static synchronized String[] getAvailableIDs()
获取提供的全部支持的ID。
■public String getID()
获取特定时区对象的ID。
例 TimeZone tz=TimeZone.getDefault();
String s=tz.getID();
打印s，结果为s=CTT。
上面使用类的对象表明了一个特定的地理、政治或文化区域。Locale只是一种机制，它用来标识一类对象，Local自己并不包含此类对象。
要获取一个Locale的对象有两种方法：
(Ⅰ)调用Locale类的构造方法
Locale(String language,String country)
Locale(String language,String country,String variant)
参数说明：language??在ISO-639中定义的代码，由两个小写字母组成。
country??在ISO-3166中定义的代码，由两个大写字母组成。
variant??售货商以及特定浏览器的代码，例如使用WIN表明Windows。
(Ⅱ)调用Locale类中定义的常量
Local类提供了大量的常量供用户建立Locale对象。
例 Locale.CHINA
为中国建立一个Locale的对象。
类TimeZone和类Locale中的其它方法，读者可查阅API。
(5)public GregorianCalendar(int year,int month,int date)
(6)public GregorianCalendar(int year,int month,int date,int hour,int minute)
(7)public GregorianCalendar(int year,int month,int date,int hour,int minute,int second)
用给定的日期和时间建立一个GregorianCalendar的对象。
参数说明：
year-设定日历对象的变量YEAR；month-设定日历对象的变量MONTH；
date-设定日历对象的变量DATE；hour-设定日历对象的变量HOUR_OF_DAY；
minute-设定日历对象的变量MINUTE；second-设定日历对象的变量SECOND。
与Date类中不一样的是year的值没有1900这个下限，并且year的值表明实际的年份。month的含义与Date类相同，0表明1月，11表明12月。
例 GregorianCalendar cal=new GregorianCalendar(1991,2,4)
cal的日期为1991年3月4号。
除了与Date中相似的方法外，Calendar类还提供了有关方法对日历进行滚动计算和数学计算。计算规则由给定的日历系统决定。进行日期计算时，有时会遇到信息不足或信息不实等特殊状况。Calendar采起了相应的方法解决这些问题。当信息不足时将采用缺省设置，在GregorianCalendar类中缺省设置通常为YEAR=1970,MONTH=JANUARY,DATE=1。
当信息不实时，Calendar将按下面的次序优先选择相应的Calendar的变量组合，并将其它有冲突的信息丢弃。
MONTH+DAY_OF_MONTH
MONTH+WEEK_OF_MONTH+DAY_OF_WEEK
MONTH+DAY_OF_WEEK_OF_MONTH+DAY_OF_WEEK
DAY_OF+YEAR
DAY_OF_WEEK_WEEK_OF_YEAR
HOUR_OF_DAY
1.4 随机数类Random
Java实用工具类库中的类java.util.Random提供了产生各类类型随机数的方法。它能够产生int、long、float、double以及Goussian等类型的随机数。这也是它与java.lang.Math中的方法Random()最大的不一样之处，后者只产生double型的随机数。
类Random中的方法十分简单，它只有两个构造方法和六个普通方法。
构造方法：
(1)public Random()
(2)public Random(long seed)
Java产生随机数须要有一个基值seed，在第一种方法中基值缺省，则将系统时间做为seed。
普通方法：
(1)public synonronized void setSeed(long seed)
该方法是设定基值seed。
(2)public int nextInt()
该方法是产生一个整型随机数。
(3)public long nextLong()
该方法是产生一个long型随机数。
(4)public float nextFloat()
该方法是产生一个Float型随机数。
(5)public double nextDouble()
该方法是产生一个Double型随机数。
(6)public synchronized double nextGoussian()
该方法是产生一个double型的Goussian随机数。
例1.2 RandomApp.java。
//import java.lang.*;
import java.util.Random;
public class RandomApp{
public static void main(String args[]){
Random ran1=new Random();
Random ran2=new Random(12345);
//建立了两个类Random的对象。
System.out.println("The 1st set of random numbers:");
System.out.println("/t Integer:"+ran1.nextInt());
System.out.println("/t Long:"+ran1.nextLong());
System.out.println("/t Float:"+ran1.nextFloat());
System.out.println("/t Double:"+ran1.nextDouble());
System.out.println("/t Gaussian:"+ran1.nextGaussian());
//产生各类类型的随机数
System.out.print("The 2nd set of random numbers:");
for(int i=0;i<5;i++){
System.out.println(ran2.nextInt()+" ");
if(i==2) System.out.println();
//产生同种类型的不一样的随机数。
System.out.println();//原文如此
}
}
}
运行结果：
E:/java01>java RandomApp
The 1st set of random numbers:
Integer:-173899656
Long:8056223819738127077
Float:0.6293638
Double:0.7888394520265607
Gaussian:0.5015701094568733
The 2nd set of random numbers:1553932502
-2090749135
-287790814
-355989640
-716867186
E:/java01>
1.5 向量类Vector
Java.util.Vector提供了向量(Vector)类以实现相似动态数组的功能。在Java语言中。正如在一开始就提到过，是没有指针概念的，但若是能正确灵活地使用指针又确实能够大大提升程序的质量，好比在C、C++中所谓”动态数组”通常都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类即是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
建立了一个向量类的对象后，能够往其中随意地插入不一样的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。对于预先不知或不肯预先定义数组大小，并需频繁进行查找、插入和删除工做的状况，能够考虑使用向量类。
向量类提供了三种构造方法：
public vector()
public vector(int initialcapacity,int capacityIncrement)
public vector(int initialcapacity)
使用第一种方法，系统会自动对向量对象进行管理。若使用后两种方法，则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小)，当真正存放的数据个数超过容量时，系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时，则每次扩充一倍。利用这个功能能够优化存储。
在Vector类中提供了各类方法方便用户使用：
■插入功能
(1)public final synchronized void addElement(Object obj)
将obj插入向量的尾部。obj能够是任何类的对象。对同一个向量对象，可在其中插入不一样类的对象。但插入的应是对象而不是数值，因此插入数值时要注意将数值转换成相应的对象。
例 要插入一个整数1时，不要直接调用v1.addElement(1)，正确的方法为：
Vector v1=new Vector();
Integer integer1=new Integer(1);
v1.addElement(integer1);
(2)public final synchronized void setElementAt(object obj,int index)
将index处的对象设成obj，原来的对象将被覆盖。
(3)public final synchronized void insertElementAt(Object obj,int index)
在index指定的位置插入obj，原来对象以及此后的对象依次日后顺延。
■删除功能
(1)public final synchronized void removeElement(Object obj)
从向量中删除obj。如有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
(2)public final synchronized void removeAllElement()
删除向量中全部的对象。
(3)public final synchronized void removeElementlAt(int index)
删除index所指的地方的对象。
■查询搜索功能
(1)public final int indexOf(Object obj)
从向量头开始搜索obj ,返回所遇到的第一个obj对应的下标，若不存在此obj，返回-1。
(2)public final synchronized int indexOf(Object obj,int index)
从index所表示的下标处开始搜索obj。
(3)public final int lastIndexOf(Object obj)
从向量尾部开始逆向搜索obj。
(4)public final synchronized int lastIndexOf(Object obj,int index)
从index所表示的下标处由尾至头逆向搜索obj。
(5)public final synchronized Object firstElement()
获取向量对象中的首个obj。
(6)public final synchronized Object lastelement()
获取向量对象中的最后一个obj。
了解了向量的最基本的方法后，咱们来看一下例8.3VectorApp.java。
例1.3 VectorApp.java。
import java.util.Vector;
import java.lang.*;//这一句不该该要，但原文如此
import java.util.Enumeration;
public class VectorApp{
public static void main(String[] args){
Vector v1=new Vector();
Integer integer1=new Integer(1);
v1.addElement("one");
//加入的为字符串对象
v1.addElement(integer1);
v1.addElement(integer1);
//加入的为Integer的对象
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
System.out.println("The vector v1 is:/n/t"+v1);
//将v1转换成字符串并打印
v1.insertElementAt("three",2);
v1.insertElementAt(new Float(3.9),3);
System.out.println("The vector v1(used method insertElementAt()) is:/n/t "+v1);
//往指定位置插入新的对象，指定位置后的对象依次日后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1(used method setElementAt()) is:/n/t "+v1);
//将指定位置的对象设置为新的对象
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1因为存在多个integer1因此从头开始
//找，删除找到的第一个integer1
Enumeration enum=v1.elements();
System.out.print("The vector v1(used method removeElement())is:");
while(enum.hasMoreElements())
System.out.print(enum.nextElement()+" ");
System.out.println();
//使用枚举类(Enumeration)的方法来获取向量对象的每一个元素
System.out.println("The position of object 1(top-to-bottom):"
+ v1.indexOf(integer1));
System.out.println("The position of object 1(tottom-to-top):"
+v1.lastIndexOf(integer1));
//按不一样的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new vector(resized the vector)is:"+v1);
//从新设置v1的大小，多余的元素被行弃
}
}
运行结果：
E:/java01>java VectorApp
The vector v1 is:
[one, 1, 1, two, 2, 1, 1]
The vector v1(used method insertElementAt()) is:
[one, 1, three, 3.9, 1, two, 2, 1, 1]
The vector v1(used method setElementAt()) is:
[one, 1, four, 3.9, 1, two, 2, 1, 1]
The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
The position of object 1(top-to-bottom):3
The position of object 1(tottom-to-top):7
The new vector(resized the vector)is:[one, four, 3.9, 1]
E:/java01>
从例1.3运行的结果中能够清楚地了解上面各类方法的做用，另外还有几点需解释。
(1)类Vector定义了方法
public final int size()
此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数，而非向量容量。能够调用方法capactly()来获取容量值。
方法：
public final synchronized void setsize(int newsize)
此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值，则超过部分的多余元素会丢失。
(2)程序中定义了Enumeration类的一个对象
Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法。
在Enumeration中提供了方法hawMoreElement()来判断集合中是束还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法能够依次得到集合中元素。
Vector中提供方法：
public final synchronized Enumeration elements()
此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法，以便于用户获取对应的枚举类型。
1.6 栈类Stack
Stack类是Vector类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。Stack类中提供了相应方法完成栈的有关操做。
基本方法：
public Object push(Object Hem)
将Hem压入栈中，Hem能够是任何类的对象。
public Object pop()
弹出一个对象。
public Object peek()
返回栈顶元素，但不弹出此元素。
public int search(Object obj)
搜索对象obj,返回它所处的位置。
public boolean empty()
判别栈是否为空。
例1.4 StackApp.java使用了上面的各类方法。
例1.4 StackApp.java。
import java.lang.*;
import java.util.*;
public class StackApp{
public static void main(String args[]){
Stack sta=new Stack();
sta.push("Apple");
sta.push("banana");
sta.push("Cherry");
//压入的为字符串对象
sta.push(new Integer(2));
//压入的为Integer的对象，值为2
sta.push(new Float(3.5));
//压入的为Float的对象，值为3.5
System.out.println("The stack is,"+sta);
//对应栈sta
System.out.println("The top of stack is:"+sta.peek());
//对应栈顶元素，但不将此元素弹出
System.out.println("The position of object Cherry is:"
+sta.search("cherry"));
//打印对象Cherry所处的位置
System.out.print("Pop the element of the stack:");
while(!sta.empty())
System.out.print(sta.pop()+" ");
System.out.println();
//将栈中的元素依次弹出并打印。与第一次打印的sta的结果比较，可看出栈
//先进后出的特色
}
}
运行结果(略)
1.7 哈希表类Hashtable
哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值做为自变量，经过必定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算获得存储地址所对应的存储单元。检索时采用检索关键码的方法。如今哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象，实现快速检索。
Java.util.Hashtable提供了种方法让用户使用哈希表，而不须要考虑其哈希表真正如何工做。
哈希表类中提供了三种构造方法，分别是：
public Hashtable()
public Hashtable(int initialcapacity)
public Hashtable(int initialCapacity,float loadFactor)
参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装载因子，是一个0.0到0.1之间的float型的浮点数。它是一个百分比，代表了哈希表什么时候须要扩充，例如，有一哈希表，容量为100，而装载因子为0.9，那么当哈希表90%的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。若是用户不赋这些参数，系统会自动进行处理，而不须要用户操心。
Hashtable提供了基本的插入、检索等方法。
■插入
public synchronized void put(Object key,Object value)
给对象value设定一关键字key,并将其加到Hashtable中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象Value。这代表在哈希表中相同的关键字不可能对应不一样的对象(从哈希表的基本思想来看，这也是显而易见的)。
■检索
public synchronized Object get(Object key)
根据给定关键字key获取相对应的对象。
public synchronized boolean containsKey(Object key)
判断哈希表中是否包含关键字key。
public synchronized boolean contains(Object value)
判断value是不是哈希表中的一个元素。
■删除
public synchronized object remove(object key)
从哈希表中删除关键字key所对应的对象。
public synchronized void clear()
清除哈希表
另外，Hashtalbe还提供方法获取相对应的枚举集合：
public synchronized Enumeration keys()
返回关键字对应的枚举对象。
public synchronized Enumeration elements()
返回元素对应的枚举对象。
例1.5 Hashtable.java给出了使用Hashtable的例子。
例1.5 Hashtalbe.java。
//import java.lang.*;
import java.util.Hashtable;
import java.util.Enumeration;
public class HashApp{
public static void main(String args[]){
Hashtable hash=new Hashtable(2,(float)0.8);
//建立了一个哈希表的对象hash，初始容量为2，装载因子为0.8
hash.put("Jiangsu","Nanjing");
//将字符串对象"Jiangsu"给定一关键字"Nanjing",并将它加入hash
hash.put("Beijing","Beijing");
hash.put("Zhejiang","Hangzhou");
System.out.println("The hashtable hash1 is: "+hash);
System.out.println("The size of this hash table is "+hash.size());
//打印hash的内容和大小
Enumeration enum1=hash.elements();
System.out.print("The element of hash is: ");
while(enum1.hasMoreElements())
System.out.print(enum1.nextElement()+" ");
System.out.println();
//依次打印hash中的内容
if(hash.containsKey("Jiangsu"))
System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
hash.remove("Beijing");
//删除关键字Beijing对应对象
System.out.println("The hashtable hash2 is: "+hash);
System.out.println("The size of this hash table is "+hash.size());
}
}
运行结果：
The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
The size of this hash table is 3
The element of hash is: Beijing Hangzhou Nanjing
The capatial of Jiangsu is Nanjing
The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
The size of this hash table is 2
Hashtable是Dictionary(字典)类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在java.util中还有一个类Properties，它是Hashtable的子类。用它能够进行与对象属性相关的操做。
1.8 位集合类BitSet
位集合类中封装了有关一组二进制数据的操做。
咱们先来看一下例8.6 BitSetApp.java。
例1.6 BitSetApp.java
//import java.lang.*;
import java.util.BitSet;
public class BitSetApp{
private static int n=5;
public static void main(String[] args){
BitSet set1=new BitSet(n);
for(int i=0;i<n;i++) set1.set(i);
//将set1的各位赋1，即各位均为true
BitSet set2= new BitSet();
set2=(BitSet)set1.clone();
//set2为set1的拷贝
set1.clear(0);
set2.clear(2);
//将set1的第0位set2的第2位清零
System.out.println("The set1 is: "+set1);
//直接将set1转换成字符串输出，输出的内容是set1中值true所处的位置
//打印结果为The set1 is:{1,2,3,4}
System.out.println("The hash code of set2 is: "+set2.hashCode());
//打印set2的hashCode
printbit("set1",set1);
printbit("set2",set2);
//调用打印程序printbit(),打印对象中的每个元素
//打印set1的结果为The bit set1 is: false true true true true
set1.and(set2);
printbit("set1 and set2",set1);
//完成set1 and set2,并打印结果
set1.or(set2);
printbit("set1 or set2",set1);
//完成set1 or set2,并打印结果
set1.xor(set2);
printbit("set1 xor set2",set1);
//完成set1 xor set2,并打印结果
}
//打印BitSet对象中的内容
public static void printbit(String name,BitSet set){
System.out.print("The bit "+name+" is: ");
for(int i=0;i<n;i++)
System.out.print(set.get(i)+" ");
System.out.println();
}
}
运行结果：
The set1 is: {1, 2, 3, 4}
The hash code of set2 is: 1225
The bit set1 is: false true true true true
The bit set2 is: true true false true true
The bit set1 and set2 is: false true false true true
The bit set1 or set2 is: true true false true true
The bit set1 xor set2 is: false false false false false
程序中使用了BitSet类提供的两种构造方法：
public BitSet();
public BitSet(int n);
参数n表明所建立的BitSet类的对象的大小。BitSet类的对象的大小在必要时会由系统自动扩充。
其它方法：
public void set(int n)
将BitSet对象的第n位设置成1。
public void clear(int n)
将BitSet对象的第n位清零。
public boolean get(int n)
读取位集合对象的第n位的值，它获取的是一个布尔值。当第n位为1时，返回true；第n位为0时，返回false。
另外，如在程序中所示，当把一BitSet类的对象转换成字符串输出时，输出的内容是此对象中true所处的位置。
在BitSet中提供了一组位操做，分别是：
public void and(BitSet set)
public void or(BitSet set)
public void xor(BitSet set)
利用它们能够完成两个位集合之间的与、或、异或操做。
BitSet类中有一方法public int size()来取得位集合的大小，它的返回值与初始化时设定的位集合大小n不同，通常为64。
线性表，链表，哈希表是经常使用的数据结构，在进行Java开发时，JDK已经为咱们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图经过简单的描述，向读者阐述各个类的做用以及如何正确使用这些类。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
Collection是最基本的集合接口，一个Collection表明一组Object，即Collection的元素（Elements）。一些Collection容许相同的元素而另外一些不行。一些能排序而另外一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
全部实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于建立一个空的Collection，有一个Collection参数的构造函数用于建立一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数容许用户复制一个Collection。
如何遍历Collection中的每个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子便可逐一访问Collection中每个元素。典型的用法以下：
Iterator it = collection.iterator(); // 得到一个迭代子
while(it.hasNext()) {
Object obj = it.next(); // 获得下一个元素
}
由Collection接口派生的两个接口是List和Set。
List接口
List是有序的Collection，使用此接口可以精确的控制每一个元素插入的位置。用户可以使用索引（元素在List中的位置，相似于数组下标）来访问List中的元素，这相似于Java的数组。
和下面要提到的Set不一样，List容许有相同的元素。
除了具备Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，容许添加，删除，设定元素，还能向前或向后遍历。
实现List接口的经常使用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
LinkedList实现了List接口，容许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操做使LinkedList可被用做堆栈（stack），队列（queue）或双向队列（deque）。
注意LinkedList没有同步方法。若是多个线程同时访问一个List，则必须本身实现访问同步。一种解决方法是在建立List时构造一个同步的List：
List list = Collections.synchronizedList(new LinkedList(…));
ArrayList类
ArrayList实现了可变大小的数组。它容许全部元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。可是add方法开销为分摊的常数，添加n个元素须要O(n)的时间。其余的方法运行时间为线性。
每一个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增长，可是增加算法并无定义。当须要插入大量元素时，在插入前能够调用ensureCapacity方法来增长ArrayList的容量以提升插入效率。
和LinkedList同样，ArrayList也是非同步的（unsynchronized）。
Vector类
Vector很是相似ArrayList，可是Vector是同步的。由Vector建立的Iterator，虽然和ArrayList建立的Iterator是同一接口，可是，由于Vector是同步的，当一个Iterator被建立并且正在被使用，另外一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，所以必须捕获该异常。
Stack 类
Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被看成堆栈使用。基本的push和pop方法，还有peek方法获得栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚建立后是空栈。
Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须当心操做可变对象（Mutable Object）。若是一个Set中的可变元素改变了自身状态致使Object.equals(Object)=true将致使一些问题。
Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每一个key只能映射一个value。Map接口提供3种集合的视图，Map的内容能够被看成一组key集合，一组value集合，或者一组key-value映射。
Hashtable类
Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象均可做为key或者value。
添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操做的时间开销为常数。
Hashtable经过initial capacity和load factor两个参数调整性能。一般缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor能够节省空间但相应的查找时间将增大，这会影响像get和put这样的操做。
使用Hashtable的简单示例以下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
要取出一个数，好比2，用相应的key：
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);
因为做为key的对象将经过计算其散列函数来肯定与之对应的value的位置，所以任何做为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，若是你用自定义的类看成key的话，要至关当心，按照散列函数的定义，若是两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但若是两个对象不一样，则它们的hashCode不必定不一样，若是两个不一样对象的hashCode相同，这种现象称为冲突，冲突会致使操做哈希表的时间开销增大，因此尽可能定义好的hashCode()方法，能加快哈希表的操做。
若是相同的对象有不一样的hashCode，对哈希表的操做会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只须要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
Hashtable是同步的。
HashMap类
HashMap和Hashtable相似，不一样之处在于HashMap是非同步的，而且容许null，即null value和null key。，可是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操做时间开销和HashMap的容量成比例。所以，若是迭代操做的性能至关重要的话，不要将HashMap的初始化容量设得太高，或者load factor太低。
WeakHashMap类 WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，若是一个key再也不被外部所引用，那么该key能够被GC回收。 总结 若是涉及到堆栈，队列等操做，应该考虑用List，对于须要快速插入，删除元素，应该使用LinkedList，若是须要快速随机访问元素，应该使用ArrayList。 若是程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，若是多个线程可能同时操做一个类，应该使用同步的类。 要特别注意对哈希表的操做，做为key的对象要正确复写equals和hashCode方法。 尽可能返回接口而非实际的类型，如返回List而非ArrayList，这样若是之后须要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。