本講介紹了Java類庫中已存在的豐富的類和方法。類庫中的這些類和方法都是精心設計的，其運行效率高、質(zhì)量高。這些類和方法包含在幾乎所有的Java軟件中，所以具有很好的移植性。許多類庫還可以作為免費軟件和共享軟件從Internet上下載，從而方便用戶使用。

1. 熟練掌握常用類的使用方法 2. 會查閱Java的技術文檔以便使用Java的類庫

1．Java常用類 2. 查閱Java技術文檔的方法

Java常用類的使用

幻燈片與投影示例

教學內(nèi)容

第七講 Java常用類庫介紹

7.1 Java類庫的結構

類庫就是Java API(Application Programming Interface，應用程序接口)，是系統(tǒng)提供的已實現(xiàn)的標準類的集合。在程序設計中，合理和充分利用類庫提供的類和接口，不僅可以完成字符串處理、繪圖、網(wǎng)絡應用、數(shù)學計算等多方面的工作，而且可以大大提高編程效率，使程序簡練、易懂。

Java類庫中的類和接口大多封裝在特定的包里，每個包具有自己的功能。表7．1列出了Java中一些常用的包及其簡要的功能。其中，包名后面帶“. *”的表示其中包括一些相關的包。有關類的介紹和使用方法，Java中提供了極其完善的技術文檔。我們只需了解技術文檔的格式就能方便地查閱文檔。

表7．1Java提供的部分常用包

注：在使用Java時，除了java.lang外，其他的包都需要import語句引入之后才能使用。

7.2 java.lang包中的常用類

java.lang是Java語言最廣泛使用的包。它所包括的類是其他包的基礎，由系統(tǒng)自動引入，程序中不必用import語句就可以使用其中的任何一個類。java.lang中所包含的類和接口對所有實際的Java程序都是必要的。下面我們將分別介紹幾個常用的類。

7.2.1 String類和StringBuffer類

許多語言中，字符串是語言固有的基本數(shù)據(jù)類型。但在Java語言中字符串通過String類和StringBuffer類來處理。

1．String類

Java語言中的字符串屬于String類。雖然有其它方法表示字符串（如字符數(shù)組），但Java使用String類作為字符串的標準格式。Java編譯器把字符串轉換成String對象。String對象一旦被創(chuàng)建了，就不能被改變。如果需要進行大量的字符串操作，應該使用StringBuffer類或者字符數(shù)組，最終結果可以被轉換成String格式。

（1）創(chuàng)建字符串

創(chuàng)建字符串的方法有多種方式，通常我們用String類的構造器來建立字符串。表6．2列出了String類的構造器及其簡要說明。

表7．2 String類構造器概要

【例7．1】使用多種方法創(chuàng)建一個字符串并輸出字符串內(nèi)容。

public class StrOutput {

public static void main(Sring[] args) {

//將字符串常量作為String對象對待，實際上是將一個String對象賦值給另一個

String s1 = "Hello,java!";

//聲明一個字符串，然后為其賦值

String s2;

s2 = "Hello,java!";

//使用String類的構造器中的一個。創(chuàng)建一個空字符串，然后賦值給它

String s3 = new String( );

S3 = "Hello,java!";

//將字符串直接傳遞給String類構造器來創(chuàng)建新的字符串

String s4 = new String("Hello,java!");

//使用String類的構造器中的一個。

//通過創(chuàng)建字符數(shù)組傳遞給String類構造器來創(chuàng)建新的字符串

Char c1[ ] = { ' H', ' i', ' , ' , 'j', 'a', 'v', 'a'};

String s5 = newString(c1 );

//將字符數(shù)組子集傳遞給String類構造器來創(chuàng)建新的字符串

String s6 = new String(c1,0,2 );

System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

System.out.println(s4);

System.out.println(s5);

System.out.println(s6);

}

}

運行結果：

C:\>java StrOutput

Hello,java!

Hello,java!

Hello,java!

Hello,java!

Hi,java

Hi

（2）字符串的操作

Java語言提供了多種處理字符串的方法。表6．3列出了String類常用的方法。

表7．3 String類的常用方法

下面結合常用的方法，介紹幾種典型的字符串操作。

①字符串的比較

Java語言提供了四種字符串的比較方法，這些方法有些類似于操作符。例如，可以使用equals、equalsIgnoreCase、regionMatches和compareTo方法來實現(xiàn)對字符串的比較。調(diào)用形式如下：

s1.equals(s2) ----- 如果s1等于s2，返回true，否則為false。

s1. equalsIgnoreCase (s2) ----- 如果s1等于s2，返回true，否則為false，忽略大小寫。

s1. regionMatches(boolean ignoreCase,int toffset,s2,int ooffset,int len ) ----- 如果s1和 s2的子串相等，返回true，否則為false。其中，ignoreCase為忽略大小寫設置，true為忽略大小寫，false為不忽略大小寫，toffset確定s1的起始偏移量，ooffset確定s2的起始偏移量，len確定子串的長度。

s1. compareTo (s2) -----如果s1<s2，則返回小于0的值；如果s1=s2，則返回0；如果s1>s2，則返回大于0的值

【例7．2】比較字符串。

public class StrCompare {

public static void main(Sring[] args) {

String s1="aaaa";

String s2="aaaa";

String s3="AAAA";

String s4="bcd";

if (s1.equals(s2)) {

System.out.println("s1==s2");

}

else {

System.out.println("s1!=s2");

}

if (s1.equalsIgnoreCase(s3)) {

System.out.println(" s1= =s3 when ignoring case");

}

else {

System.out.println(" s1!=s3 when ignoring case");

}

if (s1.regionMatches(true,0,s3,1,3)) {

System.out.println(" s1= =s3 when ignoring case");

}

else {

System.out.println(" s1!=s3 when ignoring case");

}

if (s1.regionMatches(false,0,s3,1,3)) {

System.out.println(" s1= =s3 when not ignoring case");

}

else {

System.out.println("s1!=s3 when not ignoring case");

}

if (s1.compareTo(s4)<0) {

System.out.println(" s1<s4");

}

else if (s1.compareTo(s4)= =0){

System.out.println("s1= =s4");

}

else{

System.out.println("s1>s4");

}

}

}

運行結果:

C:\>java StrCompare

s1= =s2

s1= =s3 when ignoring case

s1= =s3 when ignoring case

s1!= =s3 when not ignoring case

s1<s4

②求字符串長度

使用String類的length方法，調(diào)用形式如下：

s1.length( ) ----- 返回s1的長度，其類型為int。

【例7．3】求指定字符串的長度。

public class StrLength

{public static void main(Sring[] args)

{String s1="Hello,Java!";

int i=s1.length();

System.out.println("字符串s1長度為"+i);

}

}

運行結果:

C:\>java StrLength

字符串s1長度為11

③連接字符串

可以使用兩種方法將字符串連接起來：+操作符、用String類的concat方法。Concat方法的調(diào)用形式如下：

s1.concat(s2) ----- 將兩個字符串連接起來。

s1.concat(“字符串常量”) ----- 將字符串和字符串常量連接起來。

【例7．4】使用+和concat方法創(chuàng)建同一個字符串。

public class StrConcat

{public static void main(Sring[] args)

{String s1="Hello";

String s2=s1+",";

String s3=s2.concat(" Java");!

String s4=new String(" ! ");

String s5=s4.concat(s4);

System.out.println(" 連接而成的字符串是"+s5);

}

}

運行結果:

C:\>java StrConcat

連接而成的字符串是Hello,Java!

④拷貝字符串

可以有四種方法將一個字符串復制到另一個字符數(shù)組或String對象中：copyValueOf、getChars、toCharArray、substring。調(diào)用形式：

s1.copyValueOf(data) ----- 將數(shù)組data中的內(nèi)容全部拷貝到字符串中。

s1.copyValueOf(data,int offset,int count) ----- 將數(shù)組data中以offset起始，長度為count的內(nèi)容拷貝到字符串中。

s1.getChars(int strbegin,int strend, data,int offset) ----- 將s1的全部或部分內(nèi)容拷貝到數(shù)組data中。其中，strbegin為字符的起始，strend 為字符的終止，offset為字符數(shù)組的起始。

data=s1.toCharArray( ) ----- 將s1中的全部內(nèi)容拷貝到一個字符數(shù)組data中。

s2=s1.substring(int strbegin) ----- 將s1中以stregin起始的內(nèi)容拷貝到s2中。

s2=s1.substring(int strbegin,int strend) ----- 將s1中以stregin起始，以strend結束之間的內(nèi)容拷貝到s2中。

【例7．5】拷貝字符串。

public class StrCopy

{public static void main(Sring[] args)

{

String s1=new String( );

char data[ ]={ 'a', 'b', 'c', 'd', 'e', 'f'};

s1=s1.copyValueOf(data);

System.out.println(" s1="+s1);

s1=s1.copyValueOf(data,2,3);

System.out.println(" s1="+s1);

s1.getChars(1,2, data,0)

System.out.println(" data="+data);

data=s1. toCharArray( );

System.out.println(" data="+data);

String s2=new String( );

String s3=new String( );

s2=s1.substring(0);

System.out.println(" s2="+s2);

s3= s1.substring(1,2);

System.out.println(" s3="+s3);

}

}

運行結果:

C:\>java StrCopy

s1=abcdef

s2=cde

data=decdef

data=cde

s2=cde

s3=de

⑤在字符串中查找字符和子串

在字符串中查找字符和子串，確定它們的位置，有幾種常用的方法：charAt、indexOf、lastIndexOf。調(diào)用形式如下：

s1.chatAt(int index)--------返回s1中index所對應的字符。其中，index是下標號。

s1. indexOf (int char)--------返回s1中字符char在字符串中第一次出現(xiàn)的位置。

s1. lastIndexOf (int char)--------返回s1中字符char在字符串中最后一次出現(xiàn)的位置。

s1. indexOf (s2)--------返回s2在s1中第一次出現(xiàn)的位置。

s1. lastIndexOf (s2)--------返回s2在s1中最后一次出現(xiàn)的位置。

【例7．6】查找字符和子串。

public class StrSearch

{public static void main(Sring[] args)

{

String s1="Javav";

char c=s1.charAt(2);

System.out.println("c=",+c);

int i=s1.indexOf('a');

System.out.println("fistchar=",+i);

int j=s1.lastIndexOf('a');

System.out.println("lastchar=",+j);

i= s1.indexOf("av");

System.out.println("fiststring=",+i);

j=s1.lastIndexOf("av");

System.out.println("laststring=",+j);

}

}

運行結果:

C:\>java StrSearch

c=v

firstchar=1

lastchar=3

firststring=1

laststring=3

⑥修改字符串

修改字符串的常用方法有：replace、toLowerCase、toUpperCase、trim。調(diào)用形式如下：

s1.replace(oldchar,newchar)--------用新字符newchar替代舊字符oldchar，若指定字符不存在，則不替代。

s1.toLowerCase( )--------將s1中的所有大寫字母轉換為小寫字母。

s1.toUpperCase( )-------- 將s1中的所有小寫字母轉換為大寫字母。

s1.trim( )--------刪除s1中的首、尾空格。

【例7．7】修改字符串。

public class StrModify

{public static void main(Sring[] args)

{

String s1="Java";

s1=s1.replae('a', 'b');

System.out.println("s1=",+s1);

String s2=s1.toLowerCase( );

String s3=s1. toUpperCase ( );

System.out.println("s2=",+s2);

System.out.println("s3=",+s3);

s2= s1.trim( );

System.out.println("s2=",+s2);

}

}

運行結果:

C:\>java StrModify

s1= Jbvb

s2= jbvb

s3= JBVB

s2= jbvb

2．StringBuffer類

緩沖字符串類StringBuffer與String類相似，它具有String類的很多功能，甚至更豐富。它們主要的區(qū)別是StringBuffer對象可以方便地在緩沖區(qū)內(nèi)被修改，如增加、替換字符或子串。與Vector對象一樣，StringBuffer對象可以根據(jù)需要自動增長存儲空間，故特別適合于處理可變字符串。當完成了緩沖字符串數(shù)據(jù)操作后，可以通過調(diào)用其方法StringBuffer.toString( )或String構造器把它們有效地轉換回標準字符串格式。

（1）創(chuàng)建StringBuffer對象

可以使用StringBuffer類的構造器來創(chuàng)建StringBuffer對象。表6.4 是StringBuffer的構造器及其簡要說明。

表6.4StringBuffer類構造器概要

【例7．8】用多種方法創(chuàng)建StringBuffer對象。

public class StrBufferSet

{public static void main(Sring[] args)

{

StringBuffers1=new StringBuffer( );

s1.append("Hello,Java!");

System.out.println("s1=" +s1);

StringBuffers2=new StringBuffer(10 );

S2.insert(0, "Hello,Java!");

System.out.println("s2="+s2);

StringBuffers3=new StringBuffer("Hello,Java!");

System.out.println("s3="+s3);

}

}

運行結果:

C:\>java StrBufferSet

s1=Hello,Java!

s2=Hello,Java!

s3=Hello,Java!

（2）StringBuffer類的常用方法

StringBuffer類是可變字符串，因此它的操作主要集中在對字符串的改變上。

①為StringBuffer的對象插入和追加字符串

可以在StringBuffer對象的字符串之中插入字符串，或在其之后追加字符串，經(jīng)過擴充之后形成一個新的字符串，方法有：append和insert，調(diào)用形式如下：

s1.append(s2)--------將字符串s2加到s1之后。

s1.insert(int offset,s2)--------在s1從起始處offset開始插入字符串s2。

append和insert都有多個重載方法，這里不一一贅述。關于append和insert方法的使用見例6.8 。

②獲取和設置StringBuffer對象的長度和容量

獲取和設置StringBuffer對象的長度和容量的方法有：length、capacity、setlength，調(diào)用形式如下：

s1.length( )--------返回s1中字符個數(shù)。

s1. capacity ( )--------返回s1的容量，即內(nèi)存空間數(shù)量。通常會大于length( )

s1. setlength (int newLength )--------改變s1中字符的個數(shù)，如果newLength大于原個數(shù)，則新添的字符都為空（""）；相反，字符串中的最后幾個字符將被刪除。

【例7．9】顯示確定字符串的長度和容量，并改變字符串的長度。

public class StrLen

{public static void main(Sring[] args)

{

StringBuffers1=new StringBuffer("Hello,Java!");

System.out.println("The length is"+s1.length( ));

System.out.println("The allocated length is"+s1.capacity( ));

s1.setlength(100);

System.out.println("The new length is"+s1.length( ));

}

}

運行結果:

C:\>java StrLen

The length is11

The allocated length is22

The new length is100

③讀取和改變StringBuffer對象中的字符

讀取StringBuffer對象中的字符的方法有：charAt和getChar，這與String對象方法一樣。在StringBuffer對象中，設置字符及子串的方法有：setCharAt、replace；刪除字符及子串的方法有：delete、deleteCharAt。調(diào)用形式如下：

s1.setCharAt(int index,char ch)--------用ch替代s1中index位置上的字符。

s1.replace(int start,int end,s2)--------s1中從start（含）開始到end（不含）結束之間的字符串以s2代替。

s1.delete(int start,int end)--------刪除s1中從start（含）開始到end（不含）結束之間的字符串。

s1.deleteCharAt(int index)------刪除s1中index位置上的字符。

【例7．10】改變字符串的內(nèi)容。

public class StrChange

{public static void main(Sring[] args)

{

StringBuffers1=new StringBuffer("Hallo,Java!");

s1.setCharAt(1, 'e');

System.out.println(s1);

s1.replace(1,5, "i");

System.out.println(s1);

s1.delete(0,3);

System.out.println(s1);

s1.deleteCharAt(4);

System.out.println(s1);

}

}

運行結果:

C:\>java StrChange

Hello,Java!

Hi,Java!

Java!

Java

7.2.2 System類

System類是一個特殊類，它是一個公共最終類，不能被繼承，也不能被實例化，即不能創(chuàng)建System類的對象。

System類功能強大，與Runtime一起可以訪問許多有用的系統(tǒng)功能。System類保存靜態(tài)方法和變量的集合。標準的輸入、輸出和Java運行時的錯誤輸出存儲在變量in，out和err中。由System類定義的方法豐富并且實用。System類中所有的變量和方法都是靜態(tài)的，使用時以System作為前綴，即形如“System.變量名”和“System.方法名”。

1．標準的輸入輸出

System類包含三個使用頻繁的公共數(shù)據(jù)流，分別是：標準輸入（in）、標準輸出（out）、標準錯誤輸出（err）。

① public static final InputStream in--------標準輸入。

這個屬性是InputStream類的一個對象，它是未經(jīng)包裝的原始Input Stream，讀取System.in之前應該先加以包裝?？梢酝ㄟ^read()方法讀取字節(jié)數(shù)據(jù)。

② public static final PrintStream out--------標準輸出。

③ public static final PrintStream err---------標準輸出。

out和err都已經(jīng)被包裝成PrintStream對象，所以可以直接使用System.out和System.err。可以通過方法print()、println()或write()方法很方便地完成各種數(shù)據(jù)類型的輸出。out與err使用上的不同是： System.out用于輸出普通信息，out的輸出一般需要緩存；System.err一般情況下用來打印錯誤信息，不需要緩存，快速顯示緊急信息。

關于InputStream類和PrintStream類將在java.io包中介紹。

2．System類的常用方法

System類有一些有用的方法，這些方法用于處理運行環(huán)境。下面簡單介紹幾個方法及其功能。

（1）獲取當前時間

使用currentTineMillis( )可以記錄程序執(zhí)行的時間，這是一個特別有意義的用法。currentTineMillis( )方法返回自從1970年1月1日午夜起到現(xiàn)在的時間，時間單位是毫秒。如果要記錄程序中一段有問題程序的運行時間，可以在這段程序開始之前調(diào)用currentTineMillis( )方法存儲當前時間，在這段程序結束處再次調(diào)用currentTineMillis( )方法。執(zhí)行該段程序所花費的時間為其結束時刻的時間值減去其開始時刻的時間值。下面的程序段可以用來估計一下執(zhí)行某個循環(huán)所占用的時間：

long startTime=System.currenTimerMillis( );//記錄循環(huán)開始時間

int sum=0;

for(int i=0;i<100000;i++){

sum+=i;

}

long endTime=System.currentTimeMillis( );// 記錄循環(huán)結束時間

System.out.Println("time: "+(endTime-startTime)+ "milliseconds. ");

注意：雖然使用cuttentTimeMillis()方法可以計算出當前的日期和時間，但是獲取當前日期和時間最好使用java.util中的Date類。

（2）快速復制數(shù)組

使用arraycopy()方法可以將一個任意類型的數(shù)組快速地從一個地方復制到另一個地方。這比使用循環(huán)編寫的程序要快得多。調(diào)用形式為：

System.arraycopy(a1,int sourceStart,a2,int targetStart,int size)------將數(shù)組a1從下標sourceStart開始，長度為size的元素依次復制到數(shù)組a2的以targetStart為起始的單元中。

【例7．11】用arraycopy()方法復制兩個數(shù)組。

class CopyArray

{static byte array1[ ]={97,98,99,100,101};

static byte array2[ ]={102,102,102,102,102};

public static void main(Sring[] args)

{

System.out.println(" array1="+new String(array1));

System.out.println(" array2="+new String(array2));

System.arraycopy(array1,0,array2,0,array1.length);

System.out.println(" array1="+new String(array1));

System.out.println(" array2="+new String(array2));

System.arraycopy(array1,0,array1,1,array1.length-1);

System.arraycopy(array2,1,array2,0,array2.length-1);

System.out.println(" array1="+new String(array1));

System.out.println(" array2="+new String(array2));

}

}

運行結果:

C:\>java CopyArray

array1=abcde

array2=fffff

array1=abcde

array2= abcde

array1=aabcd

array2=bcdee

（3）退出虛擬機

在用戶的程序還未執(zhí)行完之前，強制關閉Java虛擬機的方法是exit()：

Public static void exit(int exitCode)

關閉虛擬機的同時把狀態(tài)信息exitCode傳遞給操作系統(tǒng)，exitCoded非零時，表示非正常退出。

（4）強制垃圾收集

垃圾收集器一般情況下運行于后臺，并自動地收集已不使用了的內(nèi)存。使用gc()方法可強制垃圾收集器啟動：

public static void gc()

3．環(huán)境屬性

可以通過調(diào)用System.getProperty()方法來獲得不同環(huán)境屬性的值。例如下面的程序顯示當前用戶目錄的路徑：

class PlayUserDir{

public static void main(String[ ] args){

System.out.println(System.getProperty(" user.dir"));

}

}

可以通過setProperty( )方法設置系統(tǒng)屬性的值：

public static String setProperty(String key,String value);

其中，key為鍵名，value為鍵值。

6.2.3 Math類

Math類提供了用于幾何學、三角學以及幾種一般用途方法的浮點函數(shù)，來執(zhí)行很多數(shù)學運算。

1．Math類定義的兩個雙精度常量

doubleE--------常量e（2.7182818284590452354）

doublePI--------常量pi（3.14159265358979323846）

2．Math類定義的常用方法

Math類定義的方法是靜態(tài)的，可以通過類名直接調(diào)用。下面簡要介紹幾類常用的方法。

①三角函數(shù)

public static double sin(double a)------三角函數(shù)正弦。

public static double cos(double a)------三角函數(shù)余弦。

public static double tan(double a)------三角函數(shù)正切。

public static double asin(double a)------三角函數(shù)反正弦。

public static double acos(double a)------三角函數(shù)反余弦。

public static double atan(double a)------三角函數(shù)反正切。

② 指數(shù)函數(shù)

public static double exp(double a)------返回ea的值。

public static double log(double a)------ 返回lna的值。

public static double pow (double y,double x)------ 返回以y為底數(shù)，以x為指數(shù)的冪值。

public static double sqrt(double a)------ 返回a的平方根。

③ 舍入函數(shù)

public static intceil(double a)------- 返回大于或等于a的最小整數(shù)。

public static intfloor(double a)------- 返回小于或等于a的最大整數(shù)。

以下三個方法都有其它數(shù)據(jù)類型的重載方法：

public static intabs(int a)------- 返回a的絕對值。

public static intmax(int a，int b)------- 返回a和b的最大值。

public static intmin(int a，int b)------- 返回a和b的最小值。

④其它數(shù)學方法

public static doublerandom( )------ 返回一個偽隨機數(shù)，其值介于0和1之間。

public static doubletoRadians(doubleangle )------ 將角度轉換為弧度。

public static doubletoDegrees (doubleangle)------ 將弧度轉換為角度。

7.3 java.util包中的集合類

java.util是Java語言中另一個使用廣泛的包，它包括集合類、時間處理模式、日期時間工具等各種常用工具。

Java的集合類是java.util包中的重要內(nèi)容，它允許以各種方式將元素分組，并定義了各種使這些元素更容易操作的方法。集合類中存放的是對象，不同的集合類有不同的功能和特點，適合不同的場合，用以解決一些實際問題。

下面我們將介紹集合類中的幾個常用類的使用。

6.3.1 Vector類

Java的數(shù)組具有很強的功能，但它并不總是能滿足我們的要求。數(shù)組一旦被創(chuàng)建，它的長度就固定了。但是，有時我們在創(chuàng)建數(shù)組時并不確切地知道有多少項需要加進去。解決這一問題的辦法是，創(chuàng)建一個盡可能大的數(shù)組，以滿足要求，但這勢必會造成空間的浪費。Java提供了一個好的辦法：使用java.util包中的向量類Vector。

簡單地說，Vector是一個動態(tài)數(shù)組，它可以根據(jù)需要動態(tài)伸縮。另外，Vector類還提供了一些有用的方法，如增加和刪除元素的方法，而這些操作在數(shù)組中一般來說必須手工完成。

Vector類提供了三個屬性，四個構造器和多種方法，下面分別做以介紹：

1．屬性

protected int capacityIncrement--------當向量的大小超過容量時，向量容量的增長量。

protected int elementCount--------這個Vector對象中的組件數(shù)。

protectedObjected[ ] elementData--------存儲向量的組件的數(shù)組緩沖區(qū)。

2．構造器

Vector( )--------構造一個空向量。

Vector(Collection c )--------構造一個包含給定集合中的元素的向量。

Vector(int initialCapacity )--------構造一個具有給定的初始容量的空向量。

Vector(int initialCapacity, int capacityIncrement )-------- 構造一個具有給定的初始容量和容量增量的空向量。

3. 常用的方法

① 向向量中添加對象

向一個向量中添加新對象有兩種情況，可以用Vector提供的兩種不同方法來實現(xiàn)：

void addElement(Object obj)-------- 在向量的最后增加一個元素。

void insetElementAt(Object obj，int index)-------- 在向量的指定位置插入一個元素。

② 從向量中刪除對象

從向量中刪除對象有三種情況，可以用Vector提供的三種不同方法來實現(xiàn)：

void removeAllElement( )--------刪除向量中的所有對象。

void removeElement(Object ob)--------刪除向量中一個指定的對象（僅刪除第一次出現(xiàn)的對象）。

void removeElementAt( int index)--------刪除向量中一個指定位置上的對象。

③ 搜索向量中的對象

有時我們需要得到向量中特殊位置上的對象或判斷向量中是否包含某個對象，可以使用如下的方法：

Object firstElement( )--------返回這個向量的第一個對象。

Object lastElement( )--------返回這個向量的最后一個對象。

Object ElementAt(int index )--------返回這個向量中指定位置的對象。

Boolean contains(Object elem)--------如果這個對象在這個對象中，則返回true。

④獲取向量的基本信息

int capacity( )--------返回這個向量的當前容量。

int size( )-------- 返回這個向量的對象個數(shù)。

【例7．12】使用Vector類的示例。

• import java.util.*

class VectorTest{

public static void main(Sring[] args){

Vector vec=new Vector(3);

System.out.println(" old capacity is"+vec.capacity());

vec.addElement(new Integer(1));

vec.addElement(new Integer(2));

vec.addElement(new Integer(3));

vec.addElement(new Float(2.78));

vec.addElement(new Double(2.78));

System.out.println(" new capacity is"+vec.capacity());

System.out.println(" new size is"+vec.size());

System.out.println(" first item is"+(Integer)vec.firstElement());

System.out.println(" last item is"+(Float)vec.lasttElement());

if(vec. Contains(new Integer(2)))

System.out.println(" found 2");

vec. removeElementAt(1);

if(vec.Contains(new Integer(2))){

System.out.println(" found 2");

else

System.out.println(" after deleting not found 2");

}

}

運行結果:

C:\>java VectorTest

old capacity is3

new capacity is6

new size is5

first item is1

last item is2.78

found 2

after deleting not found 2

7.3.2 Stack類

Stack是Vector的一個子類，它實現(xiàn)標準的后進先出堆棧。Stack 僅僅定義了創(chuàng)建空堆棧的默認構造函數(shù)。Stack包括了由Vector定義的所有方法，同時增加了幾種它自己定義的方法，介紹如下：

boolean empty( )--------如果堆棧是空的，則返回true，當堆棧包含元素時，返回false。

Object peek( )-----------返回位于棧頂?shù)脑?，但是并不在堆棧中刪除它。

Object pop( )------------返回位于棧頂?shù)脑?，并在進程中刪除它。

Object push (Object element )---------將element壓入堆棧，同時也返回element。

int search(Object element)---------在堆棧中搜索element，如果發(fā)現(xiàn)了，則返回它相對于棧頂?shù)钠屏?。否則，返回-1。

【例7．13】向堆棧中添加元素并彈出。

import java.util.*

classStackTest{

public static voidmain(Sring[] args){

Stack stack1=new Stack();//構造一個空堆棧stack1

try {

stack1.push(new Integer(0));

stack1.push(new Integer(1));

stack1.push(new Integer(2));

stack1.push(new Integer(3));

stack1.push(new Integer(4));

System.out.println((Integer)stack1.pop());

System.out.println((Integer)stack1.pop());

System.out.println((Integer)stack1.pop());

System.out.println((Integer)stack1.pop());

System.out.println((Integer)stack1.pop());

}

catch(EmptyStackException e){ }

}

}

運行結果:

C:\>java StackTest

4

3

2

1

0

7.3.3 Hashtable類

前面講到的集合類是通過下標來確定元素的位置，集合中的對象有一定的順序，而Hashtable（散列表）卻不同，它通過另一種方式來確定對象的位置。它是映射集合的一種實現(xiàn)，提供了將一個對象與另一個對象相關聯(lián)的方法。

Hashtable是Dictionary類的子類，Dictionary類是抽象類，與查字典操作類似，它要達到通過一個鍵（key）來查找元素的目的。Hashtable類也是通過鍵來查找對象，如何確定這個鍵值呢？首先，散列表為每個對象計算出一個整數(shù)，稱為散列碼，每個對象與其散列碼一一對應；然后，用散列碼與對象個數(shù)進行取模運算，計算出相對應的鍵。散列表中的對象就是通過這種方式一一放入的，所以在查詢對象時，用同樣的方式就可以快速定位對象在散列表中的位置。

Hashtable不僅實現(xiàn)了父類的方法，還有自己的方法，如conrainsKey(Object key)。

下面介紹幾個常用的方法：

Object put(Object key, Object value)--------將關鍵字和值插入散列表中。如果key不在散列表中，返回null。如果key已存在于散列表中，則返回與key相連的前一個值。

Object get(Object key)--------返回包含與key相關聯(lián)的值的對象。如果key不在散列表中，則返回一個空對象。

Object remove(Object key)--------刪除key及其相應的值，返回與key相關聯(lián)的值。如果key不在散列表中，則返回一個空對象。

boolean conrainsKey(Object key)--------用來檢查形參對象是否是一個散列表的鍵，是則返回true,否則返回false。

另外，size()方法返回表中元素的個數(shù)，isEmply()方法判斷表中是否包含有元素。

作為應用散列表的一個典型例子，可考慮用一個程序來檢驗Java的Math.random()方法的隨機性到底如何。在理想情況下，它應該產(chǎn)生一系列完美的隨機分布數(shù)字。但為了驗證這一點，我們需要生成數(shù)量眾多的隨機數(shù)字，然后計算落在不同范圍內(nèi)的數(shù)字多少。散列表可以極大簡化這一工作，因為它能將對象同對象關聯(lián)起來（此時是將Math.random()生成的值同那些值出現(xiàn)的次數(shù)關聯(lián)起來）。

【例7．14】用Hashtable來檢驗隨機數(shù)的隨機性。

import java.util.*;

class Counter {

int i = 1;

public String toString() {

return Integer.toString(i);

}

}

class Statistics {

public static void main(String[] args) {

Hashtable ht = new Hashtable();

for(int i = 0; i < 10000; i++) {

// Produce a number between 0 and 20:

Integer r = new Integer((int)(Math.random() * 20));

if(ht.containsKey(r))

((Counter)ht.get(r)).i++;

else

ht.put(r, new Counter());

}

System.out.println(ht);

}

}

在main()中，每次產(chǎn)生一個隨機數(shù)字，它都會封裝到一個Integer對象里，使句柄能夠隨同散列表一起使用（不可對一個集合使用基本數(shù)據(jù)類型，只能使用對象句柄）。containKey()方法檢查這個鍵是否已經(jīng)在集合里（也就是說，那個數(shù)字以前發(fā)現(xiàn)過嗎？）若已在集合里，則get()方法獲得那個鍵關聯(lián)的值，此時是一個Counter（計數(shù)器）對象。計數(shù)器內(nèi)的值i隨后會增加1，表明這個特定的隨機數(shù)字又出現(xiàn)了一次。

假如鍵以前尚未發(fā)現(xiàn)過，那么方法put()仍然會在散列表內(nèi)置入一個新的“鍵－值”對。在創(chuàng)建之初，Counter會自己的變量i自動初始化為1，它標志著該隨機數(shù)字的第一次出現(xiàn)。

為顯示散列表，只需把它簡單地打印出來即可。Hashtable toString()方法能遍歷所有鍵－值對，并為每一對都調(diào)用toString()。Integer toString()是事先定義好的，可看到計數(shù)器使用的toString。一次運行的結果如下（添加了換行）：

{19=526, 18=533, 17=460, 16=513, 15=521, 14=495, 13=512, 12=483, 11=488,

10=487, 9=514, 8=523, 7=497, 6=487, 5=480, 4=489, 3=509, 2=503, 1=475, 0=505}

7.4 關于Java技術文檔

Java技術文檔描述代碼的工作原理，可以向程序員提供信息，是需要經(jīng)常查看的資料。這一節(jié)我們將介紹如何查看javaDOC中的類庫。

可以從Sun公司的網(wǎng)站上下載Java文檔。在下載完j2sdk-1_4_2-doc后，找到它下面的docs文件夾，打開其中的index文件（HTML文件），找到“API & Language Documentation”下的“Java 2PlatformAPI Specification”，然后選擇需要查看的那個包，進而查看類、接口等內(nèi)容。或者直接進入docs文件夾下的api文件夾，打開index（HTML文件），也可進入選擇包的界面。

選擇一個包后，可以看到包的名稱及簡單描述，然后是包中的內(nèi)容，分為interface summary、class summary、exception summary和error summary等（當然包中如果沒有某一方面內(nèi)容，就不包含），如果想看包中各類的繼承結構，可以選擇最上面的菜單中的tree，就可以了解包中的總體結構。

當選擇一個類進入后，可以看到如下的內(nèi)容（以Double類為例說明）：

java. lang//包名

Class Double//類名

java. lang. Object//繼承結構：java. lang包中的Double類的直接父類

|//是java. lang中的Number類，

+--java. lang. Number

|

+--java. lang. Double

All Implemented Interfaces:

Comparable, Serializable

然后是類頭定義和說明，以及源于哪個版本：

public final class Double

extends Number

implements Comparable

The Double class wraps a value of the primitive type double in an object. An object of type Double contains a single field whose type is double. In addition, this class provides several methods for converting a double to a String and a string to a double, as well as other constants and methods useful when dealing with a double.

Since:

JDK1.0

See Also:

serialized Form

然后就是屬性、方法、構造函數(shù)的概述表（summary），最后是屬性、方法、構造函數(shù)的詳細說明。

小結

Java語言的內(nèi)核非常小，其強大的功能主要由類庫（Java API，應用程序接口）體現(xiàn)。從某種意義上說，掌握Java的過程也是充分利用Java類庫中豐富資源的過程。

String類和StringBuffer類用來完成字符串處理，它們都具有多個構造器（構造函數(shù)）。通常使用String類來定義固定長度字符串。當字符串長度空間不確定時，應該使用StringBuffer類，它具有更豐富的功能。

公共最終類System和數(shù)學類Math中所有的變量和方法都是靜態(tài)的，可以通過類名直接調(diào)用。

Java的集合類是java.util包中的重要內(nèi)容。常用的有向量類Vector、堆棧類Stack、散列表類Hashtable。更多有關類庫的介紹和使用方法，需要查閱Java技術文檔。