面试姊妹篇3：常用方法中的错误

目的

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

目录

• 1、关于三目运算符
• 2、关于effective final
• 3、关于饥饿死锁
• 4、交换a和b的值
• 5、计时攻击
• 6、哪一个才是我的属性

系列文章

• 面试姊妹篇1：不起眼的Java基础/陷阱题，一看就会，一做就错
• 面试姊妹篇2：有趣的BAT逻辑面试题分享

【1】关于三目运算符

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

public static void main(String[] args) {
   Integer a = 1;
   Integer b = 2;
   Integer c = null;
   Integer d = a > b ? a + b : c;
   System.out.println(d);
}

• 你期待的：

null

• 实际上：

Exception in thread "main" java.lang.NullPointerException
	at DesignPattern.single.dfghj.main(dfghj.java:16)

Process finished with exit code 1

• 原因

  • 报错的第16行是这一句：Integer d = a > b ? a + b : c;
  • 首先我们明确：条件运算符是右结合的，也就是说，从右向左分组计算。例如，a?b:c?d:e将按 a?b:（c?d:e） 执行。
  • 基本类型跟包装类型在做转换的时候，有个自动包装和解包装的过程，会调用.xxxxValue()，比如.booleanValue()，.intValue()，.StringValue()。
  • 三目运算符的“：”左右两边会自动保持一致，那么如果类型不一致，会发生解包装的过程。
  • 如果两边类型不一致，比如题目中的：左边计算出来是int3，而不是Integer3，右边的也会解包装，那么null本身再次吊用.xxxxValue()，会发生NPE。

• 解决办法：保持“：”两边一致，

  • 要么修改 a+b：Integer d = a > b ? Integer.valueOf(a + b) :c;
  • 要么修改 c ：Integer d = a > b ? a + b :null;

• 参考博客：三目运算符的空指针问题

【2】关于effective final

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

public class ljtest{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("thread name:" + Thread.currentThread().getName() + ",i:" + i);
                }
            });
        }
    }
}

• 你期待的：

thread name:Thread-0,i:0
thread name:Thread-1,i:1
thread name:Thread-2,i:2
thread name:Thread-4,i:4
thread name:Thread-6,i:6
thread name:Thread-8,i:8
thread name:Thread-9,i:9
thread name:Thread-3,i:3
thread name:Thread-5,i:5
thread name:Thread-7,i:7

• 实际上：

编译期都过不了，会在输出语句哪一行的 i 哪里显示红线。

• 原因分析
  • 因为内部类在访问外部类成员变量的时候，这个变量不能改变，他必须是稳定的，要么是final，要么是effective final。
  • final的意思是不可更改的，effective final的意思是差不多相当于不可更改的，如果一个变量在使用前，没有出现过多次赋值（两次），那么就默认是形式上的不可变量。
• 解决办法
  • 将变量 i 变成final，或者effective final，例如在for循环下面加上一句：int temp = i;(注意输出语句中的 i 也要改成temp哦)
• 现在将 int temp = i;加上了，结果会是期望那样么？
• 不会，因为线程根本没有启动。
• 解决办法：
  • 办法一：在for循环内，每个线程后面加上 t.start();
  • 办法二：交给线程池来管理，就不需要加上 t.start();

【3】关于饥饿死锁

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

public class ljtest{

    private static ExecutorService executorService = Executors.newSingleThreadExecutor();

    static class t1 implements Callable<String> {

        @Override
        public String call() throws Exception {
            System.out.println("i am t1");
            return "t1===";
        }
    }

    static class t2 implements Callable<String> {

        @Override
        public String call() throws Exception {
            System.out.println("i am t2");
            Future<String> submit = executorService.submit(new t1());
            return "t2===" + submit.get();
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        t2 t = new t2();
        Future<String> submit = executorService.submit(t);
        System.out.println(submit.get());
        System.out.println("la~la~la~");
        executorService.shutdown();
    }
}

• 你期待的：

i am t2
i am t1
t2===t1===
la~la~la~

• 实际上：只有这个

i am t2

• 原因分析
  • 我们用到的线程池是Executors.newSingleThreadExecutor();他是只有一个线程的线程池。
  • 当我们把t2放进去执行的时候，t2又把t1放进去了，这个时候t1在等t2结束，t2在等t1的返回值，出现饥饿等待。

【4】交换a和b的值

• 不使用其他变量的情况下，如何交换a和b的值

常规写法：
public static void main(String[] args) {
    int a = 5;
    int b = 6;
    a = a + b;
    b = a - b;
    a = a - b;
    System.out.println("a:" + a + "b:" + b);
}

异或写法
public static void main(String[] args) {
    int a = 8;
    int b = 8;
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    System.out.println("new--->" + "a:" + a + ",b:" + b);

}

• 针对有博客指出常规写法有内存溢出问题，理论上是有的，但是可能jdk1.8以后做了优化，亲测没有溢出的。
• 针对有博客指出异或写法对两个相同的数异或有bug，但是亲测也没有。
• 异或写法可能相对常规写法，会减少计算的累加次数。

【5】计时攻击

• 写一段判断字符串相等的代码

常规写法
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

• 上面这一段选自JDK的equals方法，大致先判断
  • 是否引用地址一样
  • 是否属于String类型
  • 长度是否一致
  • 挨个对比每个字符是否一样
• 写成这样就可以了，但是不完美，这会引发安全问题，暴露一种叫做计时攻击的漏洞（请自行百度计时攻击）。
• 按照下面这种写法，会牺牲效率，达到防计时攻击。

防计时攻击写法
public boolean equals(String s1, String s2) {
    if (s1 == null || s2 == null) {
        return false;
    }
    if (s1 == s2) {
        return true;
    }
    if (s1.length() != s2.length()) {
        return false;
    }
    int res = 0;
    for (int i = 0; i < s1.length(); i++) {
        res |= s1.charAt(i) ^ s2.charAt(i);
    }
    return res == 0;
}

【6】哪一个才是我的属性

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

public class ljtest {
    public final int value = 4;//5.注释掉本行
    public void dop(){
        int value = 6;//4.注释掉本行
        Runnable r = new Runnable() {
            public final int value = 9;//3.注释掉本行
            @Override
            public void run() {
                int value = 10;//2.注释掉本行
                System.out.println(this.value);//1.去掉this
            }
        };
        r.run();
    }

    public static void main(String[] args) {
        ljtest f = new  ljtest();
        f.dop();
    }
}

• 输出

9

• 看代码的注释部分，考虑下列情形，输出分别是什么？

  • //1.去掉this
  • //2.注释掉本行
  • //3.注释掉本行
  • //4.注释掉本行
  • //5.注释掉本行

• 输出结果

  • 1、输出：10
  • 2、输出：9
  • 3、输出：6
  • 4、输出：4
  • 5、输出：编译报错

• 结论：

  • 分清内部类的属性和值