目的
- 专门收集一些看上去很有意思的题目
- 这些题目，一看就会，一做就错
- 持续更新，每十题作为一篇文章
目录
- 1、关于自增
- 2、关于list删除元素
- 3、关于运算：0.1+0.2等于几 ？float 0.7与double 0.7谁更大？
- 4、如何获取 Integer.MAX_VALUE值的 3/4
- 5、关于继承和多态
- 6、关于String 的 equals
- 7、String类型的长度限制是多少
- 8、Java是引用传递还是值传递
- 9、单例模式在什么情况下会失效?如何避免这种情况?
- 10、线程数设置为多少合适?
系列文章
- 面试姊妹篇2：有趣的BAT逻辑面试题分享
- 面试姊妹篇3：常用方法中的错误
【1】关于自增
public static void main(String[] args) {
int j = 0;
int i = 0;
int m = 0;
int n = 0;
for (; i < 10; i++) {
m = j++;
n = n++;
}
System.out.println("i:" + i);
System.out.println("j:" + j);
System.out.println("n:" + n);
System.out.println("m:" + m);
}
i:0
j:10
n:9
m:9
i:10
j:10
n:0
m:9
- 原因
- i 一般是眼误，以为只存在于循环内，实际上它是定义在循环外的，所以值会一直被保存下来。
- j 没什么好说的。
- j++是先赋值，再加加，所以 m 比 j 慢一拍。
- 同样的道理，n每次赋值给自己都是原始值，它的加加也就显得没有意义。
- = i++ 这一过程的伪代码类似于
public void ipp(){
int i_temp = i;
i+1;
return i_temp;
}
【2】关于list删除元素
public static void main(String[] args) {
List<Integer> list = new ArrayList();
list.add(1);
list.add(3);
list.add(4);
list.add(7);
list.add(8);
list.add(9);
list.add(2);
list.add(5);
list.add(6);
for (int i = 0; i < 9; i++) {
if ((list.get(i) & 1) == 1) {
list.remove(i);
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
Exception in thread "main" ----------------
java.lang.IndexOutOfBoundsException: Index: 6, Size: 5
at java.util.ArrayList.rangeCheck(ArrayList.java:657)
at java.util.ArrayList.get(ArrayList.java:433)
at HttpServer.wwvae.main(wwvae.java:27)
- 原因
- 移除元素后，list大小不再是9，因此 i 的增加会导致空指针异常。
- 那么修改 9 为 list.size() ，是否正常输出所有的偶数
for (int i = 0; i < list.size(); i++) {
if ((list.get(i) & 1) == 1) {
list.remove(i);
}
}
3
4
8
2
6
- 原因
- 还是因为移除元素后，原来的 i+1 变成了 i，躲过了检查，所以漏删。
- 修改办法
办法一：加上i--;
for (int i = 0; i < list.size(); i++) {
if ((list.get(i) & 1) == 1) {
list.remove(i);
i--;
}
}
for (int i : list) {
if ((i & 1) == 1) {
list.remove(i);
}
}
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at HttpServer.wwvae.main(wwvae.java:32)
- 错误原因
- 因为元素在使用的时候发生了并发的修改，导致异常抛出。如果删除完毕马上使用break跳出，则不会触发报错，但是只能删除第一个符合条件的偶数。
- 建议的写法
办法二：使用迭代器
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()){
if ((iterator.next() & 1) == 1) {
iterator.remove();
}
}
- 参考博客：ArrayList循环删除元素的方法总结
【3】0.1+0.2等于几？float 0.7与double 0.7谁更大？
double a = 0.1;
double b = 0.2;
System.out.println(a+b);
0.30000000000000004
float a = 0.7f, a1 = 2.7f;
double b = 0.7, b1 = 2.7;
if (b > a) {
System.out.println("double 0.7 > float 0.7");
} else {
System.out.println("double 0.7 < float 0.7");
}
if (b1 > a1) {
System.out.println("double 2.7 > float 2.7");
} else {
System.out.println("double 2.7 < float 2.7");
}
double 0.7 > float 0.7
double 2.7 < float 2.7
- 原因分析：
- 这跟我们大学学的十进制转换二进制有关，一定存在某些数，不是完全匹配的，就像1/3表示成小数，是无限循环，而我们存储是有限的，会发生截取，因此就不完全想等了，具体细节分析见我的另一篇博客：float类型与double类型数谁更大？
- 建议
- 如果像银行业等对精度要求比较高的行业，建议使用BigInteger和BigDecimal，它两分别表示大整数类和大浮点数类
- 但是BigDecimal的构造函数选取不当，也会造成精度缺失，具体见这篇博客：BigDecimal一定不会丢失精度吗
- 精度不缺失的原理是使用字符串相加相乘，具体见我的另外一篇博客：大整数乘法其实很简单（Java）
【4】如何获取 Integer.MAX_VALUE值的 3/4
int max = Integer.MAX_VALUE;
System.out.println("max:" + max);
int result = max * 3 / 4;
int result1 = max / 4 * 3;
System.out.println("max * 3 / 4:" + result);
System.out.println("max / 4 * 3:" + result1);
max:2147483647
max * 3 / 4:536870911
max / 4 * 3:1610612733
- 很明显，根据数学尝试我们知道，第一个运算结果是假的，为什么呢？因为 int 类型发送溢出了。
- 如何修改：为了防止溢出，需要进行先除后乘。
- 第二个答案就正确么？也不正确，正确答案是：1610612735.25，因为 int 是整数，所以进行了截取，这里跟第四问一样有趣，改写成double就行了（float依然有精度缺失）。
max:2.147483647E9
max * 3 / 4:1.61061273525E9
max / 4 * 3:1.61061273525E9
【5】关于继承和多态
class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
class B extends A {
public String show(B obj) {
return ("B and B");
}
@Override
public String show(A obj) {
return ("B and A");
}
}
class C extends B {}
class D extends B {}
class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b));
System.out.println("5--" + a2.show(c));
System.out.println("6--" + a2.show(d));
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c));
System.out.println("9--" + b.show(d));
}
}
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D
- 原因分析：
- 做对这道题，需要你对父类引用子类对象的具体实现有很深的理解，需要理解那些方法会被覆盖，那些会被重写。
- 这道题的具体原因分析见：面向对象编程封装、继承、多态
【6】关于String 的 equals
public static void main(String[] args) {
String st1 = "abc";
String st2 = "abc";
System.out.println("1-1:" + st1 == st2);
System.out.println("1-2:" + st1.equals(st2));
String st3 = new String("abc");
System.out.println("2-1:" + st1 == st3);
System.out.println("2-2:" + st1.equals(st3));
String st4 = "a" + "b" + "c";
System.out.println("3-1:" + st1 == st4);
System.out.println("3-2:" + st1.equals(st4));
String st5 = "ab";
String st6 = st1 + "c";
System.out.println("4-1:" + st1 == st6);
System.out.println("4-2:" + st1.equals(st6));
}
1-1:true
1-2:true
2-1:false
2-2:true
3-1:true
3-2:true
4-1:false
4-2:true
false
1-2:true
false
2-2:true
false
3-2:true
false
4-2:false
- 原因分析：
- 首先你应该注意到格式问题了，格式是由“== ” 引起的，如果你希望输出期望的那样，那么你应该给 “==” 加上()，比如这样：System.out.println(“3-1:” + (st1 == st4));这里有一个运算优先级的关系在这里，不知道你发现没有。
- 在具体分析前，明确这一点：”==“对比的是内存地址，equals是按照既定的格式/规则/算法来匹配的，比如说一般的string.equals方法都是对比两个字符串是否逐位相等，想等输出true，所有毫无疑问，x-2都输出true。
- 2-1之所以这样是因为new String(“abc”);出来的是一个全新的对象，内存地址肯定不一样。
- 3-1之所以这样是因为Java中有常量优化机制，+符号拼接之后常量池立马会创建一个“abc”的字符串常量对象，在进行st2=”abc”,这个时候，常量池存在“abc”，所以不再创建。
- 4-1之所以这样是因为引用和字符串的加和，是由StringBuilder或者StringBuffer类以及里面的append方法实现拼接的，最后给出的地址，肯定不会再次引用常量池中的值，所以地址也不同。
【7】String类型的长度限制是多少
String s = "aa...aaa";
错误：常量字符串过长
- 接下来我们研究：String类型的长度限制是多少？
- 根据错误提示，我们去常量池中找答案。在常量池中，对java.lang.String类型的常量对象，定义了如下格式：
CONSTANT_String_info {
u1 tag;
u2 string_index;
}
CONSTANT_Utf8_info {
u1 tag;
u2 length;
u3 bytes[length];
}
- 是不是65535长度的String就可以编译通过？
String s = "aa...aaa";
错误：常量字符串过长
- 原因
- 在javac的代码中是可以找到的Gen类中有如下代码：
private void checkStringConstant(DiagnosticPosition var1, Object var2) {
if (this.nerrs == 0 && var2 != null && var2 instanceof String
&& ((String)var2).length() >= 65535) {
this.log.error(var1, "limit.string", new Object[0]);
++this.nerrs;
}
}
- 实验定义长度为65534个字符的字符串，会发现可以正常编译
- 说完编译期，再说说运行期长度（运行时是允许拼接编译期的字符串的）
- String的很多重载方法中可以看到，length是等于int的，根据Integer类的定义，java.lang.Integer#MAX_VALUE的最大值是2^31 - 1
public String(byte bytes[], int offset, int length)
- 结论
- 在编译期，要求字符串常量池中的常量不能超过65535
- 在javac执行过程中控制了最大值为65534。
- 在运行期，长度不能超过Int的范围，否则会抛异常。
- 参考博客：面试官竟然问我Java中的String有没有长度限制！？
【8】Java是引用传递还是值传递
public class fvybhj {
public static void main(String[] args) {
int n = 3;
System.out.println("Before change, n = " + n);
changeData(n);
System.out.println("After changeData(n), n = " + n);
}
public static void changeData(int nn) {
nn = 10;
}
}
Before change, n = 3
After changeData(n), n = 3
public class fvybhj {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Hello ");
System.out.println("Before change, sb = " + sb);
changeData(sb);
System.out.println("After changeData(n), sb = " + sb);
}
public static void changeData(StringBuffer strBuf) {
strBuf.append("World!");
}
}
Before change, sb = Hello
After changeData(n), sb = Hello World!
- 结论：
- 一定要明确：Java是值传递，你改了指针或者说引用是没有用的。
- 本题的具体细节请看参考博客：java参数传递（超经典）
【9】单例模式在什么情况下会失效?如何避免这种情况?
- 首先认识一下什么是单例模式？
- 推荐阅读我这篇博文：十大常见设计模式，一次性让你面试通过，此处就不再赘述了。
- 那么单例模式在什么情况下会失效呢？
1、通过反射，重新获取类的私有构造函数，来创建对象
2、在反序列化的时候，重新获取该类的实例对象
- 对于反射方式破坏单例，可以在单例模式的构造函数内加入以下语句来杜绝反射：
private DCLSingletom() {
if(dclSingletom != null){
throw new RuntimeException("eeeeee");
}
}
- 对于序列化破坏单例，因为反序列化过程中，在反序列化执行过程中会执行到ObjectInputStream#readOrdinaryObject方法，这个方法会判断对象是否包含readResolve方法，如果包含的话会直接调用这个方法获得对象实例，因此重写readResolve方法可以保证单例。
private Object readResolve(){
return dclSingletom;
}
singleton : DesignPattern.single.DCLSingletom@2b193f2d
singletonBySerialize : DesignPattern.single.DCLSingletom@2b193f2d
singleton == singletonBySerialize : true
- 注意：序列化的时候，实现类一定要implements Serializable。
- 参考博客：关于"如何破坏单例"我说了好几种方式
【10】线程数设置为多少合适?
