有趣的Java题目!!!

Question

这是以前别人发的帖子，我整理了一下，都是一些很有趣的题目。

Answer 1

嗯！LZ收集的不错，有些题目我以前也做过，温故而知新...谢谢LZ分享

Answer 2

//我做最后一题
import java.text.SimpleDateFormat;public class Part {
public static void main(String[] args) {
System.out.println(formatTime(System.currentTimeMillis()));
} private static char[] formatTime(long currentTimeMillis) {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(
currentTimeMillis).toCharArray();
}
}

Answer 3

第一篇：
1、
a. 5
b. 6
c. 5
d. 6
理由：&、|与&&、||的区别在于短路的行为
2、
a. true
b. false
c. true
d. false
理由：应该是考察小范围内的缓存池
3、不知道
4、Integer.MIN_VALUE
理由：猜测+查文档
5、不知道
6、不知道第二篇：
1、
Parrent
Parrent
理由：static方法不具有多态行为，另外，遵从原文的拼写错误: )
2、
Java   Puzzlers 
理由：不知道想要考查什么
3、
String i = "anything you like";
4、
0
理由：add不是在原对象上操作，而是返回一个新的对象
5、不知道第三篇：
1、不知道
2、
0
3、不知道，这个优先级得查文档
4、编译错，for语句少了最后一个语句
5、太复杂，懒得想
6、new Date(currentTimeMillis).toString().toCharArray();

Answer 4

第二篇的第二个，为什么必须加{}将 Integer k   =   new   Integer(i);
括起来，否则报错，不知道为什么 for(int   i   =   0;   i   <=   10;   i++)
                Integer k   =   new   Integer(i);
            System.out.println( "Java   Puzzlers ");

Answer 5

喜欢的看看 java解惑就是了。。 全是里面的

Answer 6

public   class   Test   {
        public static void main(String[] args) {
            for(int   i   =   0;   i   <=   10;   i++){
                Integer k   =   new   Integer(i);}
            System.out.println( "Java   Puzzlers ");
    　　　　}
    　　}
//此题考察什么的

Answer 7

不好意思，这个题打错了，，，
因该是：
public   class   Test   {
        public static void main(String[] args) {
            for(int   i   =   0;   i   <=   10;   i++)
                Integer k   =   new   Integer(i);
            System.out.println( "Java   Puzzlers ");
    　　　　}
    　　}

Answer 8

2、
Java Puzzlers 
理由：不知道想要考查什么这里打错了，因该是
public   class   Test   {
        public static void main(String[] args) {
            for(int   i   =   0;   i   <=   10;   i++)
                Integer k   =   new   Integer(i);
            System.out.println( "Java   Puzzlers ");
    　　　　}
    　　}

Answer 9

  boolean b = true?false:((true == true)?false:true);//false

Answer 10

boolean   b   =   ((true?false:(true   ==   true))?false:true);
1级　——   .   ()
2级　——   ++   --   !   instanceof
3级　——   new
4级　——   *   /   %
5级　——   +   -
6级　——   > >   < <   > > >
7级　——   >   <   > =   <=
8级　——   ==   !=
9级　——   &
10级   ——   ^
11级   ——   !
12级   ——   &&
13级   ——   ||
14级   ——   ?:
15级   ——   =   +=   -=   *=   /=   %=   ^=
16级   ——   &=   < <=   > > =   > > > =

Answer 11

第五输出了Array  不明白

Answer 12

像这种如果是分开的两种方法都可以的，就寻找精度高的，Object 是 Integer的父类，所以int[] 的精度比Object的高，所以就输出Array了。

Answer 13

4.不可能发生的事
Integer.MIN_VALUE

Answer 14

public class Part {
    public static void main(String[] args) {
        int num = 32;
        System.out.println(num >>= 32);
    }
}32
int存储32位，向右边移动32位还是自己本身。

Answer 15

第三篇 
public class Part {
    public static void main(String[] args) {
        int j = 0;
        for (int i = 0; i < 100; i++) {
            j = j++;
        }
        System.out.println(j);
    }
}答案是：0
 j = j++;  就相当于 j=j;

Answer 16

第一篇
1：
a.5
b.6
c.5
d.6
2：
如果自动包装是分配的不同Integer对象那么就输出：
a.false
b.false
c.false
d.false
何必这样呢？为何不直接用equals？
3：
public class Test3 {
    public static void main(String[] args) { 
        /* 提示 \u000A 表示换行（LF），而 0x000A 表示什么呢？ */
        char c = 0x000A; System.out.println("Hello" + c + "World!"); 
    }
} /* output:
Hello
World!*/4：
public class Test4 {
    public static void main(String[] args) {
        int num = 0x80000000;
        if (num < 0 && num == Math.abs(num)) {
            System.out.println("Hello World!");
        }
    }
}
abs
public static int abs(int a)返回 int 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。 
注意，如果参数等于 Integer.MIN_VALUE 的值（即能够表示的最小负 int 值），那么结果与该值相同且为负。 
参数：
a - 要确定绝对值的参数。 
返回：
参数的绝对值。
另请参见：
Integer.MIN_VALUE
5：
public class Test1 {
    public static void main(String[] args) {
        invoke(null); // 子类引用优先接收到
    }    private static void invoke(Parent obj) {
        System.out.println("Parent");
    }    private static void invoke(Child nums) {
        System.out.println("Child");
    }
}class Parent {}class Child extends Parent {}
/* Output
Child
*/6:
没用过Number
第二篇
1：
Parrent
Parrent
2：
Java   Puzzlers不知道为什么考这个？
3：
public class Test {
    public static void main(String[] args) {
         String i = "";
         if (i != i + 0) {
             System.out.println("hello world");
         }
    }
}
4：
没用过BigInteger
5：
没学过
第三篇
1：
>>6位就已经变成0了，左移32位有什么意义呢？
2：
每次j都被赋值0，所以输出0，如果改为++j，那么就会输出100
3：
false
因为? :优先级低，所以等价于：boolean b = true?false:(true == true)?false:true;
4：
没学过
5:
又没学过
6：
还是没学过绝大部分是研究细节问题，难道记性好的朋友就可以做对吗？

Answer 17

http://topic.csdn.net/u/20110529/23/1729a6d3-2bdd-4d3f-b9de-f7ed889f9935.html
请参考这个，这是我之前看火龙果前辈的帖子所写的，看一下阿宝前辈的解释就明白了！！！

Answer 18

6，Number引起的计算错误Number是众多数值类型的抽象父类，难道用它会引发计算错误？！看看下面的程序会输出什么？Java code:
Java code
public class Test6 {
        public static void main(String[] args) {
            Number num = 12345 + 5432l;
            System.out.println(num.intValue());
        }
    }
這個5432l原來是5432L，汗一個

Answer 19

1.这个记得我们老师讲的时候专门提过，&&在左边运算值为false时不会计算右边的。||在左边运算值为true时不会计算右边。可以把两个运算符这样理解：
&&:
return(!left?left:right);
||:
return(left?left:right);
而&与|会先计算左边与右边的值，再进行逻辑运算。这个效果有个很实用的应用：if(con!=null&&!(con.isClose())
    con.close();

Answer 20

2.这个其实很容易理解，Integer是int的容器类。也就是说：它是个类。两个Integer的==运算自然也就执行两个Object的==运算，即比较两个对象的地址。有意思的是，当Integer对象执行其没有的运算时。如>、<，或Integer与int的==运算时，将会把Integer对象转换为int进行运算。即
new Integer(5)==5的值是true

Answer 21

3.这个，应该熟悉ASCII的都清楚，标准的换行符并不是'\n'而是'\r\n'('\r'对应0x0d,'\n'对应0x0a)。在Unix、Linux下用于表示换行的是'\n'，Windows下是'\r\n'(支持Unicode的Window下似乎也兼容'\n'的表示方式)。换句话说，在不支持Unicode的Windows下输出"Hello\nWorld"系统会因为不认识'\n'而输出乱码。
PS:本人用的2003 Server是支持Unicode的，所以也看不到这种现象。

Answer 22

import java.text.SimpleDateFormat;public class Part {
    public static void main(String[] args) {
        System.out.println(formatTime(System.currentTimeMillis()));
    }    private static char[] formatTime(long currentTimeMillis) {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(
                currentTimeMillis).toCharArray();
    }
}

Answer 23

我很无耻的点了MyEclipse j++为什么不执行呢

Answer 24

j++是执行了，也就是现在j的值加一了，但是j++整体的值并没有增加，现在j = j++,所以j的值又回到了原值0.

Answer 25

好像是thinking in java里面有介绍

Answer 26

位运算用得比较多的，特别是一些数学计算或者数据存储运输中运用得会比较多，例如一些加密算法，byte与字符串转换，或者一些曲线轨迹运算，基本上都会用到位运算，而且^运算的几率在这些情况中也是相当常见的，当然和通用的+ - * / 运算符比较起来，是要少多了。

Answer 27

第2篇第3题public class Test {
    public static void main(String[] args) {
         String i = "1";
         if (i != i +0) {
             System.out.println("hello world");
         }
    }
}

Answer 28

public class Testt {
    public static void main(String[] args) {
 Number num = 12345 + 54321;
         System.out.println(num.intValue());
    }
}这道题我很郁闷的是，我复制过去是177777，我自己敲代码，死活是正确的66666

Answer 29

Number引起的计算错误Number是众多数值类型的抽象父类，难道用它会引发计算错误？！看看下面的程序会输出什么？
艹，这题的54321根本不是54321，最后那个是L。

Answer 30

4.答案是Integer.MIN_VALUE,
可以看下Math.abs的代码：    public static int abs(int a) {
return (a < 0) ? -a : a;
    }即a<0时会返回-a。
再看下Integer.MIN_VALUE对应的值是0x80000000，补码的相反数计算方法为“取反加一”，
0x80000000取反=>0x7fffffff
0x7fffffff+1=>0x80000000
计算结果依然是Integer.MIN_VALUE即-2^31。
可以得出结论：Java里Math.abs(Integer.MIN_VALUE)<0。
这其实就是补码的溢出现象。相似的例子还有：for(int i=num;i<Integer.MAX_VALUE;i++)
...;以上是个死循环。由于i增加到Integer.MAX_VALUE(0x7fffffff)时再执行i++会溢出为Integer.MIN_VALUE(0x80000000)仍然满足i<Integer.MAX_VALUE的条件。PS：为了横向比较，在.Net上做了试验。发现Microsoft为了避免这个Bug，在Math.Abs的参数为int.MinValue时会抛出Overflow异常。

Answer 31

5.这个也比较好理解，OOP函数重载的参数匹配顺序为：
基本类型：隐式转换中的低类型优先于高类型；
引用类型：继承(或实现)方优先于被继承(或被实现)方，即：子类优先于父类、接口优先于它所继承的接口、实现类优先于它所实现的接口。
(如果顺序反过来则低类型、子类、实现类所对应的函数将永远不可能被执行  -_-)再看题目，数组其实是个类，也是继承自Object的。所以优先匹配第二个invoke函数，而null可以匹配所有的引用类型所以被调用的是int[]对应的invoke函数。PS：讨论点题外话，当参数为基本类型，而重载函数没有与之对应或高于它的基本类型时，会去匹配它的容器类=>容器类的父类=>...=>Object。可见，当一个函数有Object类型的参数时，它就可以匹配所有类型的参数了。

Answer 32

6.这题……
也就是5432l容易看成54321，也许是想告诉我们写后缀时要用大写L吧……
感觉像是脑筋急转弯，没什么技术上的问题。二篇：
1.这个理解起来有点绕：
先得理解p与p指向的对象。p是一个局部变量，它所处位置在操作系统给程序分配的栈区。对象是程序在堆数据区为存储数据而分配的一块内存区域(分配过程在new运算时完成)。p指向一个对象意为p中存储的数值是该对象所处内存区域的首地址或内存映射表中的键值(即C/C++中的指针)。重点是p与p指向的对象在内存中是不同内存区块。当Java虚拟机取p的对象成员时，会到p所指向的对象中找对应的成员(这时如果p没指向任何存在的变量即为null时就会引发空指针异常)。而修饰为static的成员叫作静态成员(或类成员)，从名字上可以看出：它并不是存放在堆里的，而是与类信息一样存放在静态内存区。使用静态成员不需要从堆里取数据，只需要根据类名从静态内存里取就行了(也可以用类名调用静态成员，如上面写的Integer.MIN_VALUE)。
执行流程：(以变量c为例)
取对象成员：c=>c指向对象(类型为Child，由Parent c = new Child()创建)=>Child的getName方法=>输出Child
取静态成员：c=>c对应类名(Parent)=>Parent的getName方法=>输出Parent。可以试试：将p与c赋值成null，同样可以取到静态成员： public static void main(String[] args) {
Parent p = null;
Child c = null; System.out.println(p.call());
System.out.println(c.call());
}输出结果为：
Parent
ChildPS：部分OOP语言为了避免产生这种歧意，只允许通过类名调用静态成员，用变量调用静态成员将通不过编译。

Answer 33

大家为什么不去看《JAVA 解惑》这本书呢？这种问题，大师级的人物都解释过了

Answer 34

2.这个问题……　　之前还真没注意到……这个问题并不是逻辑上的问题，而是Java编译器的硬性规定(也就是要死记硬背的-_-)。注意到for()循环的循环体是内嵌形式，不是{}引起来的。也就是说，它只有一句。在这一句中声明的局部变量不会有被用到的可能。为了避免这种内存的浪费以及一些无法预期的状况，Java编译器会对内嵌形式(if、while等的内嵌形式也一样)中使用的声明语句发出编译期error(C#中的错误提示是"嵌入的语句不能是声明或标记语句")。PS：并不是所有的OOP语言都禁止这种用法，C++就可以编译过去。

Answer 35

j=j++;j++是先赋值在做加1 也就是说j=j++ j++这个时候为0赋值给了j 然后才做j+1...

Answer 36

看书归看书，讨论是讨论哈。一家之言终归只代表他个人的看法。就似盲人摸象一般，各人站在不同的角度看同一事物可能会得到完全不同的结论。只是看书的话，知识永远是别人的。只有通过不断的实践和研讨才能把书本上的知识变成自己的，并能举一反三，发现新的问题。我不敢说自己的分析比那些“大师级”的要好，但至少我和他们不会是完全站在一个观点上看问题的。PS：其实我是挺希望有人提些反对的看法，这样争论才能学到真正的知识。(另外，那本书哪儿有下?我也下本看看:P)继续：
3.String i="";
这里需要注意的是+这个运算并不是数值型独有的。Java里还有String类也是可以用+运算符的(在Java里是特例，因为Java没有运算符重载的功能)。
PS：如果是有运算符重载的功能的语言中(如C++、C#)，还可以重载出各种+运算。

Answer 37

4.这道题目是计算结果会抛出格式异常：
BigInteger参数中的字符串貌似不能有空格的。忽略上面的问题(可能是笔误)，输出结果是0。这个问题对于用过BigInteger和BigDecimal的就是最简单的概念题，没用过的就猜去吧(我是猜0的^_^，直觉觉得应该和int不一样)。查JDK文档就可以知道，BigInteger是不可变整数(像String)，它本身的值是不可变的。
add方法不会改变它本身的值，而会把和当作返回值。因此，BigInteger的加法不是
a.add(b)
而是
c=a.add(b).

Answer 38

2:
a.false
b.false
c.false
d.false3:4:
负数 如-15：
报错或者Objects6:
第二篇：1:
Parent
Child2:
11 个 Java Puzzlers3:4:

Answer 39

5.这题不是已经把答案给出来了么？
(也是概念题)三篇：
1.答案是32。
因为Java标准的int是32位的，而左移与右移的运算会在移动前根据被操作数的位数对操作数进行取余计算(目的是不让操作数超过被操作数的位数，注意：输出为32并不是因为右移了32位，而是32%32=0，并没有移位)PS：数值左移时会在数据最右方补0，右移时会在最左方补0(无符号变量)或补符号(有符号变量，最左边一位表示正负号，非负数为0，负数为1)，Java标准中没有符号变量。
因此假设>>32是右移32位的话，那计算结果将会因为补0而变成0，而不是32了。看下面的例子就能明白了： public static void main(String[] args) {
int a=32;

System.out.println(a>>32);  //1
System.out.println(a>>31);  //2
System.out.println(a>>33);  //3
}1处右移32%32=0位，结果为32；
2处右移31位，结果为0；
3处右移33%32=1位，结果为16。