实用工具类库java.util

本章介绍Java的实用工具类库java.util包。在这个包中，Java提供了一些实用的方法和数据结构。例如，Java提供日期(Data)类、日历(Calendar)类来产生和获取日期及时间，提供随机数(Random)类产生各种类型的随机数，还提供了堆栈(Stack)、向量(Vector)、位集合(Bitset)以及哈希表(Hashtable)等类来表示相应的数据结构。
　　图1.1给出了java.util包的基本层次结构图。下面我们将具体介绍其中几个重要的类。
　　　　　　　　　　　┌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.1java.util包的基本层次结构


1.2日期类Date

　　Java在日期类中封装了有关日期和时间的信息，用户可以通过调用相应的方法来获取系统时间或设置日期和时间。Date类中有很多方法在JDK1.0公布后已经过时了，在8.3中我们将介绍JDK1.0中新加的用于替代Date的功能的其它类。
　　在日期类中共定义了六种构造函数。
　　(1)publicDate()
　　创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。
　　例Datetoday=newDate()；//today被设置成创建时刻相对应的日期时间。
　　(2)publicDate(longdate)
　　long型的参数date可以通过调用Date类中的static方法parse(Strings)来获得。
　　例longl=Date.parse("Mon6Jan199713:3:00");
　　　　Dateday=newDate(l);
　　//day中时间为1997年1月6号星期一，13:3:00。
　　(3)publicDate(Strings)
　　按字符串s产生一日期对象。s的格式与方法parse中字符串参数的模式相同。
　　例Dateday=newDate("Mon6Jan199713:3:00");
　　//day中时间为1997年1月6号星期一，13:3:00.
　　(4)publicDate(intyear,intmonth,intdate)
　　(5)publicDate(intyear,intmonth,intdate,inthrs,intmin)
　　(6)publicDate(intyear,intmonth,intdate,inthrs,intmin,intsec)
　　按给定的参数创建一日期对象。
　　参数说明：
　　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之间。
　　例Dateday=newDate(11,3,4);
　　//day中的时间为：04-Apr-1112:00:00AM
另外，还可以给出不正确的参数。
　　例　设定时间为1910年2月30日，它将被解释成3月2日。
　　Dateday=newDate(10,1,30,10,12,34);
　　System.out.println("Day'sdateis:"+day);
　　//打印结果为：Day'sdateis:WebMar0210:13:34GMT+08:001910
　　下面我们给出一些Date类中常用方法。
　　(1)publicstaticlongUTC(intyear,intmonth,intdate,inthrs.intmin,intsec)
　　该方法将利用给定参数计算UTC值。UTC是一种计时体制，与GMT(格林威治时间)的计时体系略有差别。UTC计时体系是基于原子时钟的，而GTMT计时体系是基于天文学观测的。计算中使用的一般为GMT计时体系。
　　(2)publicstaticlongparse(Strings)
　　该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(longdate)时曾使用过这个方法。
　　字符串s有一定的格式，一般为：
　　(星期日年时间GMT+时区)
　　若不注明时区，则为本地时区。
　　(3)publicvoidsetMonth(intmonth)
　　(4)publicintgetMonth()
　　这两个方法分别为设定和获取月份值。
　　获取的月份的值域为0～11，0代表1月，11代表12月。
　　(5)publicStringtoString()
　　(6)publicStringtoLocalString()
　　(7)publicStringtoGMTString()
　　将给定日期对象转换成不同格式的字符串。它们对应的具体的格式可参看例子8.1。
　　(8)publicintgetTimezoneOffset()
　　该方法用于获取日期对象的时区偏移量。
　　例8.1中对上面介绍的Date类中的基本方法进行了具体的应用，并打印了相应的结果。由于使用了一些过时的方法，所以编译时会有警告信息。另外，由于本例中的时间表示与平台有关，不同的JDK版本对此处理不完全相同，因此不同版本的JDK执行本例的结果可能有细微差异。
　　例1.1DateApp.java
　　importjava.lang.System;
　　importjava.util.Date;
　　publicclassDateApp{
　　　publicstaticvoidmain(Stringargs[]){
　　　　Datetoday=newDate();
　　　　//today中的日期被设成创建时刻的日期和时间，假设创建时刻为1997年3月
　　　　//23日17时51分54秒。
　　　　System.out.println("Today'sdateis"+today);
　　　　//返回一般的时间表示法，本例中结果为
　　　　//Today'sdateisFriMay2317:51:541997
　　　　System.out.println("Today'sdate(InternetGMT)is:"
　　　　　+today.toGMTString());
　　　　//返回结果为GMT时间表示法，本例中结果为
　　　　//Today'sdate(InternetGMT)is:23May199709:51:54:GMT
　　　　System.out.println("Today'sdate(Locale)is:"
　　　　　+today.toLocaleString());
　　　　//返回结果为本地习惯的时间表示法，结果为
　　　　//Today'sdate(Locale)is:05/23/9717:51:54
　　　　System.out.println("Today'syearis:"+today.getYear());
　　　　System.out.println("Today'smonthis:"+(today.getMonth()+1));
　　　　System.out.println("Today'sdateis:"+today.getDate());
　　　　//调用Date类中方法，获取年月日的值。
　　　　//下面调用了不同的构造方法来创建Date类的对象。
　　　　Dateday1=newDate(100,1,23,10,12,34);
　　　　System.out.println("Day1'sdateis:"+day1);
　　　　Dateday2=newDate("Sat12Aug199613:3:00");
　　　　System.out.println("Day2'sdateis:"+day2);
　　　　longl=Date.parse("Sat5Aug199613:3:00GMT+0800");
　　　　Dateday3=newDate(l);
　　　　System.out.println("Day3'sdate(GMT)is:"+day3.toGMTString());
　　　　System.out.println("Day3'sdate(Locale)is:"
　　　　　+day3.toLocaleString());
　　　　System.out.println("Day3'stimezoneoffsetis:"
　　　　　+day3.getTimezoneOffset());
　　　}
　　}

　　运行结果(JDK1.3版，与原文不同，原文是JDK1.0版)：
　　E:\java\tutorial\java01>javaDateApp
　　Today'sdateisThuDec2717:58:16CST2001
　　Today'sdate(InternetGMT)is:27Dec200109:58:16GMT
　　Today'sdate(Locale)is:2001-12-2717:58:16
　　Today'syearis:101
　　Today'smonthis:12
　　Today'sdateis:27
　　Day1'sdateis:WedFeb2310:12:34CST2000
　　Day2'sdateis:FriAug1213:03:00CST1996
　　Day3'sdate(GMT)is:5Aug199605:03:00GMT
　　Day3'sdate(Locale)is:1996-8-513:03:00
　　Day3'stimezoneoffsetis:-480

　　E:\java\tutorial\java01>

1.3日历类Calendar

　　在早期的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)publicGregorianCalendar()
　　创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间。
　　(2)publicGregorianCalendar(TimeZonezone)
　　创建的对象中的相关值被设置成指定时区zone，缺省地点的当前时间。
　　(3)publicGregorianCalendar(LocaleaLocale)
　　创建的对象中的相关值被设置成缺省时区，指定地点aLocale的当前时间。
　　(4)publicGregorianCalendar(TimeZonezone,LocalaLocale)
　　创建的对象中的相关值被设置成指定时区，指定地点的当前时间。
　　上面使用到的类TimeZone的性质如下：
　　TimeZone是java.util包中的一个类，其中封装了有关时区的信息。每一个时区对应一组ID。类TimeZone提供了一些方法完成时区与对应ID两者之间的转换。
　　(Ⅰ)已知某个特定的ID，可以调用方法
　　publicstaticsynchronizedTimeZonegetTimeZone(StringID)
来获取对应的时区对象。
　　例太平洋时区的ID为PST，用下面的方法可获取对应于太平洋时区的时区对象：
　　TimeZonetz=TimeZone.getTimeZone("PST");
　　调用方法getDefault()可以获取主机所处时区的对象。
　　TimeZonetz=TimeZone.getDefault();
　　(Ⅱ)调用以下方法可以获取时区的ID
　　■publicstaticsynchronizedString[]getavailableIDs(intrawOffset)
　　根据给定时区偏移值获取ID数组。同一时区的不同地区的ID可能不同，这是由于不同地区对是否实施夏时制意见不统一而造成的。
　　例Strings[]=TimeZone.getAvailableIDs(-7*60*60*1000);
　　打印s，结果为s[0]=PNT，s[1]=MST
　　■publicstaticsynchronizedString[]getAvailableIDs()
　　获取提供的所有支持的ID。
　　■publicStringgetID()
　　获取特定时区对象的ID。
　　例TimeZonetz=TimeZone.getDefault();
　　Strings=tz.getID();
　　打印s，结果为s=CTT。
　　上面使用类的对象代表了一个特定的地理、政治或文化区域。Locale只是一种机制，它用来标识一类对象，Local本身并不包含此类对象。
　　要获取一个Locale的对象有两种方法：
　　(Ⅰ)调用Locale类的构造方法
　　Locale(Stringlanguage,Stringcountry)
　　Locale(Stringlanguage,Stringcountry,Stringvariant)
　　参数说明：language??在ISO-639中定义的代码，由两个小写字母组成。
　　　　　　　country??在ISO-3166中定义的代码，由两个大写字母组成。
　　　　　　　variant??售货商以及特定浏览器的代码，例如使用WIN代表Windows。
　　(Ⅱ)调用Locale类中定义的常量
　　Local类提供了大量的常量供用户创建Locale对象。
　　例Locale.CHINA
　　　　为中国创建一个Locale的对象。
　　类TimeZone和类Locale中的其它方法，读者可查阅API。
　　(5)publicGregorianCalendar(intyear,intmonth,intdate)
　　(6)publicGregorianCalendar(intyear,intmonth,intdate,inthour,intminute)
　　(7)publicGregorianCalendar(intyear,intmonth,intdate,inthour,intminute,intsecond)
　　用给定的日期和时间创建一个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月。
　　例GregorianCalendarcal=newGregorianCalendar(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)publicRandom()
　　(2)publicRandom(longseed)
　　Java产生随机数需要有一个基值seed，在第一种方法中基值缺省，则将系统时间作为seed。
　　普通方法：
　　(1)publicsynonronizedvoidsetSeed(longseed)
　　该方法是设定基值seed。
　　(2)publicintnextInt()
　　该方法是产生一个整型随机数。
　　(3)publiclongnextLong()
　　该方法是产生一个long型随机数。
　　(4)publicfloatnextFloat()
　　该方法是产生一个Float型随机数。
　　(5)publicdoublenextDouble()
　　该方法是产生一个Double型随机数。
　　(6)publicsynchronizeddoublenextGoussian()
　　该方法是产生一个double型的Goussian随机数。
　　例1.2RandomApp.java。
　　//importjava.lang.*;
　　importjava.util.Random;

　　publicclassRandomApp{
　　　publicstaticvoidmain(Stringargs[]){
　　　　Randomran1=newRandom();
　　　　Randomran2=newRandom(12345);
　　　　//创建了两个类Random的对象。
　　　　System.out.println("The1stsetofrandomnumbers:");
　　　　System.out.println("\tInteger:"+ran1.nextInt());
　　　　System.out.println("\tLong:"+ran1.nextLong());
　　　　System.out.println("\tFloat:"+ran1.nextFloat());
　　　　System.out.println("\tDouble:"+ran1.nextDouble());
　　　　System.out.println("\tGaussian:"+ran1.nextGaussian());
　　　　//产生各种类型的随机数
　　　　System.out.print("The2ndsetofrandomnumbers:");
　　　　for(inti=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+"");
　　　　　if(i==2)System.out.println();
　　　　　//产生同种类型的不同的随机数。
　　　　　System.out.println();//原文如此
　　　　}
　　　}
　　}

　　运行结果：
　　E:\java01>javaRandomApp
　　The1stsetofrandomnumbers:
　　　　Integer:-173899656
　　　　Long:8056223819738127077
　　　　Float:0.6293638
　　　　Double:0.7888394520265607
　　　　Gaussian:0.5015701094568733
　　The2ndsetofrandomnumbers:1553932502
　　-2090749135
　　-287790814
　　-355989640
　　-716867186
　　E:\java01>

1.5向量类Vector

　　Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中。正如在一开始就提到过，是没有指针概念的，但如果能正确灵活地使用指针又确实可以大大提高程序的质量，比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷，Java提供了丰富的类库来方便编程者使用，Vector类便是其中之一。事实上，灵活使用数组也可完成向量类的功能，但向量类中提供的大量方法大大方便了用户的使用。
　　创建了一个向量类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。对于预先不知或不愿预先定义数组大小，并需频繁进行查找、插入和删除工作的情况，可以考虑使用向量类。
　　向量类提供了三种构造方法：
　　publicvector()
　　publicvector(intinitialcapacity,intcapacityIncrement)
　　publicvector(intinitialcapacity)
　　使用第一种方法，系统会自动对向量对象进行管理。若使用后两种方法，则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小)，当真正存放的数据个数超过容量时，系统会扩充向量对象的存储容量。参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时，则每次扩充一倍。利用这个功能可以优化存储。
　　在Vector类中提供了各种方法方便用户使用：
　　■插入功能
　　(1)publicfinalsynchronizedvoidaddElement(Objectobj)
　　将obj插入向量的尾部。obj可以是任何类的对象。对同一个向量对象，可在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数值转换成相应的对象。
　　例要插入一个整数1时，不要直接调用v1.addElement(1)，正确的方法为：
　　Vectorv1=newVector();
　　Integerinteger1=newInteger(1);
　　v1.addElement(integer1);
　　(2)publicfinalsynchronizedvoidsetElementAt(objectobj,intindex)
　　将index处的对象设成obj，原来的对象将被覆盖。
　　(3)publicfinalsynchronizedvoidinsertElementAt(Objectobj,intindex)
　　在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。
　　■删除功能
　　(1)publicfinalsynchronizedvoidremoveElement(Objectobj)
　　从向量中删除obj。若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
　　(2)publicfinalsynchronizedvoidremoveAllElement()
　　删除向量中所有的对象。
　　(3)publicfinalsynchronizedvoidremoveElementlAt(intindex)
　　删除index所指的地方的对象。
　　■查询搜索功能
　　(1)publicfinalintindexOf(Objectobj)
　　从向量头开始搜索obj,返回所遇到的第一个obj对应的下标，若不存在此obj，返回-1。
　　(2)publicfinalsynchronizedintindexOf(Objectobj,intindex)
　　从index所表示的下标处开始搜索obj。
　　(3)publicfinalintlastIndexOf(Objectobj)
　　从向量尾部开始逆向搜索obj。
　　(4)publicfinalsynchronizedintlastIndexOf(Objectobj,intindex)
　　从index所表示的下标处由尾至头逆向搜索obj。
　　(5)publicfinalsynchronizedObjectfirstElement()
　　获取向量对象中的首个obj。
　　(6)publicfinalsynchronizedObjectlastelement()
　　获取向量对象中的最后一个obj。
　　了解了向量的最基本的方法后，我们来看一下例8.3VectorApp.java。
　　例1.3VectorApp.java。
　　importjava.util.Vector;
　　importjava.lang.*;//这一句不应该要，但原文如此
　　importjava.util.Enumeration;
　　publicclassVectorApp{
　　　publicstaticvoidmain(String[]args){
　　　　Vectorv1=newVector();
　　　　Integerinteger1=newInteger(1);
　　　　v1.addElement("one");
　　　　//加入的为字符串对象
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　//加入的为Integer的对象
　　　　v1.addElement("two");
　　　　v1.addElement(newInteger(2));
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　System.out.println("Thevectorv1is:\n\t"+v1);
　　　　//将v1转换成字符串并打印
　　　　v1.insertElementAt("three",2);
　　　　v1.insertElementAt(newFloat(3.9),3);
　　　　System.out.println("Thevectorv1(usedmethodinsertElementAt())is:\n\t"+v1);
　　　　//往指定位置插入新的对象，指定位置后的对象依次往后顺延
　　　　v1.setElementAt("four",2);
　　　　System.out.println("Thevectorv1(usedmethodsetElementAt())is:\n\t"+v1);
　　　　//将指定位置的对象设置为新的对象
　　　　v1.removeElement(integer1);
　　　　//从向量对象v1中删除对象integer1由于存在多个integer1所以从头开始
　　　　//找，删除找到的第一个integer1
　　　　Enumerationenum=v1.elements();
　　　　System.out.print("Thevectorv1(usedmethodremoveElement())is:");
　　　　while(enum.hasMoreElements())
　　　　System.out.print(enum.nextElement()+"");
　　　　System.out.println();
　　　　//使用枚举类(Enumeration)的方法来获取向量对象的每个元素
　　　　System.out.println("Thepositionofobject1(top-to-bottom):"
　　　　　+v1.indexOf(integer1));
　　　　System.out.println("Thepositionofobject1(tottom-to-top):"
　　　　　+v1.lastIndexOf(integer1));
　　　　//按不同的方向查找对象integer1所处的位置
　　　　v1.setSize(4);
　　　　System.out.println("Thenewvector(resizedthevector)is:"+v1);
　　　　//重新设置v1的大小，多余的元素被行弃
　　　}
　　}
　　运行结果：
　　E:\java01>javaVectorApp
　　Thevectorv1is:
　　　　　[one,1,1,two,2,1,1]
　　Thevectorv1(usedmethodinsertElementAt())is:
　　　　　[one,1,three,3.9,1,two,2,1,1]
　　Thevectorv1(usedmethodsetElementAt())is:
　　　　　[one,1,four,3.9,1,two,2,1,1]
　　Thevectorv1(usedmethodremoveElement())is:onefour3.91two211
　　Thepositionofobject1(top-to-bottom):3
　　Thepositionofobject1(tottom-to-top):7
　　Thenewvector(resizedthevector)is:[one,four,3.9,1]
　　E:\java01>
　　从例1.3运行的结果中可以清楚地了解上面各种方法的作用，另外还有几点需解释。
　　(1)类Vector定义了方法
　　publicfinalintsize()
　　此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数，而非向量容量。可以调用方法capactly()来获取容量值。
　　方法：
　　publicfinalsynchronizedvoidsetsize(intnewsize)
　　此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值，则超过部分的多余元素会丢失。
　　(2)程序中定义了Enumeration类的一个对象
　　Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法。
　　在Enumeration中提供了方法hawMoreElement()来判断集合中是束还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法可以依次获得集合中元素。
　　Vector中提供方法：
　　publicfinalsynchronizedEnumerationelements()
　　此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法，以便于用户获取对应的枚举类型。

1.6栈类Stack

　　Stack类是Vector类的子类。它向用户提供了堆栈这种高级的数据结构。栈的基本特性就是先进后出。即先放入栈中的元素将后被推出。Stack类中提供了相应方法完成栈的有关操作。
　　基本方法：
　　publicObjectpush(ObjectHem)
　　将Hem压入栈中，Hem可以是任何类的对象。
　　publicObjectpop()
　　弹出一个对象。
　　publicObjectpeek()
　　返回栈顶元素，但不弹出此元素。
　　publicintsearch(Objectobj)
　　搜索对象obj,返回它所处的位置。
　　publicbooleanempty()
　　判别栈是否为空。
　　例1.4StackApp.java使用了上面的各种方法。
　　例1.4StackApp.java。
　　importjava.lang.*;
　　importjava.util.*;
　　publicclassStackApp{
　　　publicstaticvoidmain(Stringargs[]){
　　　　Stacksta=newStack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//压入的为字符串对象
　　　　sta.push(newInteger(2));
　　　　//压入的为Integer的对象，值为2
　　　　sta.push(newFloat(3.5));
　　　　//压入的为Float的对象，值为3.5
　　　　System.out.println("Thestackis,"+sta);
　　　　//对应栈sta
　　　　System.out.println("Thetopofstackis:"+sta.peek());
　　　　//对应栈顶元素，但不将此元素弹出
　　　　System.out.println("ThepositionofobjectCherryis:"
　　　　+sta.search("cherry"));
　　　　//打印对象Cherry所处的位置
　　　　System.out.print("Poptheelementofthestack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+"");
　　　　System.out.println();
　　　　//将栈中的元素依次弹出并打印。与第一次打印的sta的结果比较，可看出栈
　　　　//先进后出的特点
　　　}
　　}
　　运行结果(略)


1.7哈希表类Hashtable

　　哈希表是一种重要的存储方式，也是一种常见的检索方法。其基本思想是将关系码的值作为自变量，通过一定的函数关系计算出对应的函数值，把这个数值解释为结点的存储地址，将结点存入计算得到存储地址所对应的存储单元。检索时采用检索关键码的方法。现在哈希表有一套完整的算法来进行插入、删除和解决冲突。在Java中哈希表用于存储对象，实现快速检索。
　　Java.util.Hashtable提供了种方法让用户使用哈希表，而不需要考虑其哈希表真正如何工作。
　　哈希表类中提供了三种构造方法，分别是：
　　publicHashtable()
　　publicHashtable(intinitialcapacity)
　　publicHashtable(intinitialCapacity,floatloadFactor)
　　参数initialCapacity是Hashtable的初始容量，它的值应大于0。loadFactor又称装载因子，是一个0.0到0.1之间的float型的浮点数。它是一个百分比，表明了哈希表何时需要扩充，例如，有一哈希表，容量为100，而装载因子为0.9，那么当哈希表90%的容量已被使用时，此哈希表会自动扩充成一个更大的哈希表。如果用户不赋这些参数，系统会自动进行处理，而不需要用户操心。
　　Hashtable提供了基本的插入、检索等方法。
　　■插入
　　publicsynchronizedvoidput(Objectkey,Objectvalue)
给对象value设定一关键字key,并将其加到Hashtable中。若此关键字已经存在，则将此关键字对应的旧对象更新为新的对象Value。这表明在哈希表中相同的关键字不可能对应不同的对象(从哈希表的基本思想来看，这也是显而易见的)。
　　■检索
　　publicsynchronizedObjectget(Objectkey)
　　根据给定关键字key获取相对应的对象。
　　publicsynchronizedbooleancontainsKey(Objectkey)
　　判断哈希表中是否包含关键字key。
　　publicsynchronizedbooleancontains(Objectvalue)
　　判断value是否是哈希表中的一个元素。
　　■删除
　　publicsynchronizedobjectremove(objectkey)
　　从哈希表中删除关键字key所对应的对象。
　　publicsynchronizedvoidclear()
　　清除哈希表
　　另外，Hashtalbe还提供方法获取相对应的枚举集合：
　　publicsynchronizedEnumerationkeys()
　　返回关键字对应的枚举对象。
　　publicsynchronizedEnumerationelements()
　　返回元素对应的枚举对象。
　　例1.5Hashtable.java给出了使用Hashtable的例子。
　　例1.5Hashtalbe.java。
　　//importjava.lang.*;
　　importjava.util.Hashtable;
　　importjava.util.Enumeration;
　　publicclassHashApp{
　　　publicstaticvoidmain(Stringargs[]){
　　　　Hashtablehash=newHashtable(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("Thehashtablehash1is:"+hash);
　　　　System.out.println("Thesizeofthishashtableis"+hash.size());
　　　　//打印hash的内容和大小

　　　　Enumerationenum1=hash.elements();
　　　　System.out.print("Theelementofhashis:");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+"");
　　　　System.out.println();
　　　　//依次打印hash中的内容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("ThecapatialofJiangsuis"+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//删除关键字Beijing对应对象
　　　　System.out.println("Thehashtablehash2is:"+hash);
　　　　System.out.println("Thesizeofthishashtableis"+hash.size());
　　　}
　　}

　　运行结果：
　　Thehashtablehash1is:{Beijing=Beijing,Zhejiang=Hangzhou,Jiangsu=Nanjing}
　　Thesizeofthishashtableis3
　　Theelementofhashis:BeijingHangzhouNanjing
　　ThecapatialofJiangsuisNanjing
　　Thehashtablehash2is:{Zhejiang=Hangzhou,Jiangsu=Nanjing}
　　Thesizeofthishashtableis2

　　Hashtable是Dictionary(字典)类的子类。在字典类中就把关键字对应到数据值。字典类是一个抽象类。在java.util中还有一个类Properties，它是Hashtable的子类。用它可以进行与对象属性相关的操作。

1.8位集合类BitSet

　　位集合类中封装了有关一组二进制数据的操作。
　　我们先来看一下例8.6BitSetApp.java。
　　例8.6BitSetApp.java
　　//importjava.lang.*;
　　importjava.util.BitSet;
　　publicclassBitSetApp{
　　　privatestaticintn=5;
　　　publicstaticvoidmain(String[]args){
　　　　BitSetset1=newBitSet(n);
　　　　for(inti=0;i<n;i++)set1.set(i);
　　　　//将set1的各位赋1，即各位均为true
　　　　BitSetset2=newBitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2为set1的拷贝
　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//将set1的第0位set2的第2位清零
　　　　System.out.println("Theset1is:"+set1);
　　　　//直接将set1转换成字符串输出，输出的内容是set1中值true所处的位置
　　　　//打印结果为Theset1is:{1,2,3,4}
　　　　System.out.println("Thehashcodeofset2is:"+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//调用打印程序printbit(),打印对象中的每一个元素
　　　　//打印set1的结果为Thebitset1is:falsetruetruetruetrue
　　　　set1.and(set2);
　　　　printbit("set1andset2",set1);
　　　　//完成set1andset2,并打印结果
　　　　set1.or(set2);
　　　　printbit("set1orset2",set1);
　　　　//完成set1orset2,并打印结果
　　　　set1.xor(set2);
　　　　printbit("set1xorset2",set1);
　　　　//完成set1xorset2,并打印结果
　　　}
　　　//打印BitSet对象中的内容
　　　publicstaticvoidprintbit(Stringname,BitSetset){
　　　　System.out.print("Thebit"+name+"is:");
　　　　for(inti=0;i<n;i++)
　　　　　System.out.print(set.get(i)+"");
　　　　System.out.println();
　　　}
　　}

　　运行结果：
　　Theset1is:{1,2,3,4}
　　Thehashcodeofset2is:1225
　　Thebitset1is:falsetruetruetruetrue
　　Thebitset2is:truetruefalsetruetrue
　　Thebitset1andset2is:falsetruefalsetruetrue
　　Thebitset1orset2is:truetruefalsetruetrue
　　Thebitset1xorset2is:falsefalsefalsefalsefalse

　　程序中使用了BitSet类提供的两种构造方法：
　　　　publicBitSet();
　　　　publicBitSet(intn);
　　参数n代表所创建的BitSet类的对象的大小。BitSet类的对象的大小在必要时会由系统自动扩充。
　　其它方法：
　　publicvoidset(intn)
　　将BitSet对象的第n位设置成1。
　　publicvoidclear(intn)
　　将BitSet对象的第n位清零。
　　publicbooleanget(intn)
　　读取位集合对象的第n位的值，它获取的是一个布尔值。当第n位为1时，返回true；第n位为0时，返回false。
　　另外，如在程序中所示，当把一BitSet类的对象转换成字符串输出时，输出的内容是此对象中true所处的位置。
　　在BitSet中提供了一组位操作，分别是：
　　publicvoidand(BitSetset)
　　publicvoidor(BitSetset)
　　publicvoidxor(BitSetset)
利用它们可以完成两个位集合之间的与、或、异或操作。
　　BitSet类中有一方法publicintsize()来取得位集合的大小，它的返回值与初始化时设定的位集合大小n不一样，一般为64。

小结

　　本章我们介绍了Java的实用工具类库java.util中一些常用的类。java.util包中还有其它一些类。它们的具体用法用户可以自行查阅API。