面试姊妹篇1：不起眼的Java陷阱题，一看就会，一做就错

最新推荐文章于 2023-10-10 10:13:17 发布

New俊

最新推荐文章于 2023-10-10 10:13:17 发布

阅读量856

点赞数 1

分类专栏：面试姐妹篇文章标签： java 编程语言面试

本文链接：https://blog.csdn.net/ljfirst/article/details/106082534

版权

面试姐妹篇专栏收录该内容

5 篇文章 0 订阅

订阅专栏

系列文章

$\color{7f1A8A}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;//返回的是原始值
 }

$\color{7f1A8A}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);
     }
}

输出结果

原因
- 还是因为移除元素后，原来的 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循环删除元素的方法总结

$\color{7f1A8A}3、还是关于自增$

下面的运行结果应该输出什么？

	static int i;

    public static void main(String[] args) {
        int n = 0;
        for (int i = 0; i < 4; i++) {
            n += cal(i);
        }
        System.out.println(n);
    }

    public static int cal(int k) {
        int j = 0;
        return ++i + k + j++;
    }

实际运行结果

原因分析
- j++每次都是0
- i 是全局变量，每次增加1
- k是根据每次传入的值计算
- 循环四次每次：
  - 1+0+0
  - 2+1+0
  - 3+2+0
  - 4+3+0
  - 合计：16

$\color{7f1A8A}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

$\color{7f1A8A}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方法实现拼接的，最后给出的地址，肯定不会再次引用常量池中的值，所以地址也不同。

$\color{7f1A8A}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)

结论
- 在编译期，要求字符串常量池中的常量不能超过65535
- 在javac执行过程中控制了最大值为65534。
- 在运行期，长度不能超过Int的范围，否则会抛异常。
参考博客：面试官竟然问我Java中的String有没有长度限制！？

$\color{7f1A8A}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参数传递（超经典）

$\color{7f1A8A}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。
参考博客：关于"如何破坏单例"我说了好几种方式

New俊

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
面试姊妹篇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:
复制链接

扫一扫