《Java解惑》书摘

例子1：关于char数组的输出

 System.out.println("H" + "a");//输出：Ha
 System.out.println('H' + 'a');//输出：169
 System.out.println("" + 'H' + 'a');//输出：Ha
 System.out.println("//////////////////");
 System.out.println("2 + 2 = " + 2 + 2);//输出：2 + 2 = 22
 System.out.println("2 + 2 = " + (2 + 2));//输出：2 + 2 = 4
 System.out.println("//////////////////");
 char[] char1 = {'1', '2', '3'};
 Object char2 = new char[] {'1', '2', '3'};
 System.out.println(char1);//输出：123
 System.out.println(char2);//输出：[C@55e83f9
 System.out.println("test-" + char1);//输出：test-[C@55e83f9
 System.out.println("test-" + char1.toString());//输出：test-[C@55e83f9
 System.out.println("test-" + String.valueOf(char1));//输出：test-123
 System.out.println("//////////////////");

---

例子2：

 Random random = new Random();
     StringBuffer sBuffer = null;
     switch(random.nextInt(2)) {
         case 1:sBuffer = new StringBuffer('A');
         case 2:sBuffer = new StringBuffer('B');
         default:sBuffer = new StringBuffer('C');
     }
     sBuffer.append('a');
     sBuffer.append('b');
     sBuffer.append('c');
     System.out.println(sBuffer);//输出：abc
 }

这段程序有三个BUG：

1. Random.nextInt(int n)方法的使用错误：
   先看下这个方法的API：
   public int nextInt(int n)
   返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
   所以，此处应改为：switch(random.nextInt(3)) {
2. case子句中没有break语句：
   导致前面的赋值被后面的赋值覆盖。
3. StringBuffer类的构造方法使用错误：
   StringBuffer不支持传入参数为字符(char)的构造方法，应改为传入字符串(String)，
   所以，应改为：sBuffer = new StringBuffer("A");

---

例子3：会死循环的代码

  //死循环1
         int start1  = Integer.MAX_VALUE-1;
         for(int start7=start1; start7<=start1+1; start7++) {
             System.out.println("loop..");
         }
         //死循环2
         double start2 = 1.0 / 0.0;
         double start3 = Double.POSITIVE_INFINITY;//与上句等价，可替代
         while(start2 == (start2+1)) {
             System.out.println("loop..");
         }
         //死循环3
         double start4 = 0.0 / 0.0;
         double start5 = Double.NaN;//与上句等价，可替代
         while(start4 != start4) {
             System.out.println("loop..");
         }
         //死循环4
         String start6 = "test";
         while(start6 != (start6+0)) {
             System.out.println("loop..");
         }
         //死循环5
         byte start7 = -1;//死循环
 //      short start7 = -1;//死循环
 //      int start7 = -1;//循环32次
 //      long start7 = -1;//循环64次
         int count = 0;//循环次数
         while(start7 != 0) {
             start7 >>>= 1;
             System.out.println("loop..");
             count++;
         }
         System.out.println("循环次数 = " + count);
         //死循环6
         int start8 = Integer.MIN_VALUE;
 //      Long start8 = Long.MIN_VALUE;
         while(start8 != 0 && start8 == -start8) {
             System.out.println("loop..");
         }

补充说明：

1. 关于Infinity和NaN（死循环2和3）

    double d = 1.0 / 0;
    System.out.println(d);             //输出：Infinity
    System.out.println(d + 1);         //输出：Infinity
    System.out.println(d == d + 1);    //输出：true
   
    d = 0.0 / 0;
    System.out.println(d);             //输出：NaN
    System.out.println(d + 1);         //输出：NaN
    System.out.println(d == d + 1);    //输出：false
   
    System.out.println(Double.NaN == Double.NaN);//输出：false
    Double a = new Double(Double.NaN);
    Double b = new Double(Double.NaN);
    System.out.println(a.equals(b));//输出：true

2. 关于Java的自动窄化原生类型转换（死循环5）
   分析 short start7 = -1; 和 start7 >>>= 1;这两句代码：
   在执行移位操作时，第一步是将start7提升为start7nt类型，因为所有的算术操作都会对short,byte,char类型的操作数执行这样的提升；
   这种提升是拓宽了原生类型，没有信息的损失，执行的是符号扩展，start7的值提升后是0xffffffff,start7>>>1之后得到的是0x7fffffff；
   将这个值再存入start7中的时候，为了将int数值存入short变量，Java自动执行了可怕的窄化原生类型，直接把高16位截掉，剩下(short)0xffff,又回到了起点，从而导致了死循环。
   这提醒了我们，不要在short,byte,char类型上使用复合赋值操作符，很容易出问题，而且这种隐性的窄化类型转换，在丢失信息的同时，结果也可能是灾难性的。
3. 关于Java中的特殊值（死循环6）
   Java使用2的补码的算术运算是不对称的。
   对于每一种有符号的整数类型（byte、short、int和long），负的数值总是比正的数值多一个，这个多出来的数值总是这个类型所能表示的最小值；
   对Integer.MIN_VALUE取负值并不会改变它的值，对这个值取负值将会产生溢出，但是Java自动忽略了这种溢出；同理对Long.MIN_VALUE等也是如此。