神代码鉴赏

1:瞒天过海

猜下如下代码会输出啥：

public static void main(String[] args) {
    // \u000d System.out.println("coder Hydra");
}

啥也不输出，不，看结果：

神奇吧！这是因为\u000d就是换行符的unicode编码，Java编译器会将其编译为换行符，如下编译后的结果：

这就很好理解了，如果用这种方式来埋个坑，还真是不太好发现。
这个代码：

public static void main(String[] args) {
    int a=1;
    // \u000d \u0061\u002b\u002b\u003b
    System.out.println(a);
}

运行后是2，因为：

这个待优化代码逼格更高了：

public static void main(String[] args) throws Exception {
    long startTime = System.currentTimeMillis();
    //\u000d\u0054\u0068\u0072\u0065\u0061\u0064\u002e\u0073\u006c\u0065\u0065\u0070\u0028\u0032\u0030\u0030\u0030\u0029\u003b
    System.out.println("waste： " + (System.currentTimeMillis() - startTime));
}

如下：

客户说慢，只有你知道为啥，你这个机灵鬼！！！

2:舍近求远

如果等于0咋的咋的，如果等于1咋的咋的逻辑咋写，这样?：

public void judge(int x){
    if (x>0){
        //...
    }else if (x<0){
        //...
    }
}

NONONO，是这样：

public void judge2(int x){
    if (x>>>31==0){
        //...
    }else if (x>>>31==1){
        //...
    }
}

这个逻辑还是正确的，如下：

扩展一点知识，这个代码运行结果是啥：

public static void main(String[] args) throws Exception {
    int x = 345;
    int what = Integer.MAX_VALUE >> 31 >> 1;
    System.out.println(what);
}

看下：

0

Process finished with exit code 0

0，那这样呢：

public static void main(String[] args) throws Exception {
    int x = 345;
    int what = x >> 32;
    System.out.println(what);
}

是不是也是0，不是的，看结果：

为啥？？？这是因为在执行移位运算前，Java会对操作符右边的操作数执行模32的运算，即上述代码其实是int what = x >> (32%32);就是int what = x >> 0;相当于啥也不做，即限制每次右移4个字节。

3:颠倒黑白

static {
    try {
        // 获取Boolean类中的TRUE变量，即public static final Boolean TRUE = new Boolean(true);
        Field trueField = Boolean.class.getDeclaredField("TRUE");
        // 暴力访问
        trueField.setAccessible(true);

        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        // 去掉final修饰符
        // 因为public static final Boolean TRUE = new Boolean(true);的定义是public static final,而这三个修饰符对应整数值如下：
        /*
        public static final int PUBLIC           = 0x00000001;   ---1
                                                                    +
        public static final int STATIC           = 0x00000008;   ---8
                                                                    +
        public static final int FINAL            = 0x00000010;   ---16
                                                                    共25
        trueField.getModifiers() 因此该值为25，而trueField.getModifiers() & ~Modifier.FINAL相当于是将
        public static final 变为 public static，即public static Boolean TRUE = new Boolean(true);
        此时modifier变为25-16=9
            */
        modifiersField.setInt(trueField, trueField.getModifiers() & ~Modifier.FINAL);
        // final已经去掉了，就可以反射修改其值为false了
        trueField.set(null, false);
    } catch(IllegalAccessException | NoSuchFieldException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) {
    Boolean reality = true;
    if(reality) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
}

以上代码输出啥？看结果：

false

Process finished with exit code 0

奥秘都在静态代码块了，写了详细的注释，自己看下。

4:釜底抽薪

如下直接操作内存代码：

public static void main(String[] args) throws Exception {
    // 获取unsafe
    Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    unsafeField.setAccessible(true);
    Unsafe unsafe =(Unsafe) unsafeField.get(null);

    // 申请4字节 的内存
    long addr = unsafe.allocateMemory(4);
    // 设置值1
    unsafe.putInt(addr,1);
    // 注意这里输出的是随机值，因为分配的四字节内存，可能是任意4个字节，而该四字节因为还没有清除之前存储的数据，所以当前是什么内容是不确定的
    // 你可以试下，每次运行结果都是不一样的
    System.out.println(addr);
    // 转int，并清理 内存之前的脏数据
    int a=unsafe.getInt(addr);
    System.out.println(a);
    // 释放内存
    unsafe.freeMemory(addr);
}

运行:

55516032
1

Process finished with exit code 0

抄的这里的文章 。