几道小小的题目一起和大家更进一步地了解Java （Ⅲ）

Question

这是小题目的系列之三之一：http://topic.csdn.net/u/20070828/10/7aa61fbc-8575-4212-85c4-582c08f81535.html
之二：http://topic.csdn.net/u/20070917/10/928cdd3b-0ec6-4236-a89d-7c3ddba8eaba.html考虑到前两期的题目可能太难了，这次把难度降低了，以最简单的代码量来说明。做题规则：老规矩，不允许上机操作，全部完成后可以将代码复制自行检测一下，需采用JDK1.5及以上版本1，被遗忘掉的运算符如果问大家“&”、“|”、“^”这三个是什么运算符？基会本上都会回答“位运算符”，但这样的回答只能得50分。大多数的Java程序员很可能不知道它还能充当其他的运算符——布尔逻辑运算符（前提是两边的数据类型为布尔类型）。在布尔逻辑运算符中这三个运算符充当着“布尔逻辑与”、“布尔逻辑或”和“布尔逻辑异或”的角色。前面两个把它们再复制一个放在一起就成了逻辑运算符。布尔逻辑与（&）和布尔逻辑或（|）运算符的工作方式同逻辑与（&&）和逻辑或（||）的工作方式相同，布尔逻辑运算符的优先级别要高于逻辑运算符，除此之外它们还有一点细微的差别，看一看下面的程序将会输出什么，就会明白了。最后一个布尔逻辑异或（^）用得就更少了，可以采用关系运算符不等于（!=）来代替，在此就不深究了。布尔逻辑运算符与逻辑运算符还有个区别，就是布尔逻辑运算符可以与赋值运算符（=）结合成布尔逻辑赋值运算符（&=、|=、^=），而逻辑运算符就没有这样的功能，可能它本身就有两个了吧，再结合“=”的话就变三个了，呵呵，太多了 ：）public class Test1 {
    public static void main(String[] args) {
        int m = 5, n = 5;
        if((m != 5) && (n++ == 5)){}
        System.out.println("a." + n);
        
        m = n = 5;
        if((m != 5) & (n++ == 6)){}
        System.out.println("b." + n);
        
        m = n = 5;
        if((m == 5) || (n++ == 5)){}
        System.out.println("c." + n);
        
        m = n = 5;
        if((m == 5) | (n++ == 6)){}
        System.out.println("d." + n);
    }
}＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝2，自动装箱的疑惑JDK1.5中增加了自动拆装箱的语言特性，在基本类型和包装类型之间可以相互地转换和运算。大家也都知道Java中==运算符是比较两个对象间的引用是否相同。在自动拆装箱与“==”运算符之间也会产生一些奇怪的事情，看看下面的程序将会输出什么？public class Test2 {
    public static void main(String[] args) {
        int k = 100;
        Integer int1 = k;
        Integer int2 = k;
        System.out.println("a." + (int1 == int2));
        k = 200;
        Integer int3 = k;
        Integer int4 = k;
        System.out.println("b." + (int3 == int4));        char c = 'A';
        Character char1 = c;
        Character char2 = c;
        System.out.println("c." + (char1 == char2));
        c = '国';
        Character char3 = c;
        Character char4 = c;
        System.out.println("d." + (char3 == char4));
    }
}＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝3，奇怪的\u与0x\u是Unicode字符的前缀，而0x是十六进制数值的前缀，能通用吗？下面的程序是否能如愿以偿地将Hello与World!分成两行输出呢？public class Test3 {
    public static void main(String[] args) {
        // 提示 \u000A 表示换行（LF），而 0x000A 表示什么呢？
         char c = 0x000A;
        System.out.println("Hello" + c + "World!");
    }
}＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝4，不可能发生的事情来个简单点的填空题哈，在空格处填上适当的数，让下面的程序能输出“Hello World!”。public class Test4 {
    public static void main(String[] args) {
        int num = _____________;
        if(num < 0 && num == Math.abs(num)) {
            System.out.println("Hello World!");
        }
    }
}＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝5，模棱两可的方法重载invoke有两个重载的方法，一个是Object作为参数，另一个是int[]作为参数，看看下面的程序会输出什么？public class Test5 {
    public static void main(String[] args) {        
        invoke(null);
    }
    private static void invoke(Object obj) {
        System.out.println("Object");
    }
    private static void invoke(int[] nums) {
        System.out.println("Arrays");
    }
}＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝6，Number引起的计算错误Number是众多数值类型的抽象父类，难道用它会引发计算错误？！看看下面的程序会输出什么？public class Test6 {
    public static void main(String[] args) {
        Number num = 12345 + 5432l;
        System.out.println(num.intValue());
    }
}以上题目参考或改编自：
[1] H.M.Deitel, P.J.Deitel，Java程序设计教程，清华大学出版社，2004
[2] D.Flanagan, Java in a Nutshell, 5th ed., O'Reilly Media, 2005
[3] B.McLaughlin, D.Flanagan, Java 5.0 Tiger程序高手秘笈，东南大学出版社，2005
[4] Sun Microsystems, The Java Language Specification, 3rd ed., Addison-Wesley, 2005
[5] Joshua Bloch, Neal Gafter, Java解惑，人民邮电出版社，2006
[6] Joshua Bloch, Effective Java中文版，机械工业出版社，2003

Answer 1

public class Test6 {
    public static void main(String[] args) {
        Number num = 12345 + 5432l;
        System.out.println(num.intValue());
    }
}
12345
 5432
------
17777 啊！这个有问题吗？

Answer 2

前5题以前见到过，pass，第6题想不通。

┌┼──┼┐┌──┬─┐　┌┐──┬　　　┐　　　┐┌　┌　　┌┐──┬┌╭─　　　╭　　　┐　╭────╯
┌──╯─┐　　　│　　┌├┐┌┐│└──┼─┘┌┼├─┼┐┌├┐┌┐│┌┼───┐│　　　│　╭────┐
│┬──┐│　　　│　　││││││　　　│　　　││　││││││││　│　─╮││┌──┼┐│　　　　　
││　　││└──┼─┘││││││　　　│　　　││　││││││││　│　　┘│╯　　　│　│　　　┌╮
││└─┘│　　　│　　│├╯│││　　　│─╮　││　│╯│├╯│││　│　╭　││　　　│　│　　　　│
└└──╯╯└──╯─┘╰╰　╰┘┘└──╯　┘╰┴╰──┘╰╰　╰┘┘└╯　└─┘└╯　　╯　└────┘

Answer 3

第6题执行结果：17777。和预期的一样。JDK版本：java version 1.5.0_03-b07比较想知道第4题要填什么呢?

Answer 4

哈哈，刚次查了第4题了，原来是添Integer.MIN_VALUE;以前还真不知道

Answer 5

第四题答案被我猜到了
Integer.MIN_VALUE

Answer 6

应为数字的范围是
2^n -1  到 -2^n所以 MIN_VALUE 没有对应的正数，呵呵呵！

Answer 7

变态 学习了 感觉做这种题目比看thinking in java 爽

Answer 8

第四题只要是超出int表示范围的最小值都行
MIN_VALUE的二进制值取反加一都是本身

Answer 9

1，&、|逻辑运算与&&、||这几个逻辑运算还是有点区别的（^和~基本没区别）：
前者是非短路运算，后者是短路运算；

Answer 10

第六题研究了半个小时Google了半个小时，现在打死楼主的心都有。
很黄很暴力

Answer 11

哦，明白了，超过128的int类型装为2个对象，中文unicode编码也是2个对象。这么理解没有错吧？

Answer 12

第六题好淫荡啊！我自己输入12345+54321就“没错”，用他的拷贝就有问题了！最后改了类型，说不能从long转换为int。才发现后面不是1 是 l  ！！！！当时真想看看Number的原代码来着！
楼主不厚道啊，用障眼法！

Answer 13

那个1和l的障眼法在Java Puzzler一书中也有提到 还有许多有趣的小谜题

Answer 14

第六题好淫荡啊！我自己输入12345+54321就“没错”，用他的拷贝就有问题了！最后改了类型，说不能从long转换为int。才发现后面不是1   是   l     ！！！！当时真想看看Number的原代码来着！ 
楼主不厚道啊，用障眼法！

Answer 15

Java codepublic class Test6 {
    public static void main(String[] args) {
        Number num = 12345 + 5432l;
        System.out.println(num.intValue());
    }
}
12345 
  5432 
------ 
17777   啊！这个有问题吗？

Answer 16

第2题，Integer.MIN_VALUE是正确答案。原因在于绝对值的计算方式：
Integer.MIN_VALUE二进制位中最高位（符号位）为“1”，其余的位均为“0”，Math.abs的运算是
先看看参数的值是否是小于零的，若是小于零的，在前面加个负号（-），加负号的运算也就相当于，把
整个二进制位取反再加1，Integer.MIN_VALUE，取反后最高位为“0”了，其余都为“1”了，再加“1”
之后，嘿嘿...第2题：Fixed, Closed第6题，属于娱乐性质的题目，可别被标题给迷惑喔。
这道题的给我的教训是：long型数值后缀不要采用小写字母“l”，而应采用大写字母“L”。第6题：Fixed, Closed

Answer 17

2，自动装箱的疑惑
==============
外覆类有缓存 
比如Integer -128到127
Character 0到127
String 也有intern可以返回缓存中的对象 
当然new出来 是不会到缓存中去读
4，不可能发生的事情
==================
abs
public static int abs(int a)返回 int 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。 
注意，如果参数等于 Integer.MIN_VALUE 的值（即能够表示的最小负 int 值），那么结果与该值相同且为负。 
参数：
a - 要确定绝对值的参数。 
返回：
参数的绝对值。
另请参见：
Integer.MIN_VALUE文档上都写的很清楚
5，模棱两可的方法重载
=======================
这个涉及到方法参数隐式转换的问题
例如下面这个最简单的转型列子
byte b = 1;
method(b)
void method(short s);
void method(int i);
这种细节问题  那些做SSH  自称J2EE的人是不会了解的

Answer 18

对于自动装箱的疑惑 
想了下还是不是很懂
int k = 100;
Integer int1 = k;
Integer int2 = k;
执行的应该是Integer int1 = Integer.value(k);
这个方法在jdk的帮助中说是
"如果不需要新的 Double 实例，则通常应该优先采用此方法，而不是使用构造方法 Double(double)，因为该方法很可能通过缓存经常请求的值来显著提高空间和时间性能。"
那么也就是说第二个int2没有产生新的对象
那为什么k的值变后同样的就不行了呢?
继续研究中......

Answer 19

第3题 char c = 0x000A;//10 回车
char c = 0x000D;//13 换行

Answer 20

5，模棱两可的方法重载
======================= 
Java的重载解析过程是以两阶段运行的。第一阶段选取所有可获得并且可应用的方法或构造器。第二阶段在第一阶段选取的方法或构造器中选取最精确的一个。如果一个方法或构造器可以接受传递给另一个方法或构造器的任何参数，那么我们就说第一个方法比第二个方法缺乏精确性[JLS 15.12.2.5]。 参数为Object的构造器可以接收所有int[] nums的参数,所以它不够精确.所以调用的是int[] nums为参数的构造器

Answer 21

6题  最后字母是小写的“L”
这是java从c继承来的，直接将数据类型转为long型
这题的目的是提醒大家书写的规范性，避免使用小写的“L”

Answer 22

2，自动装箱的疑惑 
=================
看了下jdk的源码终于明白了
Integer.valueOf()这个方法对于大小为byte的数字做了优化.
valueOf()方法原源码:
public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];
}
        return new Integer(i);
}如果是byte大小的它是从缓存中取一个,就从IntegerCache初始化的256个Integer缓存中取.
这样就只有一个对像,用==当然就是true了.第二个k=200超过了这个范围,就是new Integer(i)了

Answer 23

20楼：daniel_kaka 1，&、|逻辑运算与&&、||这几个逻辑运算还是有点区别的（^和~基本没区别）：
前者是非短路运算，后者是短路运算；
________________________________________Very good！不过逻辑运算符中没有“~”这个的。编译器对于&&和||已经优化过的，凡&&前面的是false，那&&后面的表达式就不用了。
||前面的是true，||后面的也就不做了，这就是所谓的“短路”。而布尔逻辑运算符就没有这个特点，无论运算符前面的是true或false，运算符后面的
表达式都得继续进行运算。第1题：fixed, closed

Answer 24

int   k   =   100; 
Integer   int1   =   k; 
Integer   int2   =   k; 
关于这个 真的没有明白 为什么 前后会不一样  为什么 第一次int1，int2的id值是一样的第二次的时候int3，int4就不一样了呢。  安照常理 应该是一样的呀

Answer 25

to xiazhigen:
100在-127到128之间,它是从IntegerCache初始化的256个Integer缓存中取的.这样
int1和int2是指向同一个对象当k=200时不在这个范围,它就是执行的new Integer()当然就是两个对象,就不等了

Answer 26

public class Test1 {
    public static void main(String[] args) {
        int m = 5, n = 5;
        if((m != 5) && (n++ == 5)){}
        System.out.println("a." + n);
        
        m = n = 5;
        if((m != 5) & (n++ == 6)){}
        System.out.println("b." + n);
        
        m = n = 5;
        if((m == 5) || (n++ == 5)){}
        System.out.println("c." + n);
        
        m = n = 5;
        if((m == 5) | (n++ == 6)){}
        System.out.println("d." + n);
    }
}
觉得楼主看法不对啊，((m != 5) & (n++ == 6)这里中间仍然是位运算啊只是m != 5是1或则是0， n++ == 6结果也是1或则是0
这样取位与和逻辑与结果是一样的，所以并不是楼主上面所说的那样，这三个运算符在这里是逻辑运算。

Answer 27

楼上的不对，m != 5得出的值只会是true或者false，在Java中不会等于0或者是1的。

Answer 28

第三提0x000A是“\n”，因为“\n”的ascii是10，所以输出的时候就是有换行了

Answer 29

哈哈，先来解决第2题。引用《Java 5.0 Tiger程序高手秘笈》中的一句段话，就可以说明了。Java语言规范指出：特定的基本类型一定得被装箱成包装对象。这些对象会被高速缓存以重复使用，并且会被当作一般使用的对象。这些特殊的值是：boolean： true、false
byte： 所有的值
short、int和long： -128～127
char： \u0000～\u007F
float和double：不会被缓存我找了一下 Java Language Specification 中的相关章节（5.1.7）：
http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#5.1.7原文如下：If the value p being boxed is true, false, a byte, a char in the range 
\u0000 to \u007f, or an int or short number between -128 and 127, then
let r1 and r2 be the results of any two boxing conversions of p. It is
always the case that r1 == r2.Java Language Specification，是Java语言的“圣经”，没事不妨看看. PDF下载链接：
http://java.sun.com/docs/books/jls/download/langspec-3.0.pdf第2题：fixed, closed

Answer 30

第2题，感谢52楼：yuanyuan110_l 的源代码分析。

Answer 31

54楼:bao110908 火龙果Very   good！不过逻辑运算符中没有“~”这个的。 编译器对于&&和 ¦ ¦已经优化过的，凡&&前面的是false，那&&后面的表达式就不用了。 
¦ ¦前面的是true， ¦ ¦后面的也就不做了，这就是所谓的“短路”。 而布尔逻辑运算符就没有这个特点，无论运算符前面的是true或false，运算符后面的 
表达式都得继续进行运算。 第1题：fixed,   closed====================================================================================你这种说法不正确，逻辑运算符中没有“~”这个，但是它是按位运算符.!、~、^三个运算符号都存在的~
!是逻辑取反；
!(4>5)
~是按位取反
~2
^是按位异或
2^5

Answer 32

第二题其实 Core Java 2 vol1中有说明。o(∩_∩)o...

Answer 33

感谢LZ所搜集的内容:我整理答案如下
运行前答案 运行后答案
test1  
a.5 a.5
b.6 b.6
c.6 c.5
d.6 d.6
test2
a.true a.true
b.true b.false
c.true c.true
d.true d.false
test3
Hello 
Word
test4  
 -0
test5
Object Arrays    
test6
17777   

Answer 34

to: 72楼 daniel_kaka嘿嘿，你错误地理解我的意思了。~仅可以充当位运算符，而 & | ^ 三个不仅可以充当位运算符，还可以充当布尔逻辑运算符的。

Answer 35

第四题:
如果参数等于 Integer.MIN_VALUE 的值（即能够表示的最小负 int 值），则结果与该值相同且为负public class Test4 {
    public static void main(String[] args) {
        int num = -2147483648;
        if(num < 0 && num == Math.abs(num)) {
            System.out.println("Hello World!");
        }else System.out.println("The answer is wrong");
    }
}

Answer 36

呵呵，如果看过Java解惑这些书的话，就会知道了，这些都不是问题

Answer 37

第三题的(0x000A)是什么东西
我试了试~是这样输出的:
Hello
World

Answer 38

去百度一下Integer.MIN_VALUE