Java基础面试题.docx
《Java基础面试题.docx》由会员分享，可在线阅读，更多相关《Java基础面试题.docx（16页珍藏版）》请在冰豆网上搜索。
Java基础面试题
一、JDK与JRE有什么区别？
答：
①JDK：
Java开发工具包，包括Java开发工具和JRE。
②JRE：
Java运行环境，包括运行Java程序所需的核心类库和JVM。
③JVM：
Java虚拟机，保证Java程序的跨平台性。
总结：
由JDK开发的Java程序，交给JRE来运行，并由JVM来保证Java程序的跨平台性。
二、byteb=（byte）130;的运行结果是？
①130的原码：
00000000 000000000000000010000010
②130的反码：
00000000 000000000000000010000010
③130的补码：
00000000 000000000000000010000010
④一个字节截取的补码为10000010
⑤补码10000010的反码为10000001
⑥反码10000001的原码为11111110，计算结果为 -126
三、判断下面代码第三行和第四行编译会出现问题吗？
byteb1=3;
byteb2=4;
byteb3=b1+b2；
byteb4=3+4;
①第三行会出现问题。
如果是变量相加，首先会自动提升数据类型，然后再运算。
②第四行编译运行通过。
如果是常量相加，会直接计算，然后看运算的结果是否在其数据类型所能描述的范围内。
四、判断下列代码的第二行和第三行编译是否能通过？
并说明理由
shorts=5;
s=s+2;//报错，变量s参与运算，会自动提升数据类型至int
s+=2;//编译通过。
s+=2隐含了强制类型转换，相当于s=（short）（s+2）;
五、请用高效的形式写出：
2*8
2<<3
六、如何交换两个变量？
①用第三方变量来做（开发做）
inttemp=a;
a=b;
b=temp;
②用按位异或来做（面试做）
按位异或的特性：
一个数据对另一个数据异或两次，又变回原本的值。
a=a^b;
b=a^b;
a=a^b;
③用算术运算符
a=a+b;
b=a-b;
a=a-b;
七、写出下面程序的运行结果
classFu
{
//静态代码块
static
{
System.out.println（"Fu 静态代码块"）;
}
//构造代码块
{
System.out.println（"Fu 构造代码块"）;
}
publicFu（）
{
System.out.println（"Fu 构造方法"）;
}
}
classZiextendsFu
{
//静态代码块
static
{
System.out.println（"zi 静态代码块"）;
}
//构造代码块
{
System.out.println（"zi 构造代码块"）;
}
publicZi（）
{
System.out.println（"zi 构造方法"）;
}
}
classBlockCodeDemo2
{
publicstaticvoidmain（String[]args）
{
Ziz=newZi（）;
Ziz2=newZi（）;
}
}
如果子父类中都有静态代码块，构造代码块，构造方法，那么执行顺序为？
父类的静态代码块 -->子类的静态代码块-->父类的构造代码块-->父类的构造方法-->子类的构造代码块-->子类的构造方法
注意：
静态代码块只加载一次（.class字节码文件只加载一次的情况下）
Fu 静态代码块
zi 静态代码块
Fu 构造代码块
Fu 构造方法
zi 构造代码块
zi 构造方法
Fu 构造代码块
Fu 构造方法
zi 构造代码块
zi 构造方法
八、方法重载和方法重写有什么区别？
①方法重载：
同一个类中，出现方法名相同、参数列表不同的两个或多个方法时，即构成方法重载。
②方法重写：
子父类间，出现一模一样的方法时，被称为方法的重写，或者复写、覆盖。
也就是要求返回值类型、方法名、参数列表都一致。
day12
九、如何理解字符串一旦初始化就不可以被改变。
Strings="hello";
s+="world";
System.out.println（s）;
解释：
字符串一旦被初始化就不能被改变，说的不可以改变的是hello这个字符串在常量池中的值不可以被改变，而非s这个引用不能改变。
十、s1、s2有区别吗？
Strings1=newString（"abc"）;
Strings2="abc"；
答：
第一种方式：
在内存中存在两个对象，一个在堆内存中，一个在Sting常量池中；
第二种方式：
在内存中只有一个对象，在String常量池中。
十一、length和length（）这两个关键字的区别？
答：
①它们都不是关键字
②length是属性，用来获取数组的长度
③length（）是个方法，用来获取字符串的长度
十二、
1.publicstaticvoidmain（String[]args）
{
Strings="abc";
change（s）;
System.out.println（s）;
}
publicstaticvoidchange（Strings）
{
s+="hello";
}
把”abc”在String常量池的地址值传递进去，change方法里的s对象指向了”abc”，然后和"hello"连接形成新的字符串“abchello”，把新的字符串”abchello”的地址值赋给change方法里的s，但main方法的s还是指向“abc”，因为”abc”是字符串对象，一但初始化就不会被改变。
2.publicstaticvoidmain（String[]args）{
Strings1="a";
Strings2="b";
Strings3="ab";
System.out.println（s3==s1+s2）;
System.out.println（s3=="a"+"b"）;
}
常量相加，直接累加，然后再常量池里找有没有，有结果就是常量池的值。
而变量相加，需要重新在常量池里开辟空间，然后把s1、s2替换为“a” 、“b”，进行连接，形成一个新的 “ab”对象，和s3内容相同，但属于不同的空间即不同的对象。
十三、
Integeri1=newInteger（127）;
Integeri2=newInteger（127）;
System.out.println（i1==i2）;//false
System.out.println（i1.equals（i2））;//true
Integeri3=newInteger（128）;
Integeri4=newInteger（128）;
System.out.println（i3==i4）;//false
System.out.println（i3.equals（i4））;//true
Integeri5=128;
Integeri6=128;
System.out.println（i5==i6）;//false
System.out.println（i5.equals（i6））;//true
Integeri7=127;
Integeri8=127;
System.out.println（i7==i8）;//true
System.out.println（i7.equals（i8））;//true
①通过new出来的是不同的对象，所以比较对象，相当于比较对象的地址值，肯定为false（自动装箱，也相当于自动创建Integer对象）
②一般都会重写Object类中的euqals方法，不再比较地址值，而是比较对象的内容是否相同。
③127始终存在于byte常量池中，创建对象，直接指向127在byte常量池中的地址。
十四、用LinkedList模拟栈数据结构
题意解析：
你有一个LinkedList可以用，需要你自己定义一个栈集合，对外提供添加和获取功能（把LinkedList对象的方法封装在自定义栈方法的内部）
publicclassMyStack{
privateLinkedListlink;
publicMyStack（）{
link=newLinkedList（）;
}
publicvoidadd（Objectobj）{
link.addFirst（obj）;
}
publicObjectget（intindex）{
returnlink.get（index）;
}
publicintsize（）{
returnlink.size（）;
}
}
publicclassLinkedListStack{
publicstaticvoidmain（String[]args）{
MyStackstack=newMyStack（）;
stack.add（"hello"）;
stack.add（"world"）;
stack.add（"java"）;
for（inti=0;i System.out.println（stack.get（i））;
}
}
}
十五、Collection和Collections的区别？
A：
Collection是Collection集合的顶层接口，
它里面定义了Collection集合的共性方法。
B：
Collections是一个类，定义了针对Collection集合操作的各种功能，有排序、二分查找、反转、找最大值、随机置换等。
十六、Map和Collection的区别？
Map：
是双列集合，键必须是唯一的，值可以重复，是键值对形式的集合。
Collection：
是单列集合，它的子接口List可以存储重复元素，
它的另一子接口Set，元素唯一。
十七、统计字符串中每一个字符出现的次数
需求：
"cbxzbvavdvgd"获取字符串中，每一个字母出现次数：
"a
（1）b
（2）c
（1）d
（2）g
（1）v（3）x
（1）z
（1）"
代码如下：
Strings="cbxzbvavdvgd";
//把字符串转成字符数组
char[]chs=s.toCharArray（）;
//创建一个map集合，用出现的字母做键，出现的字母的次数做值，因为键存在自然顺序，所以选TreeMap
TreeMaptm=newTreeMap（）;
//遍历数组中的字符，获取字符键对应的值，如果值为空，则添加该键和值1的键值对，如果值不为空，用原来的值+1替换原来的值
for（charkey:
chs）{
Integervalue=tm.get（key）;
if（value==null）{
tm.put（key,1）;
}else{
tm.put（key,value+1）;
}
}
// 获取字符键的Set集合
SetkeySet=tm.keySet（）;
// 创建一个StringBuilder对象，用来拼接遍历到的字符和出现的次数
StringBuildersb=newStringBuilder（）;
for（Characterkey:
keySet）{
Integeri=tm.get（key）;
sb.append（key）.append（"（"）.append（i）.append（"）"）;
}
Stringstr=sb.toString（）;
System.out.println（str）;
十八、HashMap和Hashtable的区别
A：
HashMap 线程不安全，效率高 ，允许null键和值
B：
Hashtable 线程安全，效率低 ，不允许null键和值
十九、finally的面试题
1、请问final，finally，finalize的区别。
①final 是一个关键字
它修饰的类不能被继承；
它修饰的方法不能被重写；
它修饰的变量，具备了常量的特性。
②finally
它是异常处理的一部分，finally里面的代码永远被执行。
但是有一个特殊情况，程序在finally执行之前就退出了虚拟机。
③finalize
它是Object中的方法，当对象没有引用指向时，该对象的垃圾回收器调用此方法把对象变成垃圾，等待回收。
2:
finally里面的代码真的永远会执行吗?
会永远执行。
但是有一个特殊情况：
在代码执行到finally之前，jvm就退出了。
3:
加入在catch里面有return语句，请问finally里面的代码还会执行吗?
如果执行，是在return前，还是return后?
会执行。
在return之前执行。
但更准确来说，是在return之间执行。
inta=10;
try{
System.out.println（a/0）;
System.out.println（"a1:
"+a）;
}catch（ArithmeticExceptionae）{
System.out.println（"a2:
"+a）;//a2:
10
a=20;
returna;//这个时候，在内存中就会有一个路径产生，该路径返回值是20.
//但是，它看到了finally代码块，所以，继续执行finally里面的内容
//当finally里面结束后，会回到以前的执行路径。
}finally{
System.out.println（"a3:
"+a）;//a3:
20
a=30;
}
returna;
二十、面试题：
写一个死锁程序
publicclassDeadLockextendsThread{
privatestaticObjectobjA=newObject（）;
privatestaticObjectobjB=newObject（）;
privatebooleanflag;
publicDeadLock（booleanflag）{
this.flag=flag;
}
publicvoidrun（）{
if（flag）{
synchronized（objA）{
System.out.println（"true***objA"）;
synchronized（objB）{
System.out.println（"true***objB"）;
}
}
}else{
synchronized（objB）{
System.out.println（"false***objB"）;
synchronized（objA）{
System.out.println（"false***objA"）;
}
}
}
}
}
publicclassDeadLockTest{
publicstaticvoidmain（String[]args）{
DeadLockdl1=newDeadLock（true）;
DeadLockdl2=newDeadLock（false）;
dl1.start（）;
dl2.start（）;
}
}
二十一、线程的生命周期
线程的状态有
新建：
新建一个线程
就绪：
具备执行资格，不具备执行权
可能出现阻塞状态：
不具备执行资格，不具备执行权
运行:
具备执行资格，具备执行权
消亡：
线程对象变成垃圾，等待垃圾回收器回收
新建——*start（）*——就绪——*抢到cpu的执行权*——运行——*run方法结束或者stop（）*——消亡
运行——*其他线程抢到cpu的执行权*——就绪
运行——*sleep（）或wait（）——阻塞——*时间到或notify（）*——就绪
二十二、sleep方法和wait方法的区别？
wait（） ：
Object类中的方法，可以不传参数，它释放锁对象。
sleep（）：
Thread类中的静态方法，必须传递参数，它不释放锁对象。
二十三、我给你ArrayList的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
publicclassArrayListTest{
publicstaticvoidmain（String[]args）throwsException{
// 创建泛型为Integer的ArrayList集合
ArrayListal=newArrayList（）;
al.add（10）;
// 反射越过泛型检查
Classc=al.getClass（）;
Methodm=c.getMethod（"add",Object.class）;
m.invoke（al,"hello"）;
System.out.println（al）;
}
}
二十四、单例设计模式（饿汉式和懒汉式）
饿汉式
publicclassStudent{
// 把构造函数私有化，不让外界创建对象
privateStudent（）{}
// 创建本类对象，并私有化，不让外界直接访问
privatestaticStudents=newStudent（）;
// 对外提供公共的静态访问方式，返回本类对象
publicstaticStudentgetStudent（）{
returns;
}
publicvoidshow（）{
}
}
懒汉式
publicclassTeacher{
// 把构造函数私有化，不让外界创建对象
privateTeacher（）{}
// 定义一个本类对象的引用型变量，并赋值为null
privatestaticTeachert=null;
publicstaticTeachergetInstance（）{
if（t==null）{
synchronized（Teacher.class）{
if（t==null）{
t=newTeacher（）;
}
}
}
returnt;
}
}
升级会员 