面试姊妹篇1:不起眼的Java基础/陷阱题,一看就会,一做就错

目的

  • 专门收集一些看上去很有意思的题目
  • 这些题目,一看就会,一做就错
  • 持续更新,每十题作为一篇文章

目录

系列文章

【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();
       }
}

【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";//十万个a
  • 编译结果(注意是编译不是运行)
错误:常量字符串过长
  • 接下来我们研究:String类型的长度限制是多少?
    • 根据错误提示,我们去常量池中找答案。在常量池中,对java.lang.String类型的常量对象,定义了如下格式:
CONSTANT_String_info {
    
    
  u1  tag;
  u2  string_index;//必须是对常量池的有效索引,必须是CONSTANT_Utf8_info结构
}
  • CONSTANT_Utf8_info结构
CONSTANT_Utf8_info {
    
    
  u1  tag;
  u2  length;//指明byte数组长度,u2表示2个字节无符号数,即16位:2^16-1=65535
  u3  bytes[length];
}
  • 是不是65535长度的String就可以编译通过?
String s = "aa...aaa";//65535个a
  • 编译结果(注意是编译不是运行)
错误:常量字符串过长
  • 原因
    • 在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) 

【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

【10】线程数设置为多少合适?

  • 题目:线程数设置为多少合适
  • 理论上,单核CPU一直工作的话,只能处理一个线程。如果该线程一半时间在处理数据,一半时间在等IO,那么这个单核CPU可以处理两个线程。
  • 因此类推出:
    • 确定机器是几核的:n核
    • 确定该线程的工作状态:有1/k的时间在处理计算,需要CPU
    • 结论:该机器线程数设置的合适数量是:(n*k)个线程

猜你喜欢

转载自blog.csdn.net/ljfirst/article/details/106082534