2024年JAVA面试题资料

从网上找到一份人人网JAVA的笔试题，做了一下，受益匪浅，贴出来，个人水

平有限，欢迎各位留言讨论。

JAVA笔试题

【填空题】

java面对对象的三大特性是：______,_______,_______.

答：封装，继承，多态。

sleep。和wait()的区分是.

答：(DsleepO不释放对象锁，wait。释放对象锁。

(2)slecp()能够在时间未届时被打断，抛出异常，因此需要捕捉异常，wait不

需要捕捉异常'

(3)sleep。是Thread类的措施，wait()是Object类的措施。

一个类被JVM回收的标志适.

答：类未被其他的活动类引用。

重写JAVAequals措施，需要同时重写：.

答：hashCode措施。这忌JAVA的常规约定，假如不重写hashCodc,使用

HashMap,HashSet等类时会出现错误。调用equals()措施比较两个对象的时候,

编译器会自动调用hashCodeO来比较两个对象是否产生相同的整数成

果.equals。返回true,则hashCode()必返回true,equals。返回false,则

hashCodc。必返回false.那么重写equals()措施，肯定必须重写hashCode措施

来确保二者的同时.

String,StringBuilder,StringBuffer的区分：.

答：String保存字符串常量，字符串的每次变化都会产生一个新的字符串对象。

StringBuilder和StringBuffer都是能够变化而不产生新的对象的。其中，

StringBuffcr是线程安全的，StringBuilder是线程不安全的。

增加数据表一列的SQL语法：.

答:alter[table]add[列].

JSP的内置对象及措施request,,_____,______.(常用三个即可)

答：

response,session,out,page,application,exception,pageContext,config.

List,Set,Map是否继承自Collection接口：.

答：List和Set是的，Map不是。

数据库事务特性,,,.

答：ACID,原子性，一致性，隔离性，持久性。

针对10,100,32,45,58,126,3,29,200,400,0利用除商留余法结构长

度为13的数据的HASH：.

答：所有除以25再取余数，再连到一起？成果是：0.也也许最后再MOD一个00,

题意没有读懂。

【选择题】

已知：

Integeri=newInteger(42);

Longl=newLong(42);

Doubled=ncwDouble(42.0);

下面哪些选项返何成果为true：

A.(i—1)

B.(i==d)

C.(d==l)

D.(i.equals(d))

E.(d.equals(1))

F.(i.equals(1))

G.(1.equals(42L))

答:ABC显然是错的,==比较的是两个对象的地址。Long和Double之间，Integer

和Double之间都是不能自动转化的。不过Long和Integer之间能够自动转化,

因此，F和G是止确的。

有关用abstract定义的类，下列说法正确的是()

能够被实例化B.不能够派生子类C.不能被继承D,只能被继承E.能够

被抽象类继承

答：概念题，DE是正确的。

当线程A使用某个对象，而此对象乂需要线程B修改后才能符合A线程的需要，

这时线程A就要等候线程B完成修改工作，这种现象称为()

线程的同时B.线程的互斥C.线程的调度D.线程的就绪

答：概念题，Co

在JAVA程序中定义一个类，类中有一个没有访问权限修饰的措施，则此措施()

A.类外的任何措施都能访问它

B.类外的任何措施都不能访问它

C.类的子类和同包类能访问它

D.只有类和同包类才能访问它

答：概念题，Do

有如下程序代码，在执行完后x和y的值是多少()

Tntx=8,y=2,z;

x=++x*y;

z=x/y++;

x=16,y=2.

X=16,y=4.

X=18,y=2.

X=18,y=3.

答：D,不解释。

【问答题】

int「0叮,++;以上操作中i=i++;是线程安全的吗？假如不安全请阐明上面操

作在JVM中执行过程，为何不安全？并且说出JDK中哪个类能达成以上程序的效

果，并且是线程安全并且高效，并简述其原理。

答：不是线程安全的。JW中，赋值语句的执行过程是，先把赋值号右边的值存

入一个栈中，再从栈中弹出到赋值号左边的变量中。因此，在执行i=i++后i的

值为0。不过假如在多线程的环境下执行i=i++,线程A中执行到把i压入栈，而

在此之前线程B中执行到把i++,那么栈中i的值就已经变化了，最后线程A执

行弹栈的操作，那么i的值就不是0了，因此是线程不安全的。Atomiclnteger

中提供了线程安全且高效的原子操作。其底层的原理是利用处理器的CAS(比较

并N换)操作米检测栈中的值是否被其他线程变化，假如被变化则CAS操作失败。

这种实现措施比用sycronized来实现同时，底层显然有着更高的执行效率。

2.数组int[n]a={l,2,2,……}数组a满足如下条件，均为正整数，

a[i+l]>=a[i]迅速找出满足的数。

答：这道题大家都没有想出0(logn)的算法，只好从常数上优化。能够看出的

一个性质是数组下标每次都是固定地增加1,因此若a[i]>i,则接下来的

a[i]-i-l个数一定不也许满足a[i]=i；假如则之前的i-a[i]-l个数

一定不也许满足枚举的时候能够从两头往中间枚举，增量为

时间复杂度仍然是0(n),不过比直接枚举要快。代码如下：

packagecom.test;

importjava.util.Scanner;

publicclassMainl(

privatestaticInteger[]a=newInteger[500];

privatestaticString[]str;

publicstaticintfind(int1,intr){

if(1>r)

return-1;

if(a[l]==1)

return1;

if(a[r]==r)

returnr;

intleftincrement=Math,abs(a[l]-1);

intright_increment=Math.abs(a[r]-r);

returnfind(1+left_increment,r-right_increment);

}

publicstaticvoidmain(String[]args){

Scannerscanner=newScanner(System,in);

Stringstring=scanner.nextLineO;

str=string,split(，/〃)；

for(inti=0;i<str.length;i++)

a[i]=Integer.parseTnt(str[i]);

intpos=find(0,str.length-1);

if(pos==-1)

System,out.printin("不存在满足a[i]==i的数")；

else

System.out.printing找到满足条件的数:a[“+pos+

"]=="+pos);

)

}

3.数组int[n]a={l,2,3,3,4,3,2……}数组a中的数均为正整数，求满足

a[i]+a[t]=a[x],其中i,t,x均为正数，且小于等于n,求最大a[x].

答：本人水平有限，目前只想到0(rf2*logn)时间复杂度的算法。先将数组排

序,然后从后往前枚举a[x],对于每一个a[x],从0到枚举a[i]的值,

再二分查找a[t]是否存在，代码如下：

packagecom.test;

importjava.util.Scanner;

publicclassMainl(

privatestaticInteger[]a=newInteger[500];

privatestaticString[]str;

publicstaticvoidquicksort(int1,intr){

if(1>=r)

return;

inti=1-1,j=r+1;

intmid=a[(l+r)»1];

whi1e(i<j){

i++;

j—；

while(a[i]<mid)

i++;

while(a[j]>mid)

j—；

if(i<j){

intt=a[i];

a[i]=a[j];

a[j]=t;

)

}

quicksort(1,j);

quicksort(j+1,r);

)

publicstaticbooleanfen_2(intt){

int1=0,r=str.length-1,mid;

while(1<r){

mid=(1+r)>>1;

if(a[mid]==t)

returntrue;

if(a[mid]<t)

1=mid+1;

if(a[mid]>t)

r=mid;

}

returnfalse;

)

publicstaticintfind(){

for(inti=str.length-1;i>=0;i­)

for(intj=0;j<i;J++)

if(fen_2(a[i]-a[j]))

returni;

)

return-1;

)

publicstaticvoidmain(String[]args){

Scannerscanner=newScanner(System,in);

Stringstring=scanner.nextLineO;

str=string,split(*");

for(inti=0;i<str.length;i++)

a[i]=Integer,parselnt(str[i]);

quicksort(0,str.length-1);

intff=findO;

if(ff!=-1)

System,out.printin("最大的a[x]为:"+a[ff]);

else

System.out.prinlln("没有在数组中找到满足条件的数

〃）；

}

）

我的朋友廖宇翔大神说了一个0（广2）的算法，之前我也想到了，不过我误以

为这是一个错误的算法，会出现某些状态没有枚举到的情况，不过在大神的开导

下我豁然开朗。仍然是先迅速排序，从后向前枚举a[x],然后设定两个指针p,q

分别指向a[0]和a[x-1],从两边往中间扫，假如两个指针指向的数相加不小于

a[x],则q指针向左移（若存在a[i]和a[t]满足条件,那么此时i和t必然在

数组下标为0到x-2的区间内）；假如个指针指向的数相加小于a[x],则p指针

向右移（同理）。

代码如下：

packagecom.test;

importjava.util.Scanner;

publicclassMainl（

privatestaticInteger[]a=newInteger[500];

privatestaticString[]str;

publicstaticvoidquicksort(int1,intr){

if(1>=r)

return;

inti=1-1,j=r+1;

intmid=a[(l+r)»1];

whi1e(i<j){

i++;

j—；

while(a[i]<mid)

i++;

while(a[j]>mid)

j—；

if(i<j){

intt=a[i];

a[i]=a[j];

a[j]=t;

)

}

quicksort(1,j);

quicksort(j+1,r);

)

publicstaticintfindO{

for(inti=str.length-1;i>=0;i­){

intp=0,q=i-1;

whi1e(p<=q){

if(a[p]+a[q]>a[i]){

q—；

continue;

)

if(a[p]+a[q]<a[i]){

P++;

continue;

)

returni;

)

return-1;

)

publicstaticvoidmain(String[]args){

Scannerscanner=newScanner(System,in);

Stringstring=scanner.nextLineO;

str=string,split("");

for(inti=0;i<str.length;i++)

a[i]=Integer.parseTnt(str[i]);

quicksort(0,str.length-1);

intff=find();

if(ff!=-1)

System.out.printin("最大的a[x]为："+a[ff]);

else

System,out.printing没有在数组中找到满足条件的数

”)；

)

)

4.用JAVA扫描指定文献夹下面所有以.ixl,.log结尾的文献，并将其绝对途

径输出。

答：重要考查递归遍历文献夹以及获取文献后缀名两部分。

publicstaticvoidrefreshFileList(StringstrPazh)(

Filedir=newFile(scrPath);

File[]files=dir.listFiles();

if(files=null)

return;

for(int1■0;i<files.length;I**)(

if(files[i].isDireccory()){

refreshFileLisE(files[i].getAbsolutePath());

}else(

StringstrFileName-files[i].getAbsolutePath();

intpos-strFileName.lastlndexOf(*.•);

Stringsuffix■strFileName.substring(pos+工)；

if(pos>066pos<strFileName.length()-1)

if(suffix.equals("log**)||suffix.equals(wtxtM))

System,out.prmtln(M"+strFileName);

简明简介一下你所熟悉的设计模式，并给自己假设一个应用场景，并用程序将其

实现，并指出如此设计的优缺陷（单实例模式除外）

答：proxy模式，意图为其他对象提供一个代理以控制对这个对象的访问。优点：

向客户端隐藏了访问某个对象的细节及复杂性；能够动态地调用一个对象中的措

施，且无需实现固定的接口。在AOP编程中，能够利用proxy模式来实现核心代

码和日志代码的分离。程序实现如下：

IntorfacoCoro接口:

packagecom.test.interceptor;

publicinterfaceInterfaceTarget{

publicvoiddocore0;

)

core类:

packagecom.test,interceptor;

publicclassTargetimplementsInterfaceTargetI

publicvoiddocore()(

System.out.printIn(〃核心代码:我目前非常无聊！〃);

)

)

MyLogger类：

packagecom.test,interceptor;

publicclassMyLogger•

publicvoidbefore()(

System,out.printin(“无聊之前记一下”);

)

publicvoidafter(){

System,out.printin("无聊之后又记一下“)