IT面試筆試題全集-史上-JAVA篇4-Rain系列

IT面試筆試題全集—史上最全_JAVA篇4_Rain系列

JSF如何進行表格逐理及取值？

—追雨制作

importjavax.faces.model.DataModel;

importjavax.faces.model.ListDataModel;

DataModd:代表一個表格，其可以從客戶端傳上來。

實例化：

DataModeldm=newListDataModel();

將一個list值放入到DataModel中.

dm.setWrappedData(list)

將客戶端當前行取出

(LogsVO)dm.getRowData()

對于多條的查詢及增刪改在模型中加入了如下屬性：

模型的名稱是bean,其下的屬性是

DataModeldm:代表返有的行數(shù)據(jù)

VOvo:代表一行數(shù)據(jù)。

取一行：

vo=(VO)dm.getRowData();

通#{bean.vo.屬性名},如果修改對應(yīng)信息自動修改。

增加一行：

this.vo=newV0();

通#{bean.vo.屬性名},顯示肯定無值，但客戶輸入值提交后會將值勤寫入

JSF面試題：Jsf中導(dǎo)航的標簽是什么?

追雨制作

<navigation-rule>

<from-view-id>/main.jsp

</from-view-id>

<navigation-case>

<from-outcome>success

</from-outcome>

/result.jsp

</to-view-id>

</navigation-case>

</navigation-rule>

JSF面試題：如何管量web層中的Bean,用什么標簽。如何通過jsp

頁面與Bean綁定在一起進行處理？

—追雨制作

<managed-bean>

<managed-bean-name>checkNumber

</managed-bean-name>

<managed-bean-class>jsfl.CheckNumber

</managed-bean-class>

<managed-bean-scope>session

</managed-bean-scope>

</managed-bean>

JSF面試題：Jsf中的核心類用那些?有什么作用？LiftCycle六大生命

周期是什么？

一追雨制作

JSP的核心類主要有

FacesServlet

LiftCycleFacesContext

LiftCycle的生命周期是：恢復(fù)視圖，應(yīng)用請求值，校驗，更新模型。調(diào)用應(yīng)用程序-

＞呈現(xiàn)響應(yīng)

介紹一下ibatis的核心類？

一追雨制作

SqlMapClientBuilder:加載配置文件，返RI一個會話。

SqlMapClient:具體的會話

Listlist=queryForList（

標簽名

,object）;

Objectobj=queryForObject（

標簽名

,object）;

delete（

標簽名

,object）

update（

標簽名

,object）

insert（

標簽名

,object）

工程的使用：

將ibatisfactory拷貝到工程目錄下

將ms的3個包及ibatis的三個包拷貝到/WEB-INF/lib下

修改ibatisfhctory中的abatorConfig.xml文件

進入ibatisfactory目錄運行java-jarabator.jarabatorConfig.xmlue

將sql標記、select>update>insert、delete的副本刪除

spring

amp;ibatis:

dataSource

sqlMapClient:SqlMapClientFactoryBean

configLocation

classpath:sqlMapClient.xml

/WEB-INF/sqlMapClient.xml

dataSource

ansactionManager:DataSourceTransactionManager

dataSource

customerDaoextendsSqlMapClientDaoSupport

sqlMapClient

buyDao

sqlMapClient

Facade

buyDao

customerDao

absactProxy:TransactionProxyFactoryBean

ansactionManager

ansactionAtibutes

facadeProxy

target:fa?ade

ibatis的核心配置文件都有什么？

_追雨制作

sqlmapclient.xml：數(shù)據(jù)庫連接及相關(guān)o/rMapping的映射文件

(hibemate.cfg.xml)

sqlmapBuy.xml:具體的o/rmapping映射(*.hbm.xml)

四大標記：

select

update

delete

insert

procedure

描述Cookie和Session的作用,區(qū)別和各自的應(yīng)用范圍,SessionI

作原理。

_追雨制作

Cookie:主要用在保存客戶端，其值在客戶端與服務(wù)端之間傳送，不

安全，存儲的數(shù)據(jù)量有限。

Session:保存在服務(wù)端，每一個session在服務(wù)端有-一個sessionlD作一個標識。存

儲的數(shù)據(jù)量大，安全性高。占用服務(wù)端的內(nèi)存資源。

簡單說說tomcat的配置？

一追雨制作

JAVA_HOME=JDK的根目錄

CATALINA_HOME=tomcat的根目錄

CATALINA-HOME\conf\server.xml:可以配置tomcat的端口，可以配置tomcat中下

連接池。

CATALINA-HOME\common\lib:存放公用的類包

在Myeclipse中如何配置tomcat

在eclipse中，選擇windows->preference->MyEclipse->ApplicationServer->Tomcat

選擇Tomcat的安裝目錄，并選擇TomCat所需的jdk,選擇enable,確定即可。

簡述你對Statement,PreparedStatement,CallableStatement的理解

—追雨制作

statement用于執(zhí)行靜態(tài)SQL語句并返回它所生成結(jié)果的對象，在執(zhí)

行時確定sqlo

PreparedStatement表示預(yù)編譯的SQL語句的對象。SQL語句被預(yù)編譯并且存儲在

PreparedStatement對象中。然后可以使用此對象高效地多次執(zhí)行該語句，可以傳參

數(shù)，在得到PreparedStatement對象時確定sql.

CallableStatement用于執(zhí)行SQL存儲過程的接口。如果有輸出參數(shù)要注冊說明是輸

出參數(shù)。

如何用Java判斷一個文件或目錄是否存在?

—追雨制作

Filef=newFile(

C:\\entityBean

)；

ifi(f.exists())

System.out.println(

exist

)；

else

System.out.println(

notexist

);

如何用Java實現(xiàn)列出某個目錄下的所有子目錄？

—追雨制作

publicstaticvoidmain(Sing[]args)throwsException

getFile(newFile(

C:\\entityBean

),

publicstaticvoidgetFile(File[Singsem)throwsException

ji

System.out.println(sem+f.getName());

Filefl[]=f.listFiles();

if(fl.length>=l)

for(inti=0;i

<fl.length;i++)

if(fl[i].isDirectory())

getFile(fl[i],sem+

)；

請用Java實現(xiàn)列出某個目錄下的所有文件

—追雨制作

Importjava.io.File;

Filef=newFile(

C:\\

)；

File[]fl=f.listFiles();

fbr(inti=0;i

<fl.length;i++)

if(fl[i].isDirectory())

System.out.println(

dirctoryis

+fl[i].getName());

)

else

System.out.println(

fileis

+fl[i].getName());

介紹一下Java的輸入輸出流

追雨制作

在java使用流的機制進行數(shù)據(jù)的傳送，從文件到內(nèi)存是輸入流，從

內(nèi)存到文件是輸出流，輸入流可以通過read讀取，輸出流以write或print寫入，

對于流可以是分為高層流和低層流，低層以一個字節(jié)或字符為單位進行處理，高層

流以一批數(shù)據(jù)為單位進行處理。

FilelnputSeam（System.in）至InputSteamReader至BuffferReader

OutputSteam（System.out）至printSeam

FileReader至BufferedReader

FileWriter至PrintWriter或bufferWriter

分類：

字節(jié)（二進制）

FilelnputSeam（低層輸入流）

FileOutputSeam（低層輸出流）

PrintSeam（高層流）System.out.println（）

字符（一-個char）

FileReader

FileWriter

線程的基本概念、線程的基本狀態(tài)以及狀態(tài)之間的關(guān)系

一追雨制作

線程是進程內(nèi)的并發(fā)，沒有自己內(nèi)存空間，共享進程的，線程間的

通信成本較低。

Java中的線程有四種狀態(tài)分別是：運行、就緒、掛起、結(jié)束。

java中有幾種類型的流？JDK.為每種類型的流提供了一些抽象類以供

繼承，請說出他們分別是哪些類？

—追雨制作

字節(jié)流，字符流。字節(jié)流繼承于InputSeamOutputSeam,字符流繼

承于ReaderWriter。在java.io包中還有許多其他而流，低層流與調(diào)層流，高層流

主要是為了提高性能和使用方便。

Set里的元素是不能重復(fù)的，那么用什么方法來區(qū)分重復(fù)與否呢？是

用==還是equals()?它們有何區(qū)別?用contains來區(qū)分是否有重復(fù)的對象。還是都不

用。

—追雨制作

在比較時先調(diào)用hashCode方法，如果不相同，證明不相等。

如果相同，再調(diào)用equals方法，如果equals方法相同，證明相等，不相同，證明

不相等。

==:主要用在基本數(shù)據(jù)類型及引用

Equals:主要是對象或?qū)ο笠玫谋容^。

集合中是否包含某一個元素用contains來判斷。

請用用java代碼寫一個堆棧

一追雨制作

publicclassStack{

int[]data;

intmaxSize;

inttop;

publicStack(intmaxSize){

this.maxSize=maxSize;

data=newint[maxSize];

top=-1;

*依次加入數(shù)據(jù)

*@paramdata要加入的數(shù)據(jù)

*@retum添加是否成功

*/

publicbooleanpush(intdata){

if(top+l==maxSize){

System.out.println(

棧已滿!

）；

returnfalse;

this.data[-H-top]=data;

returnue;

*從棧中取出數(shù)據(jù)

*@retum取出的數(shù)據(jù)

*/

publicintpop()throwsException{

if(top==-l){

thrownewException(

棧已空！

)；

)

returnthis.data[top-];

publicstaticvoidmain(Sing[]args)throwsException{

Stackstack=newStack(lOOO);

stack.push(l);

stack.push(2);

stack.push(3);

stack.push(4);

stack.push(5);

while(stack.top>=0)

System.out.println(stack.pop());

java中實現(xiàn)多態(tài)的機制是什么？

一追雨制作

靜態(tài)的多態(tài):方法名相同，參數(shù)個數(shù)或類型不相同。(overloading)

動態(tài)的多態(tài)：

子類覆蓋父類的方法，將子類的實例傳與父類的引用調(diào)用的是子類的方法

實現(xiàn)接口的實例傳與接口的引用調(diào)用的實現(xiàn)類的方法。

編碼轉(zhuǎn)換，怎樣實現(xiàn)將GB2312編碼的字符串轉(zhuǎn)換為ISO-8859-1編

碼的字符串。

—追雨制作

Singa=newSing(

中

,getBytes(

gb2312

#8243;),

iso-8859-1

#8243;);

Singa=newSing(

中

.getBytes(

iso-8859-1

#8243;));

Java如何格式化日期？

—追雨制作

Importjava.text.SimpleDateFormat;

SimpleDateFormatsdf=newSimpleDateFormat(

yyyy-MM-ddhh:mm:ss

)；

Datedat=newDate();

〃把日期轉(zhuǎn)化為字符串

Sings=sdf.fdrmat(dat);

System.out.println(s);

〃將字符串轉(zhuǎn)化為日期

Java.util.Dated1=sdf.parse("yyyy-mm-dd");

如何獲取某個日期是當月的最后-?天

一追雨制作

當前日期加一天，若當前日期與結(jié)果的月份不相同，就是最后一

天。

取下一個月的第一天，下一個月的第一天-1

publicstaticvoidmain(Sing[]args)

Calendarc=Calendar.get!nstance();

c.set(Calendar.YEAR,2004);

c.set(Calendar.MONTH,0);

c.set(Calendar.DAY_OF_MONTH,30);

Calendarcl=(Calendar)c.clone();

System.out.println(c.get(Calcndar.YEAR)+

#8220;+(c.get(Calendar.MONTH)+1)+

#8220;+c.get(Calendar.DAY_OF_MONTH));

c.add(Calendar.DAY_OF_MONTH,1);

if(c.get(Calendar.MONTH)!=cl.get(Calendar.MONTH))

System.out.println(

是最后一天

)；

else

System,out.println(

不是取后一關(guān)

)；

如何喚起類中的一個方法

一追雨制作

產(chǎn)生一個Class數(shù)組，說明方法的參數(shù)

通過Class對象及方法參數(shù)得到Method

通過method.invoke（實例滲數(shù)值數(shù)組）喚醒方法

得到Class的三個過程是什么

一追雨制作

對象.getClass。

類.class或Integer.type(int)Integer.class(java.lang.Integer)

Class.forName();

類的返射機制中的包及核心類

一追雨制作

java.lang.Class

java.lang.rcfrcction.Method

java.lang.rcfrcction.Field

java.lang.rcfrcction.Consuctor

java.lang.rcfrcction.Modifier

java.lang.rcfrcction.Interface

什么是類的返射機制

一追雨制作

通過類（Class對象），可以得出當前類的fields、method、consutor、

interface、superClass、modified等，同是可以通過類實例化一個實例、設(shè)置屬性、

喚醒方法。Spring中一切都是返射、suts、hibernate都是通過類的返射進行開發(fā)

的。

Final類有什么特點

—追雨制作

屬性常量

方法不可以overridding

類不可以繼承

排序都有哪兒種方法？請列舉。用JAVA實現(xiàn)…個快速排序？

—追雨制作

排序的方法有：插入排序（直接插入排序、希爾排序），交換排序

（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸并排序，分配

排序（箱排序、基數(shù)排序）

用Java語言實現(xiàn)的各種排序，包括插入排序、冒泡排序、選擇排序、Shell排

序、快速排序、歸并排序、堆排序、SortUtil等。

插入排序：

packageorg.rut.utiLalgorithm.support;

importorg.rut.util.algorithiTi.SortUtil;

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassInsertSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.utiLalgorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

fbr(inti=l;i

<data.length;i++){

fbr(intj=i;(j>0)

amp;

amp;(data[j]

<data{j-l])y

){

Sort(Jtil.swap(data,j,j-1);

冒泡排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassBubbleSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

fbr(inti=0;i

<data.length;i++){

fbr(intj=data.length-1;j>i;j

){

if(data[j]

<data[j-l]){

SortUtil.swap(data,j,j-l);

選擇排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassSelectionSortimplementsSortUtil.Sort{

/*

*(non-Javadoc)

*

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

for(inti=0;i

<data.length;i++){

intlowlndex=i;

for(intj=data.length

)(

if(data[j]

<dataflowIndex]){

lowlndex=j;

SortUtil.swap(data,iJowIndex);

}

Shell排序:

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassShellSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

fbr(inti=data.length/2;i>2;i/=2){

fbr(intj=O;j

<i；j++){

insertSort(data,j,i)；

}

}

insertSort(data,0,l);

*@paramdata

*@paramj

*@parami

*/

privatevoidinsertSort(int[]data,intstart,intinc){

inttemp;

fbr(inti=start+inc;i

<data.length;i+=inc){

fdr(intj=i;(j>=inc)

amp;

amp;(data[j]

<data[j-inc]);j-=inc){

SortUtil.swap(dataj,j-inc);

i

J

}

}

}

快速排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassQuicksortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

quickSort(data,0,data.length-1);

privatevoidquickSort(int[]data,inti,intj){

intpivotIndex=(i+j)/2;

//swap

SortUtil.swap(data,pivotindex,j);

intk=partition(data,i-l,j,data[j]);

SortUtil.swap(data,k,j);

if((k-i)>l)quickSort(data,i,k-1);

if((j-k)>l)quickSort(data,k+1j);

*@paramdata

*@parami

*@paramj

*@retum

*/

privateintpartition(int[]data,int1,intr,intpivot){

do{

while(data[++l]

<pivot);

while((r!=O)

amp;

amp;data[—r]>pivot);

SortUtil.swap(data,l,r);

}

while(l

<r)；

SortUtiLswap(data,l,r);

return1;

)

}

改進后的快速排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassImprovedQuickSortimplementsSortUtil.Sort{

privatestaticintMAX_STACK_SIZE=4096;

privatestaticintTHRESHOLD=10;

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]stack=newint[MAX_STACK_SIZE];

inttop=-1;

intpivot;

intpivotindex,l,r;

stack[+4-top]=0;

stack[++top]=data.length-1;

while(top>0){

intj=stack[top-];

inti=stack[top-];

pivotlndex=(i+j)/2;

pivot=data[pivotlndex];

SortUtil.swap(data,pivotindex,j);

//partition

l=i-l;

r=j；

do{

while(data[-H-l]

<pivot);

while((r!=O)

amp;

amp;(data[—r]>pivot));

SortUtil.swap(data,l,r);

i

while(l

<r)；

SortUtil.swap(data,l,r);

SortUtil.swap(data,l,j);

if((l-i)>THRESHOLD){

stack[++top]=i;

stack[++top]=l-l;

i

J

if((j-I)>THRESHOLD){

stack[++top]=l+l;

stack[++top]=j;

//newInsertSort().sort(data);

insertSort(data);

*@paramdata

*/

privatevoidinsertSort(int[]data){

inttemp;

fbr(inti=l;i

<data.length;i++){

fbr(intj=i;(j>O)

amp;

amp;(data[j]

<data[j-l]);j

){

Sort(Jtil.swap(data,j,j-1);

)

}

歸并排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassMergeSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]temp=newint[data.length];

mergeSort(data,temp,0,data.length-1);

j

privatevoidmergeSort(int[]data,int[]temp,intl,intr){

intmid=(l+r)/2;

if(l==r)return;

mergeSort(data,temp,1,mid);

mergeSort(data,temp,mid+1,r);

fbr(inti=l;i

<=r;i-H-){

temp[i]=data[i];

)

intil=l;

inti2=mid+l;

fbr(intcur=l;cur

<=r;cur++){

if(il==mid+l)

data[cur]=temp[i2-H-];

elseif(i2>r)

data[cur]=temp[il-H-];

elseif(temp[il]

<temp[i2])

data[cur]=temp[il++];

else

data[cur]=temp[i2++];

f

)

}

改進后的歸并排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassImprovedMergeSortimplementsSortUtil.Sort{

privatestaticfinalintTHRESHOLD=10;

/*

*(non-Javadoc)

*

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]temp=newint[data.length];

mergeSort(data,temp,0,data.length-1);

f

privatevoidmergeSort(int[]data,int[]temp,int1,intr){

inti,j,k；

intmid=(1+r)/2;

if(l==r)

return;

if((mid

1)>=THRESHOLD)

mergeSort(data,temp,1,mid);

else

insertSort(data,1,mid

1+1)；

if((r

mid)>THRESHOLD)

mergeSort(data,temp,mid+1,r);

else

insertSort(data,mid+1,r

mid);

for(i=1;i

<=mid;i++){

temp[i]=data[i];

f

fbr(j=l；j

<=r

mid;j++){

temp[r-j+1]=data[j+mid];

inta=temp[l];

intb=temp[r];

fbr(i=I,j=r,k=l;k

<=r;k++){

if(a

<b){

data[k]=temp[i++]；

a=temp[i];

}else{

data[k]=temp[j-];

b=temp[j];

*@paramdata

*@param1

*@parami

*/

privatevoidinsertSort(int[]data,intstart,intlen){

fbr(inti=start+l;i

<start+len;i++){

fbr(intj=i;(j>start)

amp;

amp;data[j]

<data[j-l];j

)(

SortUtil.swap(data,j,j-l);

堆排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassHeapSortimplementsSortUtiLSort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

MaxHeaph=newMaxHeap();

h.init(data);

fbr(inti=0;i

<data.length;i++)

h.remove();

System.arraycopy(h.queue,1,data,O,data.length);

f

privatestaticclassMaxHeap{

voidinit(int[]data){

this.queue=newint[data.length+1]；

for(inti=0;i

<data.length;i++){

queue[++size]=data[i];

fixUp(size);

)

privateintsize=O;

privateint[]queue;

publicintget(){

returnqueuefl];

publicvoidremove(){

SortUtil.swap(queue,l,size

)；

fixDown(l);

//fixdown

privatevoidfixDown(intk){

intj;

while((j=k

<

<1)

<=size){

if(j

<size

amp;

amp;queue[j]

<queue[j+l])

j++;

if(queue[k]>queue[j])//不用交換

break;

SortUtil.swap(queueJ,k);

k=j；

}

ji

privatevoidfixUp(intk){

while(k>1){

intj=k?1;

if(queue[j]>queue[k])

break;

SortUtil.swap(queueJ,k);

k=j；

}

)

f

\

f

SortUtil：

packageorg.rut.util.algorithm;

importorg.rut.util.algorithm.support.BubbleSort;

importorg.rut.utiLalgorithm.support.HeapSort;

importorg.rut.util.algorithm.support.ImprovedMergeSort;

importorg.rut.util.algorithm.support.ImprovedQuickSort;

importorg.rut.utiLalgorithm.support.InsertSort;

importorg.rut.utiLalgorithm.support.MergeSort;

importorg.rut.util.algorithm.support.Quicksort;

importorg.rut.util.algorithm.support.SelectionSort;

importorg.rut.util.algorithm.support.ShellSort;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassSortUtil{

publicfinalstaticintINSERT=1;

publicfinalstaticintBUBBLE=2;

publicfinalstaticintSELECTION=3;

publicfinalstaticintSHELL=4;

publicfinalstaticintQUICK=5;

publicfinalstaticintIMPROVEDQUICK=6;

publicfinalstaticintMERGE=7;

publicfinalstaticintIMPROVED_MERGE=8;

publicfinalstaticintHEAP=9;

publicstaticvoidsort(int[]data){

sort(data,IMPROVEDQUICK);

)

privatestaticSing[]name={

#8220;insert

#8220;bubble

#8220;selection

#8220;shell

#8220;quick

#8220;improved_quick

#8220;merge

#8220;improvedmerge

#8220;heap

)；

privatestaticSort[]impl=newSort[]{

newInsertSort(),

newBubbleSort(),

newSelectionSort(),

newShellSort(),

newQuickSort(),

newImprovedQuickSort(),

newMergeSort(),

newImprovedMergeSortO,

newHeapSort()

);

publicstaticSingtoSing(intalgorithm){

returnname[algorithm-1];

publicstaticvoidsort(int[]data,intalgorithm){

impl[algorithm-1].sort(data);

j

publicstaticinterfaceSort{

publicvoidsort(int[]data);

publicstaticvoidswap(int[]data,inti,intj){

inttemp=data[i];

data[i]=data[j];

data[j]=temp;

JAVA的事件委托機制和垃圾回收機制

一追雨制作

java事件委托機制的概念，一個源產(chǎn)生一個事件并將它送到一個或多

個監(jiān)聽器那里。在這種方案中，監(jiān)聽器簡單的等待，直到它收到一個事件。一旦事

件被接受，監(jiān)聽器將處理這個事件，然后返回。

垃圾回收機制垃圾收集是將分配給對象但不再使用的內(nèi)存回收或釋放的過程。如

果一個對象沒有指向它的引用或者其賦值為null,則次對象適合進行垃圾回收

編程輸出如下圖形

—追雨制作

****

***

**

*

代碼如下：

publicclassPrint{

publicstaticvoidmain(Sing[]args){

for(inti=0;i

<5；i++)(

for(intj=5;j>i;j

){

System.out.print(

*

)；

System.out.println();

super。與this。的區(qū)別？

—追雨制作

This()：當前類的對象,super父類對象。

Super()：在子類訪問父類的成員和行為，必須受類繼承規(guī)則的約束

而this他代表當前對象，當然所有的資源都可以訪問.

在構(gòu)造函數(shù)中，如果第一行沒有寫super。,編譯器會自動插入.但是如果父類沒有不帶

參數(shù)的構(gòu)造函數(shù)，或這個函數(shù)被私有化了(用private修飾).此時你必須加入對父類的

實例化構(gòu)造.而this就沒有這個要求,因為它本身就進行實例化的構(gòu)造.

而在方法中super和this使用的方法就差不多了.只不過super要考慮是否能訪問其

父類的資源.

J2EE的優(yōu)越性主要表現(xiàn)在哪些方面？

_追雨制作

J2EE的優(yōu)越性主要表現(xiàn)在如下兒個方面：

1、J2EE基于JAVA技術(shù)，與平臺無關(guān)

2、J2EE擁有開放標準，許多大型公司實現(xiàn)了對該規(guī)范支持的應(yīng)用服務(wù)器。如

BEA,IBM,ORACLE等。

3、J2EE提供相當專業(yè)的通用軟件服務(wù)。

4、J2EE提供了一個優(yōu)秀的企業(yè)級應(yīng)用程序框架，對快速高質(zhì)量的開發(fā)應(yīng)用系統(tǒng)

打下了基礎(chǔ)

J2EE中的容器都包括哪些？

_追雨制作

J2EE中容器充當中間件的角色。主要的容器包括：

WEB容器：給處于其中的應(yīng)用程序組件(JSP,SERVLET)提供一個環(huán)境，使

JSP,SERVLET直接更容器中的環(huán)境變量接口交互，不必關(guān)注其它系統(tǒng)問題。主要

有WEB服務(wù)器來實現(xiàn)。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。該容器提

供的接口嚴格遵守J2EE規(guī)范中的WEBAPPLICATION標準。我們把遵守以上標

準的WEB服務(wù)器就叫做J2EE中的WEB容器。

EJB容器：Enterprisejavabean容器。更具有行業(yè)領(lǐng)域特色。他提供給運行在其中

的組件EJB各種管理功能。只要滿足J2EE規(guī)范的EJB放入該容器，馬上就會被容

器進行高效率的管理。并且可以通過現(xiàn)成的接口來獲得系統(tǒng)級別的服務(wù)。例如郵件

服務(wù)、事務(wù)管理。

WEB容器和EJB容器在原理上是大體相同的，更多的區(qū)別是被隔離的外界環(huán)境。

WEB容器更多的是跟基于HTTP的請求打交道。而EJB容器不是。它是更多的跟

數(shù)據(jù)庫、其它服務(wù)打交道。但他們都是把與外界的交互實現(xiàn)從而減輕應(yīng)用程序的負

擔(dān)。例如SERVLET不用關(guān)心HTTP的細節(jié)，直接引用環(huán)境變量

session,request,response就行、EJB不用關(guān)心數(shù)據(jù)庫連接速度、各種事務(wù)控制，直接

由容器來完成。

RMI/IIOP:遠程方法調(diào)用/internet對象請求中介協(xié)議，他們主要用于通過遠程調(diào)用服

務(wù)。例如，遠程有一臺計算機上運行一個程序，它提供股票分析服務(wù)，我們可以在

本地計算機上實現(xiàn)對其直接調(diào)用。當然這是要通過一定的規(guī)范才能在異構(gòu)的系統(tǒng)之

間進行通信。RMI是JAVA特有的。

JNDLJAVA命名目錄服務(wù)。主要提供的功能是：提供一個目錄系統(tǒng)，讓其它各地

的應(yīng)用程序在其上面留下自己的索引，從而滿足快速查找和定位分布式應(yīng)用程序的

功能。

JMS:JAVA消息服務(wù)。主要實現(xiàn)各個應(yīng)用程序之間的通訊。包括點對點和廣播。

JAVAMAIL:JAVA郵件服務(wù)。提供郵件的存儲、傳輸功能。他是JAVA編程中實

現(xiàn)郵件功能的核心。相當MS中的EXCHANGE開發(fā)包。

JTA：JAVA事務(wù)服務(wù)。提供各種分布式事務(wù)服務(wù)。應(yīng)用程序只需調(diào)用其提供的接

口即可。

JAFJAVA安全認證框架。提供一些安全控制方面的框架。讓開發(fā)者通過各種部署

和自定義實現(xiàn)自己的個性安全控制策略。

EAI:企業(yè)應(yīng)用集成。是一種概念，從而牽涉到好多技術(shù)。J2EE技術(shù)是一種很好的

集成實現(xiàn)。

JPA面試常見問題

一追雨制作

這篇文章是摘自PaickLinskey的一篇文章，主要是關(guān)于JPA相關(guān)內(nèi)

容的問答，相信JPA面試會碰到很多這里面的問題

問題：EJB專家團隊是如何擺脫事務(wù)描述符的？

回答：在會話bean和消息驅(qū)動bean中，可以通過描述符和注釋來控制事務(wù)的行

為。此外，我們將默認的事務(wù)屬性更改為“REQUIRED”，這個默認值比以前的值

“SUPPORTS”更常用。因此，完全不必為業(yè)務(wù)方法配置事務(wù)行為。

JPA實體僅供本地使用，重點關(guān)注域模型。因此，無法在JPA實體上配置事務(wù)性

（或遠程邊界或安全性）。而是必須使用會話beanfaqade（或消息驅(qū)動bean）,才可以

通過EJB協(xié)議使用這些實體。通常來說，這是一件好事，配置安全性、遠程處理

和事務(wù)的粒度應(yīng)該比持久化數(shù)據(jù)的粒度粗很多。JPA著重關(guān)注持久化數(shù)據(jù)，以及與

EJB的其他部分和JavaEE規(guī)范集成起來照管其他企業(yè)關(guān)注點。

問題：推薦對主鍵使用“l(fā)ong”還是“Long”?如果允許使用null作為值，將會如何？

回答：這實際上取決于您的數(shù)據(jù)模型。如果您的數(shù)據(jù)模型允許主鍵為null,那么使

用Long,如果您的數(shù)據(jù)模型規(guī)定主鍵列不能為null,則使用long更合適。總的來

說，我認為對于非復(fù)合主鍵，允許null作為合法值容易產(chǎn)生混淆，因此我傾向于

使用long,而不是Long。

問題：您說EJB2.0不支持繼承，但是可以在幾個不同位置（遠程/bean）使用繼承，

只是不在本地使用而已。請解釋一下。

回答：根據(jù)EJB2.1規(guī)范的附錄D3：

當前的EJB規(guī)范未指定組件繼承的概念。

另一方面，JPA規(guī)范確實規(guī)定了實體繼承的概念。我們已經(jīng)處理了EJB2.1規(guī)范中

指出的各種問題和復(fù)雜性，現(xiàn)在允許完全的多態(tài)查詢和關(guān)聯(lián)。

問題：BEA計劃什么時候支持/發(fā)布EJB3?

WcbLogicServer10TechnologyPreview是完全符合規(guī)范的JavaEE5應(yīng)用服務(wù)器。

它包括完整的EJB3支持。WebLogicServer10大概于三月下旬發(fā)布。

此外，Kod。是完全符合規(guī)范的生產(chǎn)就緒JPA實現(xiàn)，并且已經(jīng)發(fā)布。

問題：JPA是否支持組合主鍵？

回答：JPA支持自然ID和組合ID,以及數(shù)據(jù)庫指派或?qū)崿F(xiàn)指派的數(shù)字值。

問題：是否存在Spring模板，像JDBC模板一樣可以在容器外部使用？

回答:是的，Spring2有JPA模板。但是，Spring2可以對任何標記著?Repository

的bean執(zhí)行JPA異常轉(zhuǎn)譯。因此，總的來說，對于新的應(yīng)用程序，最好直接使用

JPAAPI,而不是另一個模板層。對于使用模板和正在遷移到JPA的現(xiàn)有應(yīng)用程序

來說，使用模板方法比較合理。

此外，可以像在JavaEE服務(wù)器中--樣將JPA的持久化單元部署到Spring,Spring

對JPA規(guī)范中指出的EntityManager注入和查找服從容器規(guī)則。

問題：JPA是否支持JDKL4?

回答：JPA需要Java5或更新版本。

問題：使用范圍查詢時，它是否也會返回結(jié)果總數(shù)(例如，返回538項結(jié)果中的1-

10項)？

回答：不，要想獲得總數(shù)，必須發(fā)出另外一個查詢。通用模式是，在第一次執(zhí)行搜

索時獲得總數(shù)，然后通過頁面瀏覽結(jié)果，將總數(shù)存儲到方便的位置(會話狀態(tài)、

cookie等)：

if(isFirstPage()){//thisisthefirsttimewe

#8217;reexecutingthisquery

Queryq=em.createQuery(

SELECTCOUNT(p)FROMProductpWHERE

#8230;

)；

longcount=((Long)q.getSingleResult()).longValue();

//storecountsomewherestateful

Queryq=em.createQuery(

SELECTpFROMProductpWHERE

#8230;

)；

q.sctFirstResult(page*PAGESIZE);//pageisstoredsomewherestateful

q.sctMaxResults(PAGESIZE);

問題：具有JPA包裝器的Hibernate是不是一種EJB3實現(xiàn)？

回答：JPA規(guī)范是完整的EJB3規(guī)范的子集，因此JPA實現(xiàn)本身不是完整的EJB3

實現(xiàn)。我不了解RedHat的EJB3實現(xiàn)的情況如何。但，Hibernate是JPA實現(xiàn)。

問題：與Hibernate相比，JPA是不是更好？

回答：JPA是規(guī)范，而Hibernate是實現(xiàn)。因此，這是不同事物的比較?？梢钥?/p>

定，使用標準API比使用專有API有更多優(yōu)勢，但不存在真正的劣勢。

問題：是不是不再需要學(xué)習(xí)和使用Hibernate?

回答：規(guī)范團隊關(guān)于JPA1的目標之一是制定一個可以由很多供應(yīng)商實現(xiàn)的APL

并且開發(fā)人員可以編碼來實現(xiàn)該API,而不是使用私有供應(yīng)商特有的API。我們已

成功實現(xiàn)這個目標，因此您只需使用供應(yīng)商特有的API來獲得JPA規(guī)范沒有解決

但您的應(yīng)用程序中需要的功能。我的建議是盡可能地使用JPAAPI,但是當需要供

應(yīng)商公開但是規(guī)范中沒有提供的功能時，則使用供應(yīng)商特有的APL

例如，OpenJPA提供了保存點功能，但JPA規(guī)范沒有。因此，希望使用保存點的

OpenJPA開發(fā)人員應(yīng)該對代碼的大部分內(nèi)容使用JPA規(guī)范，而借助

OpenJPAEntityManager來設(shè)置和管理保存點。

問題：規(guī)范是否解決了緩存問題？

回答：JPA規(guī)范沒有解決二級緩存問題(EntityManagerFactory-級)，但是提供了實現(xiàn)

該緩存必須遵守的一些數(shù)據(jù)鎖定和一致性規(guī)則，即使在啟用緩存時也是如此。

有少量與緩存有關(guān)的主題可能會在將來的JPA規(guī)范版木中解決，但是大多數(shù)緩存

主題不必指定規(guī)則，這樣，不同的供應(yīng)商就可以輕松地完成不同的工作。此處增加

的最重要的內(nèi)容是一些基本緩存控制APL如回收某些對象ID,或?qū)⒁恍┙?jīng)常訪

問的ID固定到緩存中。

問題：既然實體管理器承擔(dān)了所有繁重的工作負載，那么會話bean還有什么價值？

回答：EntityManager負責(zé)域?qū)ο竽Ｐ秃蛿?shù)據(jù)庫之間的交互，但是仍然在會話中實

現(xiàn)安全性、事務(wù)控制、遠程處理、有狀態(tài)的臨時數(shù)據(jù)存儲，而操作單元編程模型無

法解決以上問題。會話bean還是部署單元和公用服務(wù)邊界。因此，會話bean是定

義所有業(yè)務(wù)代碼的地方。換而言之，會話bean是EJB容器關(guān)注的，而JPA實現(xiàn)是

在會話bean中使用的。

當然，您還可以直接從servlet或JSP或其他任何可以使用Java5的地方使用JPA。

但是這樣的話，您就必須管理自己的事務(wù)、處理自己的集群服務(wù)故障轉(zhuǎn)移、管理自

己的服務(wù)重部署等。

問題：相對于EJB2來說，EJB3可以處理多少個并發(fā)事務(wù)？

回答：從純會話bean的觀點來講，至少在WebLogicServer中，并發(fā)事務(wù)的數(shù)目沒

有什么差別。也就是，如果將您的應(yīng)用程序從EJB2會話bean轉(zhuǎn)換到EJB3會話

bean,但是完全沒有修改持久化機制，可能不會發(fā)現(xiàn)重大差別。這是因為EJB3規(guī)

范對會話bean部分的大多數(shù)更改著重實現(xiàn)編程模型的改進。

從實體bean的觀點來講，我認為對于大多數(shù)應(yīng)用程序，WebLogicServer的EJB

2.1和JPA支持的并發(fā)事務(wù)數(shù)目相同。您可能發(fā)現(xiàn)JPA對于非主鍵的查詢來說，可

伸縮性更高。一旦開始鉆研Kodo的鎖定組之類的功能，則對于固定的域模型，可

以從基于JPA的系統(tǒng)中獲得更多并發(fā)事務(wù)。

問題：如何為AquaLogicDSP應(yīng)用JPA?

回答：AquaLogicDSP著重關(guān)注對數(shù)據(jù)的多重存儲訪問，并將數(shù)據(jù)作為數(shù)據(jù)服務(wù)提

供，通常作為XML或SDO呈現(xiàn)這些數(shù)據(jù)。JPA規(guī)范著重關(guān)注與數(shù)據(jù)存儲交互的

JavaAPL可以設(shè)想，JPA綁定至UAquaLogicDSP,或SDO綁定到Kodo產(chǎn)品（BEA

的JPA實現(xiàn)）。

問題：什么是實現(xiàn)過程的最佳位置，例如，檢查許多用戶及其帳戶（在銀行應(yīng)用程

序中）以付給利息?是在數(shù)據(jù)庫的存儲過程中實現(xiàn)，還是在EJB中使用JPA實現(xiàn)，

還是同時使用這兩種方式？

回答：根據(jù)我的經(jīng)驗，這實際上取決于組織因素，而不是其他因素。一些工作室更

喜歡在存儲過程中進行大量編碼，而另一些則喜歡在Java中實現(xiàn)其業(yè)務(wù)邏輯。每

種方法各有優(yōu)勢和代價。

盡管如此，還是有一些問題可促使他們優(yōu)先考慮其中的一種環(huán)境。在您的例子中，

在數(shù)據(jù)庫中執(zhí)行大量計算可能比將數(shù)據(jù)加載到內(nèi)存中更快，因此使用存儲過程可能

比較合理。另一方面，數(shù)據(jù)庫承擔(dān)這么多負載將對該應(yīng)用程序的用戶產(chǎn)生負面影

響，因此最好付出一定代價跨網(wǎng)絡(luò)拉出這些數(shù)據(jù)，以便將該數(shù)據(jù)庫用作嚴格的存儲

系統(tǒng)，而不是計算引擎?；蛘撸绻麘?yīng)用程序的其余部分主要使用JPA,則適用的

話，可能希望使用JPQL的大批量更新功能來進行更新。

問題：如果不先將數(shù)據(jù)加載到內(nèi)存中，是否可以執(zhí)行大批量更新？

回答：是的，可以通過JPQL執(zhí)行大批量更新和大批量刪除：

UPDATEEmployeeeSETe.salary=e.salary*1.1WHEREe.salary

<100000

問題：你們對KodoJDO有什么規(guī)戈|J?JPA是否會通過實現(xiàn)JDO的所有功能而將其

取代?如果是的話，是否存在任何時間表?如果不是，你們會不會繼續(xù)積極地開發(fā)

JDO?

回答：BEA仍然完全忠于JDO。從規(guī)范的觀點來看，我認為過一段時間之后，JPA

將包含當前的JDO規(guī)范中越來越多的功能。但是，我不了解Sun對JDO和JPA之

間的融合工作有什么規(guī)劃。

問題：什么是持久化單元？

回答：持久化單元是類和配置設(shè)置的集合，可以根據(jù)該集合創(chuàng)建

EntityManagerFactory（,它在persistence.xml文件中作為一個條目出現(xiàn)。

問題：如何在WebLogic9.2中測試JPA

回答：現(xiàn)在可以在WebLogic9.2中使用OpenJPA或Kodo。該服務(wù)器不執(zhí)行會話

bean持久化單元注入，但是在10.0服務(wù)器中可以這么作，并且在9.2中，沒有任何

Kodo控制臺集成。但是除了引導(dǎo)注入問題之外，應(yīng)該能夠在WebLogic9.2中成功

地使用JPA,包括參與托管事務(wù)。

問題：JDBC連接對應(yīng)于JPA中的什么概念？

回答：JPAEntityManager大致相當于JDBC連接，而JPAEntityManagerFactory從

概念上類似于JDBC數(shù)據(jù)源。JPAEntityTransaction（僅在JTA/appserver上下文以

外可用）相當于JDBC連接的事務(wù)控制APL

在OpenJPA中,EntityManager在其生命周期中可能使用多個不同的JDBC連接。

請參閱openjpa.ConnectionRetainMode屬性的文檔了解詳細信息。

問題：關(guān)于fetch類型，如果默認是主動（eager）加載，則提供程序可能忽略惰性

（lazy）加載指令。因此，即使將字段設(shè)置為惰性，也可能會加載不必要的數(shù)據(jù)。將

來的規(guī)范會不會將其修改為必須與fecth類型一致?這會涉及至U什么問題？

回答：通常，OpenJPA永遠不會忽略用戶配置的FetchMode。這是提示而不是規(guī)

則，因為惰性加載實際上是調(diào)優(yōu)過程中一項關(guān)注事項，永遠都不應(yīng)該對應(yīng)用程序產(chǎn)

生行為性的影響*。JPA規(guī)范力圖避免要求使用任何明確的性能調(diào)優(yōu)策略，因為不

同的網(wǎng)絡(luò)拓撲結(jié)構(gòu)、數(shù)據(jù)存儲系統(tǒng)和應(yīng)用程序行為需要不同的調(diào)優(yōu)關(guān)注。

例如，OpenJPA允許在運行時動態(tài)控制fetch配置。這意味著，它可能靜態(tài)地配置

對