基本介紹
- 中文名：java
- 套用：網路
Java的基本包
java.lang 其中包含有：
接口：Comparable、Cloneable、Runable等
類：八個基本數據類型封裝類、Math、Runtime、Object、String、StringBuffer、Thread、Exception等
ArrayList和Vector的區別,HashMap和Hashtable的區別
java.lang 其中包含有：
接口：Comparable、Cloneable、Runable等
類：八個基本數據類型封裝類、Math、Runtime、Object、String、StringBuffer、Thread、Exception等
ArrayList和Vector的區別,HashMap和Hashtable的區別
一.同步性:Vector是執行緒安全的，也就是說是同步的，而ArrayList是執行緒序不安全的，不是同步的。
二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半ArrayList,Vector, LinkedList的存儲性能和特性。
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等記憶體操作，所以索引數據快而插入數據慢，Vector由於使用了synchronized方法（執行緒安全），通常性能上較ArrayList差，而LinkedList使用雙向鍊表實現存儲，按序號索引數據需要進行前向或後向遍歷，但是插入數據時只需要記錄本項的前後項即可，所以插入速度較快。
就HashMap與HashTable主要從三方面來說.
一.歷史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一實現
二.同步性:Hashtable是執行緒安全的，也就是說是同步的，而HashMap是執行緒序不安全的，不是同步的
三.值：只有HashMap允許在一個集合中有一個null鍵和在一個集合中有多個null值
Hashtable是HashMap的同步版本；HashMap允許有null值和一個null鍵，但是，Hashtable不允許有任何內容為null。Hashtable類的對象必須覆蓋Object類的hashCode()和equals()方法關於其他集合類型。
一.ArrayList 提供快速遍歷和快速訪問。現在設計了新的 RandomAccess 接口，它指出這種列表支持快速隨機訪問。Vector也實現了RandomAccess 接口。
二.遍歷HashSet與HashMap時，其順序是未知的（但添加刪除快）。LinkedHashSet和LinkedHashSet是按照元素的插入的順序遍歷的（遍歷快）。
三．TreeSet和TreeMap將保證元素按照元素的自然順序進行排列。也可以使用一個用戶自己實現的比較規則。
四、HashSet有一個散列表支持它。它為基本操作提供固定時間性能。TreeSet它確保了排序集將按元素升序，根據自然順序排序。
Dictionary類
主要用於將關鍵字轉換成值，該類接收一個關鍵字並返回一個值。Dictionary是一個抽象類，它是Hashtable的超類。
Properties類
擴展了Hashtable類，但Properties對象的關鍵字和值必須是String類型，並能將對象寫入一個輸出流並保存在一個檔案中，然後可以把它讀回一個輸入流。
如果需要維護和搜尋一個部件列表，它們由唯一的字母數字序列號標示，其中的部件是Part類型，這時應該使用哪種集合？如果我們改變需求，你也需要能夠按順序、按它們的序列號列印出部件？
1、應該選擇HashMap
2、應該選擇TreeMap
多執行緒有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多執行緒有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方面有兩種，分別是synchronized,wait與notify
抽象類與接口？
答：抽象類與接口都用於抽象，但是抽象類(JAVA中)可以有自己的部分實現，而接口則完全是一個標識(同時有多重繼承的功能)。
abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized? 都不能接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)?
接口可以繼承接口。抽象類可以實現(implements)接口，抽象類可繼承實體類，但前提是實體類必須有明確的構造函式。
Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)?
可以繼承其他類或完成其他接口，在swing編程中常用此方式。
IO流
位元組流：數據在存儲時與傳輸時都是以位元組為單位進行的。通常用於讀寫二進制數據，如圖像和聲音檔案。
字元流：數據在存儲與傳輸時都是以字元為單位進行的。
流：對數據源的一種抽象，其目的是想用統一的方式訪問各種不同的數據源（檔案、網路、記憶體的緩衝區）檔案讀寫的基本類：File類提供定位本地檔案系統，描述檔案和目錄的功能。管道流用於線上程之間通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
執行緒1àPipedOutputStreamàPipedInputStreamà執行緒2
鍵盤輸入：
try{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
System.out.println(s);
}catch(Exception e){
}
檔案輸入輸出：
try{
File f=new File("test.txt");
FileOutputStream fout=new FileOutputStream(f);
fout.write(System.in.read());
fout.close();
FileInputStream fin=new FileInputStream(f);
int size=fin.available();
for(int i=0;i<size;i++){
System.out.print((char)fin.read());
}
fin.close();
}catch(Exception e){
}
通過網路傳輸檔案：
客戶端：
File f=new File("bk.exe");
FileInputStream fin=new FileInputStream(f);
Socket st=new Socket("localhost",6000);
BufferedOutputStream bout=new BufferedOutputStream(st.getOutputStream());
int size=fin.available();
for(int i=0;i<size;i++){
bout.write(fin.read());
}
伺服器端：
ServerSocket server=new ServerSocket(6000);
Socket st=server.accept();
File f=new File("kk.exe");
BufferedInputStream bin=new BufferedInputStream(st.getInputStream());
FileOutputStream fout=new FileOutputStream(f);
int i=0;
while(i!=-1){
i=bin.read();
fout.write(i);
}
串列化的注意事項以及如何實現串列化
對象的壽命通常隨著生成該對象的程式的終止而終止。有時候，可能需要將對象的狀態保存下來，在需要時再將對象恢復。我們把對象的這種能記錄自己的狀態以便將來再生的能力，叫做對象的持續性(persistence)。對象通過寫出描述自己狀態的數值來記錄自己，這個過程叫對象的串列化(serialization)。
序列化的過程就是對象寫入位元組流和從位元組流中讀取對象。將對象狀態轉換成位元組流之後，可以用java.io包中的各種位元組流類將其保存到檔案中，管道到另一執行緒中或通過網路連線將對象數據傳送到另一主機。
一：對象序列化可以實現分散式對象。
二：java對象序列化不僅保留一個對象的數據，而且遞歸保存對象引用的每個對象的數據。
常見排序法：
public class Sort{
public static int count=0;
public boolean LT(int num1,int num2){
return num1<num2;
}
public void output(int[] array){
System.out.print("第"+count+"次排序：");
for(int i=0;i<array.length;i++)
System.out.print(array[i]+" ");
System.out.println();
}
二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半ArrayList,Vector, LinkedList的存儲性能和特性。
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等記憶體操作，所以索引數據快而插入數據慢，Vector由於使用了synchronized方法（執行緒安全），通常性能上較ArrayList差，而LinkedList使用雙向鍊表實現存儲，按序號索引數據需要進行前向或後向遍歷，但是插入數據時只需要記錄本項的前後項即可，所以插入速度較快。
就HashMap與HashTable主要從三方面來說.
一.歷史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一實現
二.同步性:Hashtable是執行緒安全的，也就是說是同步的，而HashMap是執行緒序不安全的，不是同步的
三.值：只有HashMap允許在一個集合中有一個null鍵和在一個集合中有多個null值
Hashtable是HashMap的同步版本；HashMap允許有null值和一個null鍵，但是，Hashtable不允許有任何內容為null。Hashtable類的對象必須覆蓋Object類的hashCode()和equals()方法關於其他集合類型。
一.ArrayList 提供快速遍歷和快速訪問。現在設計了新的 RandomAccess 接口，它指出這種列表支持快速隨機訪問。Vector也實現了RandomAccess 接口。
二.遍歷HashSet與HashMap時，其順序是未知的（但添加刪除快）。LinkedHashSet和LinkedHashSet是按照元素的插入的順序遍歷的（遍歷快）。
三．TreeSet和TreeMap將保證元素按照元素的自然順序進行排列。也可以使用一個用戶自己實現的比較規則。
四、HashSet有一個散列表支持它。它為基本操作提供固定時間性能。TreeSet它確保了排序集將按元素升序，根據自然順序排序。
Dictionary類
主要用於將關鍵字轉換成值，該類接收一個關鍵字並返回一個值。Dictionary是一個抽象類，它是Hashtable的超類。
Properties類
擴展了Hashtable類，但Properties對象的關鍵字和值必須是String類型，並能將對象寫入一個輸出流並保存在一個檔案中，然後可以把它讀回一個輸入流。
如果需要維護和搜尋一個部件列表，它們由唯一的字母數字序列號標示，其中的部件是Part類型，這時應該使用哪種集合？如果我們改變需求，你也需要能夠按順序、按它們的序列號列印出部件？
1、應該選擇HashMap
2、應該選擇TreeMap
多執行緒有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多執行緒有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方面有兩種，分別是synchronized,wait與notify
抽象類與接口？
答：抽象類與接口都用於抽象，但是抽象類(JAVA中)可以有自己的部分實現，而接口則完全是一個標識(同時有多重繼承的功能)。
abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized? 都不能接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)?
接口可以繼承接口。抽象類可以實現(implements)接口，抽象類可繼承實體類，但前提是實體類必須有明確的構造函式。
Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)?
可以繼承其他類或完成其他接口，在swing編程中常用此方式。
IO流
位元組流：數據在存儲時與傳輸時都是以位元組為單位進行的。通常用於讀寫二進制數據，如圖像和聲音檔案。
字元流：數據在存儲與傳輸時都是以字元為單位進行的。
流：對數據源的一種抽象，其目的是想用統一的方式訪問各種不同的數據源（檔案、網路、記憶體的緩衝區）檔案讀寫的基本類：File類提供定位本地檔案系統，描述檔案和目錄的功能。管道流用於線上程之間通信：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter
執行緒1àPipedOutputStreamàPipedInputStreamà執行緒2
鍵盤輸入：
try{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String s=br.readLine();
System.out.println(s);
}catch(Exception e){
}
檔案輸入輸出：
try{
File f=new File("test.txt");
FileOutputStream fout=new FileOutputStream(f);
fout.write(System.in.read());
fout.close();
FileInputStream fin=new FileInputStream(f);
int size=fin.available();
for(int i=0;i<size;i++){
System.out.print((char)fin.read());
}
fin.close();
}catch(Exception e){
}
通過網路傳輸檔案：
客戶端：
File f=new File("bk.exe");
FileInputStream fin=new FileInputStream(f);
Socket st=new Socket("localhost",6000);
BufferedOutputStream bout=new BufferedOutputStream(st.getOutputStream());
int size=fin.available();
for(int i=0;i<size;i++){
bout.write(fin.read());
}
伺服器端：
ServerSocket server=new ServerSocket(6000);
Socket st=server.accept();
File f=new File("kk.exe");
BufferedInputStream bin=new BufferedInputStream(st.getInputStream());
FileOutputStream fout=new FileOutputStream(f);
int i=0;
while(i!=-1){
i=bin.read();
fout.write(i);
}
串列化的注意事項以及如何實現串列化
對象的壽命通常隨著生成該對象的程式的終止而終止。有時候，可能需要將對象的狀態保存下來，在需要時再將對象恢復。我們把對象的這種能記錄自己的狀態以便將來再生的能力，叫做對象的持續性(persistence)。對象通過寫出描述自己狀態的數值來記錄自己，這個過程叫對象的串列化(serialization)。
序列化的過程就是對象寫入位元組流和從位元組流中讀取對象。將對象狀態轉換成位元組流之後，可以用java.io包中的各種位元組流類將其保存到檔案中，管道到另一執行緒中或通過網路連線將對象數據傳送到另一主機。
一：對象序列化可以實現分散式對象。
二：java對象序列化不僅保留一個對象的數據，而且遞歸保存對象引用的每個對象的數據。
常見排序法：
public class Sort{
public static int count=0;
public boolean LT(int num1,int num2){
return num1<num2;
}
public void output(int[] array){
System.out.print("第"+count+"次排序：");
for(int i=0;i<array.length;i++)
System.out.print(array[i]+" ");
System.out.println();
}
}
// 冒泡排序法
public void BubbleSort(int[] array){
boolean swap=true;
int index=0;
int i=0;
while(i<array.length-1){
int temp=array[i];
for(int j=i;j<array.length;j++){
if(!LT(array[i],array[j])){
int temp2=array[i];
array[i]=array[j];
array[j]=temp2;
swap=true;
index=j;
}else{
swap=false;
}
}
i++;
if(swap){
array[i]=array[index];
array[index]=temp;
i++;
}
output(array);
}
}
// 冒泡排序法
public void BubbleSort(int[] array){
boolean swap=true;
int index=0;
int i=0;
while(i<array.length-1){
int temp=array[i];
for(int j=i;j<array.length;j++){
if(!LT(array[i],array[j])){
int temp2=array[i];
array[i]=array[j];
array[j]=temp2;
swap=true;
index=j;
}else{
swap=false;
}
}
i++;
if(swap){
array[i]=array[index];
array[index]=temp;
i++;
}
output(array);
}
}
}
// 直接插入排序法
public void InsertSort(int[] array){
for(int i=1;i<array.length;++i){
if (LT(array[i],array[i-1])){
int temp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for(int j=i-1;j>0;--j){
if(LT(array[j],array[j-1])){
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output(array);
}
}
// 直接插入排序法
public void InsertSort(int[] array){
for(int i=1;i<array.length;++i){
if (LT(array[i],array[i-1])){
int temp=array[i];
array[i]=array[i-1];
array[i-1]=temp;
for(int j=i-1;j>0;--j){
if(LT(array[j],array[j-1])){
array[j]=array[j-1];
array[j-1]=temp;
}else{
break;
}
}
output(array);
}
}
}
// 快速排序法
private int Partition(int array[],int low,int high){
int temp=array[low];
int pivotkey=array[low];
while(low<high){
while(low<high&&array[high]>pivotkey)--high;
array[low]=array[high];
while(low<high&&array[low]<=pivotkey)++low;
array[high]=array[low];
}
array[low]=temp;
output(array);
return low;
}
// 快速排序法
private int Partition(int array[],int low,int high){
int temp=array[low];
int pivotkey=array[low];
while(low<high){
while(low<high&&array[high]>pivotkey)--high;
array[low]=array[high];
while(low<high&&array[low]<=pivotkey)++low;
array[high]=array[low];
}
array[low]=temp;
output(array);
return low;
}
public void qsort(int array[],int low,int high){
if(low<high){
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}
qsort(int array[],int low,int high){
if(low<high){
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}
if(low<high){
int pivotloc=Partition(array,low,high);
QSort(array,low,pivotloc-1);
QSort(array,pivotloc+1,high);
}
}
void QuickSort(int array[]){
QSort(array,0,array.length-1);
}
public static void main(String args[]){
int array[]={49,38,65,97,76,13,27,49};
Sort sort=new Sort();
System.out.println("===================================");
sort.output(array);
System.out.println("最佳化冒泡排序法");
sort.BubbleSort(array);
System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("直接插入排序法");
sort.InsertSort(array);
System.out.println("插入排序法");
sort.InsertSort(array);System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("快速排序法");
sort.QuickSort(array);
}
}
如在COLLECTION框架中，實現比較要實現什麼樣的接口？
Collection框架中實現比較要實現Comparable 接口和 Comparator 接口
什麼是執行緒？
執行緒與進程相似，是一段完成某個特定功能的代碼，是程式中單個順序的流控制；但與進程不同的是，同類的多個執行緒是共享一塊記憶體空間和一組系統資源，而執行緒本身的數據通常只有微處理器的暫存器數據，以及一個供程式執行時使用的堆疊。所以系統在產生一個執行緒，或者在各個執行緒之間切換時，負擔要比進程小的多，正因如此，執行緒被稱為輕負荷進程（light-weight process）。一個進程中可以包含多個執行緒。
一個執行緒是一個程式內部的順序控制流。
1. 進程：每個進程都有獨立的代碼和數據空間（進程上下文） ，進程切換的開銷大。
2. 執行緒：輕量的進程，同一類執行緒共享代碼和數據空間，每個執行緒有獨立的運行棧和程式計數器（PC），執行緒切換的開銷小。
3. 多進程：在作業系統中，能同時運行多個任務程式。
4. 多執行緒：在同一應用程式中，有多個順序流同時執行。
進程上下文） ，進程切換的開銷大。
2. 執行緒：輕量的進程，同一類執行緒共享代碼和數據空間，每個執行緒有獨立的運行棧和程式計數器（PC），執行緒切換的開銷小。
3. 多進程：在作業系統中，能同時運行多個任務程式。
4. 多執行緒：在同一應用程式中，有多個順序流同時執行。同步和異步有和異同，在什麼情況下分別使用他們？
臨界資源問題
執行緒都是獨立的，而且異步執行，也就是說每個執行緒都包含了運行時所需要的數據或方法，而不需要外部的資源或方法，也不必關心其它執行緒的狀態或行為。但是經常有一些同時運行的執行緒需要共享數據，此時就需考慮其他執行緒的狀態和行為，否則就不能保證程式的運行結果的正確性。
我們需要做的是允許一個執行緒徹底完成其任務後，再允許下一個執行緒執行。必須保證一個共享的資源一次只能被一個執行緒使用。實現此目的的過程稱為同步。
同步是用於確保資源一次只能被一個執行緒使用的過程。
同步對於單執行緒程式沒有任何好處。使用同步比非同步的性能差三到四倍。
臨界資源問題
執行緒都是獨立的，而且異步執行，也就是說每個執行緒都包含了運行時所需要的數據或方法，而不需要外部的資源或方法，也不必關心其它執行緒的狀態或行為。但是經常有一些同時運行的執行緒需要共享數據，此時就需考慮其他執行緒的狀態和行為，否則就不能保證程式的運行結果的正確性。
我們需要做的是允許一個執行緒徹底完成其任務後，再允許下一個執行緒執行。必須保證一個共享的資源一次只能被一個執行緒使用。實現此目的的過程稱為同步。
同步是用於確保資源一次只能被一個執行緒使用的過程。
同步對於單執行緒程式沒有任何好處。使用同步比非同步的性能差三到四倍。執行緒方法介紹：
構造函式：
Thread()
Thread(Runable target）
Thread(Runable target，String name）
Thread(ThreadGroup group,Runable target）
Thread(ThreadGroup group,Runable target,String name）
Thread(ThreadGroup group,String name）
用於完成一個執行緒“實際功能”的代碼放在run方法中。Run方法可以在Thread的子類中重寫，也可以在Runable對象中重寫。一旦執行緒死去，它就永遠不能再重新啟動，否則會拋出異常。用start方法啟動一個已經啟動的執行緒也會拋出異常。isAlive、interrupt、Thread.currentThread、suspend、resume、stopSleep方法可以使低優先權的執行緒得到執行的機會，Yield方法只能使同優先權的執行緒有執行的機會。Join方法能夠使調用該方法的執行緒在此之前執行完畢，在該方法之後，調用join方法的執行緒不會產生輸出了，Wait與notify使用時，需要注意的事項？
它們只能用於synchronized同步塊中；
它們需要配對使用；
Wait一般出現在一個while循環中，while語句使用一個boolean標誌控制。
死鎖
當被鎖定的A對象試圖訪問另一個被鎖定的B對象，B對象同時又要訪問已被鎖定的A對象。這樣導致兩個執行緒都在等待另一個執行緒釋放資源，這樣就出現了死鎖。
STRING與STRINGBUFFER的區別。
答：STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字元串中的內容經常進行操作，特別是內容要修改時，那么使用StringBuffer，如果最後需要String，那么使用StringBuffer的toString()方法
JDBC調用資料庫的基本步驟WEBLOGIC SERVER中的JDBC配置
1、建立到指定資料庫的連線池Connection Pool
2、建立基於該連線池的數據源DataSource
3、訪問資料庫時通過數據源的JNDI名字查找到該數據源，然後通過數據源獲得資料庫連線對象。得到該對象後就可以依次生成資料庫語句對象和結果集對象，進行相應的資料庫操作。WEBLOGIC SERVER中的JDBC配置
1、建立到指定資料庫的連線池Connection Pool
2、建立基於該連線池的數據源DataSource
3、訪問資料庫時通過數據源的JNDI名字查找到該數據源，然後通過數據源獲得資料庫連線對象。得到該對象後就可以依次生成資料庫語句對象和結果集對象，進行相應的資料庫操作。import java.sql.*;
import javax.naming.*;
import javax.sql.*;
import java.util.*;
import javax.rmi.*;java.sql.*;
import javax.naming.*;
import javax.sql.*;
importjava.util.*;
importjavax.rmi.*;public class DataSourceTest{
private static Context getInitialContext() throws Exception{
String url="t3://localhost:7001";
String user="system";
String password="11111111";
Properties properties=null;
try{
properties=new Properties();
properties.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
properties.put(Context.PROVIDER_URL,url);
if(user!=null){
properties.put(Context.SECURITY_PRINCIPAL,user);
properties.put(Context.SECURITY_CREDENTIALS,
password==null?"":password);
}
return new InitialContext(properties);
}catch(Exception e){
throw e;
}
}
public static void main(String args[]){
UserTransaction tx=null;
DataSource ds=null;
Context ctx=null;
Connection myConn=null;
try{
ctx=getInitialContext();
tx=(UserTranscation)ctx.lookup("javax.transcation.UserTranscation");
tx.begin();
ds=(DataSource)ctx.lookup("myTxDataSource");
}catch(Exception e){
e.printStackTrace();
}
Statement myStatement=null;
ResultSet myResultSet=null;
try{
myConn=ds.getConnection();
myStatement=myConn.createStatement();
myResultSet=myStatement.executeQuery(
"select fullname from employee");
while(myResultSet.next()){
System.out.println(myResultSet.getString("fullname"));
}
tx.commit();
}catch(Exception e){
try{
tx.rollback();
}catch(Exception e){
}
}finally{
myStatement.close();
myConn.close();
}
}
}
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import java.io.*;public class Student{
public static void main(String args[]){
Document doc;
Element students;
Element stud;
Element fName;
Element sName;
try{
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
DocumentBuilder db=dbf.newDocumentBuilder();
doc=db.newDocument();
stud=doc.createElement("Student");fName=doc.createElement("FirstName");;
fName.appendChild(doc.createTextNode("John"));
stud.appendChild(fName);
sName=doc.createElement("surname");
sName.appendChild(doc.createTextNode("David"));
stud.appendChild(sName);surname");
sName.appendChild(doc.createTextNode("David"));
stud.appendChild(sName);students=doc.createElement("Students");
students.setAttribute("Department","Mathematics");
students.appendChild(stud);
doc.appendChild(students);TransformerFactory tf=TransformerFactory.newInstance();
Transformer transformer=tf.newTransformer();
transformer.transform(new DOMSource(doc),new StreamResult(System.out));
}catch(Exception e){
e.printStackTrace();
}
}
}
使用DOM API顯示現有XML文檔內容
使用DOM API將XML文檔數據插入資料庫使用DOM API根據資料庫創建XML文檔Java的國際化
國際化是為了將應用程式發布在多個地區（locale）而進行準備的過程。不同地區標識了各個特定的國家在信息表現上所廣泛使用的語言、流通貨幣、字元集、日期格式及其他要素。
支持國際化的應用程式具有以下特點：
1、不用改變代碼就可以支持另外的語言。
2、文本元素、訊息和圖片保存在原始碼之外。
3、將於文化背景有關的數據，比如日期和時間、十進制數值以及流通貨幣，根據用戶所用的語言和所在地理位置進行正確格式化。
4、支持非標準字元集。
5、應用程式可以快速適應新的語言區域。
為了使一個應用程式國際化，：
1、必須將用戶所見到的硬編碼字元（如標籤、工具提示和錯誤信息等）替換成包含在資源包ResourceBundle中的字元。它是一個java屬性檔案，它將關鍵字映射為字元值。並且可以使用多個不同語言版本的ResourceBundle，這樣將可以對於不同語言提供不同的字元串。
2、使用Locale對象，可以使數據格式化為與地區相關的數據。
3、國際化的應用程式還必須使用統一的字元編碼標準字元集。
ResourceBundle中的字元。它是一個java屬性檔案，它將關鍵字映射為字元值。並且可以使用多個不同語言版本的ResourceBundle，這樣將可以對於不同語言提供不同的字元串。
2、使用Locale對象，可以使數據格式化為與地區相關的數據。
3、國際化的應用程式還必須使用統一的字元編碼標準字元集。套用伺服器有那些？Servlet方面
什麼是Servlet？
Servlet是J2EE套用框架中部署於Web層的Web組件，運行在支持Servlet的Web伺服器或套用伺服器上。Servlet為客戶端和伺服器端的信息處理提供了一種“請求/回響”機制。
客戶程式將請求傳送到伺服器；伺服器將請求傳送到Servlet；依據客戶程式的請求，Servlet動態地構造回答信息並返回給伺服器；伺服器將回答返回給客戶程式。
什麼是JSP？
JSP是J2EE套用框架中部署於Web層的Web組件，是對Servlet技術的擴展。它使在靜態的頁面中加入動態的內容變得非常容易。並且通過使用標籤庫可以大大節省開發時間；將JavaBean與JSP一起使用可以將數據表示和程式實現分離。
在MVC架構模式中：
使用Servlet作為控制器，而JSP作為數據視圖。
CGI與Servlet的區別？
CGI（公共網關接口）是一項標準，使WEB伺服器可以與外部應用程式互動。但是該技術存在一些嚴重的限制：
1、CGI應用程式占用資源很多。當系統要處理來自一個用戶的請求時，就會創建一個新的進程來處理該請求，一旦CGI腳本停止執行，系統就必須收回該進程。這種重量級進程的經常啟動和停止非常低效。
2、CGI很難連結於請求進程的其他階段，因為在WEB伺服器上它們運行於不同的進程。這就很難處理授權、工作流和日誌記錄工作。
Java Servlet技術提供了一個基於組件、與平台無關的方法來構建WEB應用程式。Servlet沒有標準CGI應用程式所遇到的性能局限。
Servlet比CGI更高效是因為：
Servlet套用中將只創建一個單一個重量級進程，並對每個用戶請求使用更輕量級的執行緒來完成請求處理，並且這些執行緒是由JVM自動維護。每個客戶端請求對應一個執行緒，每個Servlet類在Servlet容器中只存在一個唯一的對象（實例）。Servlet類首次載入後將常駐記憶體。
常駐記憶體。1、說一說Servlet的生命周期?
答:在第一次請求Servlet時將創建Servlet實例，容器調用實例的init方法，如果容器有請求要傳送給servlet，它就會調用servlet實例的Service方法。一個請求將作為一個執行緒。如果伺服器要銷毀servlet實例就會調用servlet實例的destory方法，否則該實例將會常駐記憶體。
JAVA SERVLET API中forward() 與redirect()的區別？
使用重定向：當調用sendRedirect方法時，Web容器就會向瀏覽器返迴響應，指示需要新的URL。因為瀏覽器發出了完全嶄新的請求，所以在重定向之前存儲為請求屬性的任何對象都會消失。
使用轉發：當為一個請求調用轉發時，請求就傳送給伺服器上另一個資源，而無需通知客戶機由不同的資源處理請求。這個過程完全在Web容器內部進行，客戶機絕不知曉。與重定向不同，轉發過程中，對象可以存儲在請求中，並傳送給下一個資源使用。
因為轉發過程完全在伺服器上進行，與客戶機沒用通信，因此轉發的性能優於重定向。
但是如果在JSP頁面上使用圖形的相對路徑和其他資源，轉發機制就會帶來問題。因為瀏覽器無從得知發生了轉發，所以相對路徑只是相對初始的Servlet，而不是所轉發到的JSP頁面。使用JSP自定義標籤可以解決這個問題。
如何現實servlet的單執行緒模式servlet的配置4、Servlet的基本架構
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
HttpServlet{
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}JSP中動態INCLUDE與靜態include的區別？
答：動態INCLUDE用jsp:include動作實現
<jsp:include page="included.jsp" flush="true" />它總是會檢查所含檔案中的變化，適合用於包含動態頁面，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含檔案的變化，適用於包含靜態頁面
<%@ include file="included.htm" %>
可能會讓你寫一段Jdbc連Oracle的程式,並實現數據查詢.
答:程式如下：
package hello.ant;
import java.sql.*;
public class jdbc {
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String theUser="admin";
String thePw="manager";
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc() {
try{
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql) {
try {
conn.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql) {
rs=null;
try {
rs=conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery("select * from test");
try{
while (rs.next()) {
System.out.println(rs.getString("id"));
System.out.println(rs.getString("name"));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}動態INCLUDE與靜態include的區別？
答：動態INCLUDE用jsp:include動作實現
它總是會檢查所含檔案中的變化，適合用於包含動態頁面，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含檔案的變化，適用於包含靜態頁面
可能會讓你寫一段Jdbc連Oracle的程式,並實現數據查詢.
答:程式如下：
package hello.ant;
import java.sql.*;
public class jdbc {
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String theUser="admin";
String thePw="manager";
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc() {
try{
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql) {
try {
conn.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql) {
rs=null;
try {
rs=conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery("select * from test");
try{
while (rs.next()) {
System.out.println(rs.getString("id"));
System.out.println(rs.getString("name"));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
說出在JSP頁面里是怎么分頁的?
頁面需要保存以下參數：
總行數：根據sql語句得到總行數
每頁顯示行數：設定值
當前頁數：請求參數
頁面根據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行即可。
說出在JSP頁面里是怎么分頁的?
頁面需要保存以下參數：
總行數：根據sql語句得到總行數
每頁顯示行數：設定值
當前頁數：請求參數
頁面根據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行即可。
設計模式方面
1、開發中都用到了那些設計模式?用在什麼場合?
答：人們在自己的環境中不斷發現問題和尋找問題的解決方案的時候，發現有一些問題及其解決方案不斷變換面孔重複出現，但在這些不同的面孔後面有著共同的本質，這些共同的本質就是模式。設計模式就是用來描述解決這些問題的解決方案的核心的。
工廠模式
專門負責將大量有共同接口的類實例化。工廠模式可以動態確定將那一個類實例化，不必事先知道每次要實例化那一個類。
簡單工廠模式
或稱靜態工廠方法模式。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式就是由一個工廠類根據傳入的參數決定創建那一種產品類的實例。
簡單工廠模式涉及到工廠角色、抽象產品角色以及具體產品角色：l工廠類角色：含有與套用緊密相關的商業邏輯。工廠類在客戶端的直接調用下創建產品對象。l抽象產品角色：擔任這個角色的類是由工廠方法模式所創建的對象的父類，或它們共同擁有的接口。l具體產品角色：工廠方法模式所創建的任何對象都是這個角色的實例。
優點是：允許客戶端相對獨立於產品創建的過程，並且在系統引入新產品的時候無需修改客戶端。缺點是：如果有新的產品加入到系統中去，就需要修改工廠類，將必要的邏輯加入到工廠類中。
工廠方法模式
或稱多態性工廠模式。工廠方法模式的用意是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中。工廠方法模式中，核心的工廠類不再負責所有的產品的創建，而是將具體創建的工作交給子類去做。它僅負責給出具體工廠子類必須實現的接口。這樣可以用來允許系統在不修改具體工廠角色的情況下引進新的產品。
工廠方法模式涉及到的角色：l抽象工廠角色：它不包含套用邏輯。任何在模式中創建對象的工廠類必須實現這個接口。l具體工廠角色：含有與套用密切相關的邏輯，並且受到應用程式的調用以創建產品對象。l抽象產品角色：工廠方法模式所創建的對象的超類型，也就是產品對象的共同父類或共同擁有的接口。l具體產品角色：這個角色實現了抽象產品角色所聲明的接口。
單例模式
確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。
特點：單例類只能有一個實例；單例類必須自己創建自己的惟一的實例；單例類必須給所有其他對象提供這一實例。
多例模式
多例類可以有多個實例，並且多例類必須自己創建、管理自己的實例，並向外界提供自己的實例。
在系統中可以用於資料庫連線池、鍵值快取等。
代理模式
給某個對象提供一個代理對象，並由代理對象控制對原對象的引用。
代理模式所涉及的角色：抽象主題角色：聲明了真實主題和代理主題的共同接口，這樣一來在任何可以使用真實主題的地方都可以使用代理主題角色。簡單工廠模式
或稱靜態工廠方法模式。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式就是由一個工廠類根據傳入的參數決定創建那一種產品類的實例。
簡單工廠模式涉及到工廠角色、抽象產品角色以及具體產品角色：l工廠類角色：含有與套用緊密相關的商業邏輯。工廠類在客戶端的直接調用下創建產品對象。l抽象產品角色：擔任這個角色的類是由工廠方法模式所創建的對象的父類，或它們共同擁有的接口。l具體產品角色：工廠方法模式所創建的任何對象都是這個角色的實例。
優點是：允許客戶端相對獨立於產品創建的過程，並且在系統引入新產品的時候無需修改客戶端。缺點是：如果有新的產品加入到系統中去，就需要修改工廠類，將必要的邏輯加入到工廠類中。
工廠方法模式
或稱多態性工廠模式。工廠方法模式的用意是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中。工廠方法模式中，核心的工廠類不再負責所有的產品的創建，而是將具體創建的工作交給子類去做。它僅負責給出具體工廠子類必須實現的接口。這樣可以用來允許系統在不修改具體工廠角色的情況下引進新的產品。
工廠方法模式涉及到的角色：l抽象工廠角色：它不包含套用邏輯。任何在模式中創建對象的工廠類必須實現這個接口。l具體工廠角色：含有與套用密切相關的邏輯，並且受到應用程式的調用以創建產品對象。l抽象產品角色：工廠方法模式所創建的對象的超類型，也就是產品對象的共同父類或共同擁有的接口。l具體產品角色：這個角色實現了抽象產品角色所聲明的接口。
單例模式
確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。
特點：單例類只能有一個實例；單例類必須自己創建自己的惟一的實例；單例類必須給所有其他對象提供這一實例。
多例模式
多例類可以有多個實例，並且多例類必須自己創建、管理自己的實例，並向外界提供自己的實例。
在系統中可以用於資料庫連線池、鍵值快取等。
代理模式
給某個對象提供一個代理對象，並由代理對象控制對原對象的引用。
代理模式所涉及的角色：抽象主題角色：聲明了真實主題和代理主題的共同接口，這樣一來在任何可以使用真實主題的地方都可以使用代理主題角色。
QSort(array,0,array.length-1);
}
public static void main(String args[]){
int array[]={49,38,65,97,76,13,27,49};
Sort sort=new Sort();
System.out.println("===================================");
sort.output(array);
System.out.println("最佳化冒泡排序法");
sort.BubbleSort(array);
System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("直接插入排序法");
sort.InsertSort(array);
System.out.println("插入排序法");
sort.InsertSort(array);System.out.println();
System.out.println("===================================");
array=new int[]{49,38,65,97,76,13,27,49};
sort.output(array);
System.out.println("快速排序法");
sort.QuickSort(array);
}
}
如在COLLECTION框架中，實現比較要實現什麼樣的接口？
Collection框架中實現比較要實現Comparable 接口和 Comparator 接口
什麼是執行緒？
執行緒與進程相似，是一段完成某個特定功能的代碼，是程式中單個順序的流控制；但與進程不同的是，同類的多個執行緒是共享一塊記憶體空間和一組系統資源，而執行緒本身的數據通常只有微處理器的暫存器數據，以及一個供程式執行時使用的堆疊。所以系統在產生一個執行緒，或者在各個執行緒之間切換時，負擔要比進程小的多，正因如此，執行緒被稱為輕負荷進程（light-weight process）。一個進程中可以包含多個執行緒。
一個執行緒是一個程式內部的順序控制流。
1. 進程：每個進程都有獨立的代碼和數據空間（進程上下文） ，進程切換的開銷大。
2. 執行緒：輕量的進程，同一類執行緒共享代碼和數據空間，每個執行緒有獨立的運行棧和程式計數器（PC），執行緒切換的開銷小。
3. 多進程：在作業系統中，能同時運行多個任務程式。
4. 多執行緒：在同一應用程式中，有多個順序流同時執行。
進程上下文） ，進程切換的開銷大。
2. 執行緒：輕量的進程，同一類執行緒共享代碼和數據空間，每個執行緒有獨立的運行棧和程式計數器（PC），執行緒切換的開銷小。
3. 多進程：在作業系統中，能同時運行多個任務程式。
4. 多執行緒：在同一應用程式中，有多個順序流同時執行。同步和異步有和異同，在什麼情況下分別使用他們？
臨界資源問題
執行緒都是獨立的，而且異步執行，也就是說每個執行緒都包含了運行時所需要的數據或方法，而不需要外部的資源或方法，也不必關心其它執行緒的狀態或行為。但是經常有一些同時運行的執行緒需要共享數據，此時就需考慮其他執行緒的狀態和行為，否則就不能保證程式的運行結果的正確性。
我們需要做的是允許一個執行緒徹底完成其任務後，再允許下一個執行緒執行。必須保證一個共享的資源一次只能被一個執行緒使用。實現此目的的過程稱為同步。
同步是用於確保資源一次只能被一個執行緒使用的過程。
同步對於單執行緒程式沒有任何好處。使用同步比非同步的性能差三到四倍。
臨界資源問題
執行緒都是獨立的，而且異步執行，也就是說每個執行緒都包含了運行時所需要的數據或方法，而不需要外部的資源或方法，也不必關心其它執行緒的狀態或行為。但是經常有一些同時運行的執行緒需要共享數據，此時就需考慮其他執行緒的狀態和行為，否則就不能保證程式的運行結果的正確性。
我們需要做的是允許一個執行緒徹底完成其任務後，再允許下一個執行緒執行。必須保證一個共享的資源一次只能被一個執行緒使用。實現此目的的過程稱為同步。
同步是用於確保資源一次只能被一個執行緒使用的過程。
同步對於單執行緒程式沒有任何好處。使用同步比非同步的性能差三到四倍。執行緒方法介紹：
構造函式：
Thread()
Thread(Runable target）
Thread(Runable target，String name）
Thread(ThreadGroup group,Runable target）
Thread(ThreadGroup group,Runable target,String name）
Thread(ThreadGroup group,String name）
用於完成一個執行緒“實際功能”的代碼放在run方法中。Run方法可以在Thread的子類中重寫，也可以在Runable對象中重寫。一旦執行緒死去，它就永遠不能再重新啟動，否則會拋出異常。用start方法啟動一個已經啟動的執行緒也會拋出異常。isAlive、interrupt、Thread.currentThread、suspend、resume、stopSleep方法可以使低優先權的執行緒得到執行的機會，Yield方法只能使同優先權的執行緒有執行的機會。Join方法能夠使調用該方法的執行緒在此之前執行完畢，在該方法之後，調用join方法的執行緒不會產生輸出了，Wait與notify使用時，需要注意的事項？
它們只能用於synchronized同步塊中；
它們需要配對使用；
Wait一般出現在一個while循環中，while語句使用一個boolean標誌控制。
死鎖
當被鎖定的A對象試圖訪問另一個被鎖定的B對象，B對象同時又要訪問已被鎖定的A對象。這樣導致兩個執行緒都在等待另一個執行緒釋放資源，這樣就出現了死鎖。
STRING與STRINGBUFFER的區別。
答：STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字元串中的內容經常進行操作，特別是內容要修改時，那么使用StringBuffer，如果最後需要String，那么使用StringBuffer的toString()方法
JDBC調用資料庫的基本步驟WEBLOGIC SERVER中的JDBC配置
1、建立到指定資料庫的連線池Connection Pool
2、建立基於該連線池的數據源DataSource
3、訪問資料庫時通過數據源的JNDI名字查找到該數據源，然後通過數據源獲得資料庫連線對象。得到該對象後就可以依次生成資料庫語句對象和結果集對象，進行相應的資料庫操作。WEBLOGIC SERVER中的JDBC配置
1、建立到指定資料庫的連線池Connection Pool
2、建立基於該連線池的數據源DataSource
3、訪問資料庫時通過數據源的JNDI名字查找到該數據源，然後通過數據源獲得資料庫連線對象。得到該對象後就可以依次生成資料庫語句對象和結果集對象，進行相應的資料庫操作。import java.sql.*;
import javax.naming.*;
import javax.sql.*;
import java.util.*;
import javax.rmi.*;java.sql.*;
import javax.naming.*;
import javax.sql.*;
importjava.util.*;
importjavax.rmi.*;public class DataSourceTest{
private static Context getInitialContext() throws Exception{
String url="t3://localhost:7001";
String user="system";
String password="11111111";
Properties properties=null;
try{
properties=new Properties();
properties.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
properties.put(Context.PROVIDER_URL,url);
if(user!=null){
properties.put(Context.SECURITY_PRINCIPAL,user);
properties.put(Context.SECURITY_CREDENTIALS,
password==null?"":password);
}
return new InitialContext(properties);
}catch(Exception e){
throw e;
}
}
public static void main(String args[]){
UserTransaction tx=null;
DataSource ds=null;
Context ctx=null;
Connection myConn=null;
try{
ctx=getInitialContext();
tx=(UserTranscation)ctx.lookup("javax.transcation.UserTranscation");
tx.begin();
ds=(DataSource)ctx.lookup("myTxDataSource");
}catch(Exception e){
e.printStackTrace();
}
Statement myStatement=null;
ResultSet myResultSet=null;
try{
myConn=ds.getConnection();
myStatement=myConn.createStatement();
myResultSet=myStatement.executeQuery(
"select fullname from employee");
while(myResultSet.next()){
System.out.println(myResultSet.getString("fullname"));
}
tx.commit();
}catch(Exception e){
try{
tx.rollback();
}catch(Exception e){
}
}finally{
myStatement.close();
myConn.close();
}
}
}
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import java.io.*;public class Student{
public static void main(String args[]){
Document doc;
Element students;
Element stud;
Element fName;
Element sName;
try{
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
DocumentBuilder db=dbf.newDocumentBuilder();
doc=db.newDocument();
stud=doc.createElement("Student");fName=doc.createElement("FirstName");;
fName.appendChild(doc.createTextNode("John"));
stud.appendChild(fName);
sName=doc.createElement("surname");
sName.appendChild(doc.createTextNode("David"));
stud.appendChild(sName);surname");
sName.appendChild(doc.createTextNode("David"));
stud.appendChild(sName);students=doc.createElement("Students");
students.setAttribute("Department","Mathematics");
students.appendChild(stud);
doc.appendChild(students);TransformerFactory tf=TransformerFactory.newInstance();
Transformer transformer=tf.newTransformer();
transformer.transform(new DOMSource(doc),new StreamResult(System.out));
}catch(Exception e){
e.printStackTrace();
}
}
}
使用DOM API顯示現有XML文檔內容
使用DOM API將XML文檔數據插入資料庫使用DOM API根據資料庫創建XML文檔Java的國際化
國際化是為了將應用程式發布在多個地區（locale）而進行準備的過程。不同地區標識了各個特定的國家在信息表現上所廣泛使用的語言、流通貨幣、字元集、日期格式及其他要素。
支持國際化的應用程式具有以下特點：
1、不用改變代碼就可以支持另外的語言。
2、文本元素、訊息和圖片保存在原始碼之外。
3、將於文化背景有關的數據，比如日期和時間、十進制數值以及流通貨幣，根據用戶所用的語言和所在地理位置進行正確格式化。
4、支持非標準字元集。
5、應用程式可以快速適應新的語言區域。
為了使一個應用程式國際化，：
1、必須將用戶所見到的硬編碼字元（如標籤、工具提示和錯誤信息等）替換成包含在資源包ResourceBundle中的字元。它是一個java屬性檔案，它將關鍵字映射為字元值。並且可以使用多個不同語言版本的ResourceBundle，這樣將可以對於不同語言提供不同的字元串。
2、使用Locale對象，可以使數據格式化為與地區相關的數據。
3、國際化的應用程式還必須使用統一的字元編碼標準字元集。
ResourceBundle中的字元。它是一個java屬性檔案，它將關鍵字映射為字元值。並且可以使用多個不同語言版本的ResourceBundle，這樣將可以對於不同語言提供不同的字元串。
2、使用Locale對象，可以使數據格式化為與地區相關的數據。
3、國際化的應用程式還必須使用統一的字元編碼標準字元集。套用伺服器有那些？Servlet方面
什麼是Servlet？
Servlet是J2EE套用框架中部署於Web層的Web組件，運行在支持Servlet的Web伺服器或套用伺服器上。Servlet為客戶端和伺服器端的信息處理提供了一種“請求/回響”機制。
客戶程式將請求傳送到伺服器；伺服器將請求傳送到Servlet；依據客戶程式的請求，Servlet動態地構造回答信息並返回給伺服器；伺服器將回答返回給客戶程式。
什麼是JSP？
JSP是J2EE套用框架中部署於Web層的Web組件，是對Servlet技術的擴展。它使在靜態的頁面中加入動態的內容變得非常容易。並且通過使用標籤庫可以大大節省開發時間；將JavaBean與JSP一起使用可以將數據表示和程式實現分離。
在MVC架構模式中：
使用Servlet作為控制器，而JSP作為數據視圖。
CGI與Servlet的區別？
CGI（公共網關接口）是一項標準，使WEB伺服器可以與外部應用程式互動。但是該技術存在一些嚴重的限制：
1、CGI應用程式占用資源很多。當系統要處理來自一個用戶的請求時，就會創建一個新的進程來處理該請求，一旦CGI腳本停止執行，系統就必須收回該進程。這種重量級進程的經常啟動和停止非常低效。
2、CGI很難連結於請求進程的其他階段，因為在WEB伺服器上它們運行於不同的進程。這就很難處理授權、工作流和日誌記錄工作。
Java Servlet技術提供了一個基於組件、與平台無關的方法來構建WEB應用程式。Servlet沒有標準CGI應用程式所遇到的性能局限。
Servlet比CGI更高效是因為：
Servlet套用中將只創建一個單一個重量級進程，並對每個用戶請求使用更輕量級的執行緒來完成請求處理，並且這些執行緒是由JVM自動維護。每個客戶端請求對應一個執行緒，每個Servlet類在Servlet容器中只存在一個唯一的對象（實例）。Servlet類首次載入後將常駐記憶體。
常駐記憶體。1、說一說Servlet的生命周期?
答:在第一次請求Servlet時將創建Servlet實例，容器調用實例的init方法，如果容器有請求要傳送給servlet，它就會調用servlet實例的Service方法。一個請求將作為一個執行緒。如果伺服器要銷毀servlet實例就會調用servlet實例的destory方法，否則該實例將會常駐記憶體。
JAVA SERVLET API中forward() 與redirect()的區別？
使用重定向：當調用sendRedirect方法時，Web容器就會向瀏覽器返迴響應，指示需要新的URL。因為瀏覽器發出了完全嶄新的請求，所以在重定向之前存儲為請求屬性的任何對象都會消失。
使用轉發：當為一個請求調用轉發時，請求就傳送給伺服器上另一個資源，而無需通知客戶機由不同的資源處理請求。這個過程完全在Web容器內部進行，客戶機絕不知曉。與重定向不同，轉發過程中，對象可以存儲在請求中，並傳送給下一個資源使用。
因為轉發過程完全在伺服器上進行，與客戶機沒用通信，因此轉發的性能優於重定向。
但是如果在JSP頁面上使用圖形的相對路徑和其他資源，轉發機制就會帶來問題。因為瀏覽器無從得知發生了轉發，所以相對路徑只是相對初始的Servlet，而不是所轉發到的JSP頁面。使用JSP自定義標籤可以解決這個問題。
如何現實servlet的單執行緒模式servlet的配置4、Servlet的基本架構
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
HttpServlet{
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}JSP中動態INCLUDE與靜態include的區別？
答：動態INCLUDE用jsp:include動作實現
<jsp:include page="included.jsp" flush="true" />它總是會檢查所含檔案中的變化，適合用於包含動態頁面，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含檔案的變化，適用於包含靜態頁面
<%@ include file="included.htm" %>
可能會讓你寫一段Jdbc連Oracle的程式,並實現數據查詢.
答:程式如下：
package hello.ant;
import java.sql.*;
public class jdbc {
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String theUser="admin";
String thePw="manager";
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc() {
try{
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql) {
try {
conn.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql) {
rs=null;
try {
rs=conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery("select * from test");
try{
while (rs.next()) {
System.out.println(rs.getString("id"));
System.out.println(rs.getString("name"));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}動態INCLUDE與靜態include的區別？
答：動態INCLUDE用jsp:include動作實現
它總是會檢查所含檔案中的變化，適合用於包含動態頁面，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含檔案的變化，適用於包含靜態頁面
可能會讓你寫一段Jdbc連Oracle的程式,並實現數據查詢.
答:程式如下：
package hello.ant;
import java.sql.*;
public class jdbc {
String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String theUser="admin";
String thePw="manager";
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc() {
try{
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql) {
try {
conn.executeUpdate(sql);
return true;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql) {
rs=null;
try {
rs=conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close(){
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery("select * from test");
try{
while (rs.next()) {
System.out.println(rs.getString("id"));
System.out.println(rs.getString("name"));
}
}catch(Exception e) {
e.printStackTrace();
}
}
}
說出在JSP頁面里是怎么分頁的?
頁面需要保存以下參數：
總行數：根據sql語句得到總行數
每頁顯示行數：設定值
當前頁數：請求參數
頁面根據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行即可。
說出在JSP頁面里是怎么分頁的?
頁面需要保存以下參數：
總行數：根據sql語句得到總行數
每頁顯示行數：設定值
當前頁數：請求參數
頁面根據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行即可。
設計模式方面
1、開發中都用到了那些設計模式?用在什麼場合?
答：人們在自己的環境中不斷發現問題和尋找問題的解決方案的時候，發現有一些問題及其解決方案不斷變換面孔重複出現，但在這些不同的面孔後面有著共同的本質，這些共同的本質就是模式。設計模式就是用來描述解決這些問題的解決方案的核心的。
工廠模式
專門負責將大量有共同接口的類實例化。工廠模式可以動態確定將那一個類實例化，不必事先知道每次要實例化那一個類。
簡單工廠模式
或稱靜態工廠方法模式。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式就是由一個工廠類根據傳入的參數決定創建那一種產品類的實例。
簡單工廠模式涉及到工廠角色、抽象產品角色以及具體產品角色：l工廠類角色：含有與套用緊密相關的商業邏輯。工廠類在客戶端的直接調用下創建產品對象。l抽象產品角色：擔任這個角色的類是由工廠方法模式所創建的對象的父類，或它們共同擁有的接口。l具體產品角色：工廠方法模式所創建的任何對象都是這個角色的實例。
優點是：允許客戶端相對獨立於產品創建的過程，並且在系統引入新產品的時候無需修改客戶端。缺點是：如果有新的產品加入到系統中去，就需要修改工廠類，將必要的邏輯加入到工廠類中。
工廠方法模式
或稱多態性工廠模式。工廠方法模式的用意是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中。工廠方法模式中，核心的工廠類不再負責所有的產品的創建，而是將具體創建的工作交給子類去做。它僅負責給出具體工廠子類必須實現的接口。這樣可以用來允許系統在不修改具體工廠角色的情況下引進新的產品。
工廠方法模式涉及到的角色：l抽象工廠角色：它不包含套用邏輯。任何在模式中創建對象的工廠類必須實現這個接口。l具體工廠角色：含有與套用密切相關的邏輯，並且受到應用程式的調用以創建產品對象。l抽象產品角色：工廠方法模式所創建的對象的超類型，也就是產品對象的共同父類或共同擁有的接口。l具體產品角色：這個角色實現了抽象產品角色所聲明的接口。
單例模式
確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。
特點：單例類只能有一個實例；單例類必須自己創建自己的惟一的實例；單例類必須給所有其他對象提供這一實例。
多例模式
多例類可以有多個實例，並且多例類必須自己創建、管理自己的實例，並向外界提供自己的實例。
在系統中可以用於資料庫連線池、鍵值快取等。
代理模式
給某個對象提供一個代理對象，並由代理對象控制對原對象的引用。
代理模式所涉及的角色：抽象主題角色：聲明了真實主題和代理主題的共同接口，這樣一來在任何可以使用真實主題的地方都可以使用代理主題角色。簡單工廠模式
或稱靜態工廠方法模式。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式就是由一個工廠類根據傳入的參數決定創建那一種產品類的實例。
簡單工廠模式涉及到工廠角色、抽象產品角色以及具體產品角色：l工廠類角色：含有與套用緊密相關的商業邏輯。工廠類在客戶端的直接調用下創建產品對象。l抽象產品角色：擔任這個角色的類是由工廠方法模式所創建的對象的父類，或它們共同擁有的接口。l具體產品角色：工廠方法模式所創建的任何對象都是這個角色的實例。
優點是：允許客戶端相對獨立於產品創建的過程，並且在系統引入新產品的時候無需修改客戶端。缺點是：如果有新的產品加入到系統中去，就需要修改工廠類，將必要的邏輯加入到工廠類中。
工廠方法模式
或稱多態性工廠模式。工廠方法模式的用意是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中。工廠方法模式中，核心的工廠類不再負責所有的產品的創建，而是將具體創建的工作交給子類去做。它僅負責給出具體工廠子類必須實現的接口。這樣可以用來允許系統在不修改具體工廠角色的情況下引進新的產品。
工廠方法模式涉及到的角色：l抽象工廠角色：它不包含套用邏輯。任何在模式中創建對象的工廠類必須實現這個接口。l具體工廠角色：含有與套用密切相關的邏輯，並且受到應用程式的調用以創建產品對象。l抽象產品角色：工廠方法模式所創建的對象的超類型，也就是產品對象的共同父類或共同擁有的接口。l具體產品角色：這個角色實現了抽象產品角色所聲明的接口。
單例模式
確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。
特點：單例類只能有一個實例；單例類必須自己創建自己的惟一的實例；單例類必須給所有其他對象提供這一實例。
多例模式
多例類可以有多個實例，並且多例類必須自己創建、管理自己的實例，並向外界提供自己的實例。
在系統中可以用於資料庫連線池、鍵值快取等。
代理模式
給某個對象提供一個代理對象，並由代理對象控制對原對象的引用。
代理模式所涉及的角色：抽象主題角色：聲明了真實主題和代理主題的共同接口，這樣一來在任何可以使用真實主題的地方都可以使用代理主題角色。
