程序博客网 > 淘宝自动好评是多久

《java解惑》：数值表达式

来源：互联网 发布：淘宝自动好评是多久 编辑：程序博客网 时间：2024/05/21 22:43

数值表达式 
1. 奇偶判断 
不要使用 i % 2 == 1 来判断是否是奇数，因为i为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用高效式 (i & 1) != 0来判断。 
2. 小数精确计算

Java代码 复制代码
  1. System.out.println(2.00 -1.10);//0.8999999999999999  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(2.00 -1.10);//0.8999999999999999</span>  

上面的计算出的结果不是 0.9，而是一连串的小数。问题在于1.1这个数字不能被精确表示为一个double，因此它被表示为最接近它的double值，该程序从2中减去的就是这个值，但这个计算的结果并不是最接近0.9的double值。 
一般地说，问题在于并不是所有的小数都可以用二进制浮点数精确表示。 
二进制浮点对于货币计算是非常不适合的，因为它不可能将1.0表示成10的其他任何负次幂。

 

因为Java表示浮点数是使用二进制标示的，而0.1即1/10是无法用二进制来表示的：

 

2进制表示小数的时候只能够表示能够用1/(2^n)的和的任意组合

例如：
0.5能够表示，因为它可以表示成为1/2
0.75也能够表示，因为它可以表示成为1/2+1/(2^2)
0.875也能够表示，因为它可以表示成为1/2+1/(2^2)+1/(2^3)

但是0.1不能够精确表示，因为它补能够表示成为1/(2^n)的和的形式

解决问题的第一种方式是使用货币的最小单位（分）来表示：System.out.println(200-110);//90 

第二种方式是使用BigDecimal，但一定要用BigDecimal(String)构造器，而千万不要用BigDecimal(double)来构造（也不能将float或double型转换成String再来使用BigDecimal(String)来构造，因为在将float或double转换成String时精度已丢失）。例如new BigDecimal(0.1)，它将返回一个BigDecimal，也即0.1000000000000000055511151231257827021181583404541015625，正确使用BigDecimal，程序就可以打印出我们所期望的结果0.9：

Java代码 复制代码
  1. System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.10")));// 0.9  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.10")));// 0.9</span>  


另外，如果要比较两个浮点数的大小，要使用BigDecimal的compareTo方法。 
3. int整数相乘溢出 
我们计算一天中的微秒数：

Java代码 复制代码
  1. long microsPerDay = 24 * 60 * 60 * 1000 * 1000;// 正确结果应为：86400000000   
  2. System.out.println(microsPerDay);// 实际上为：500654080  
Java代码  收藏代码
  1. <span style="font-size: medium;">long microsPerDay = 24 * 60 * 60 * 1000 * 1000;// 正确结果应为：86400000000  
  2. System.out.println(microsPerDay);// 实际上为：500654080</span>  


问题在于计算过程中溢出了。这个计算式完全是以int运算来执行的，并且只有在运算完成之后，其结果才被提升为long，而此时已经太迟：计算已经溢出。 

解决方法使计算表达式的第一个因子明确为long型，这样可以强制表达式中所有的后续计算都用long运算来完成，这样结果就不会溢出：

Java代码 复制代码
  1. long microsPerDay = 24L * 60 * 60 * 1000 * 1000;  
Java代码  收藏代码
  1. <span style="font-size: medium;">long microsPerDay = 24L * 60 * 60 * 1000 * 1000;</span>  


4. 负的十六进制与八进制字面常量“数字字面常量”的类型都是int型，而不管他们是几进制，所以“2147483648”、“0x180000000（十六进制，共33位，所以超过了整数的取值范围）”字面常量是错误的，编译时会报超过int的取值范围了，所以要确定以long来表示“2147483648L”、“0x180000000L”。 

十进制字面常量只有一个特性，即所有的十进制字面常量都是正数，如果想写一个负的十进制，则需要在正的十进制字面常量前加上“-”即可。 

十六进制或八进制字面常量可就不一定是正数或负数，是正还是负，则要根据当前情况看：如果十六进制和八进制字面常量的最高位被设置成了1，那么它们就是负数：

Java代码 复制代码
  1. System.out.println(0x80);//128    
  2. //0x81看作是int型，最高位(第32位)为0，所以是正数   
  3. System.out.println(0x81);//129    
  4. System.out.println(0x8001);//32769   
  5. System.out.println(0x70000001);//1879048193    
  6. //字面量0x80000001为int型，最高位(第32位)为1，所以是负数   
  7. System.out.println(0x80000001);//-2147483647   
  8. //字面量0x80000001L强制转为long型，最高位（第64位）为0，所以是正数   
  9. System.out.println(0x80000001L);//2147483649   
  10. //最小int型   
  11. System.out.println(0x80000000);//-2147483648   
  12. //只要超过32位，就需要在字面常量后加L强转long，否则编译时出错   
  13. System.out.println(0x8000000000000000L);//-9223372036854775808  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(0x80);//128   
  2. //0x81看作是int型，最高位(第32位)为0，所以是正数  
  3. System.out.println(0x81);//129   
  4. System.out.println(0x8001);//32769  
  5. System.out.println(0x70000001);//1879048193   
  6. //字面量0x80000001为int型，最高位(第32位)为1，所以是负数  
  7. System.out.println(0x80000001);//-2147483647  
  8. //字面量0x80000001L强制转为long型，最高位（第64位）为0，所以是正数  
  9. System.out.println(0x80000001L);//2147483649  
  10. //最小int型  
  11. System.out.println(0x80000000);//-2147483648  
  12. //只要超过32位，就需要在字面常量后加L强转long，否则编译时出错  
  13. System.out.println(0x8000000000000000L);//-9223372036854775808</span>  


从上面可以看出，十六进制的字面常量表示的是int型，如果超过32位，则需要在后面加“L”，否则编译过不过。如果为32，则为负int正数，超过32位，则为long型，但需明确指定为long。 

Java代码 复制代码
  1. System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));// cafebabe  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));// cafebabe</span>  

结果为什么不是0x1cafebabe？该程序执行的加法是一个混合类型的计算：左操作数是long型，而右操作数是int类型。为了执行该计算，Java将int类型的数值用拓宽原生类型转换提升为long类型，然后对两个long类型数值相加。因为int是有符号的整数类型，所以这个转换执行的是符号扩展。 
这个加法的右操作数0xcafebabe为32位，将被提升为long类型的数值0xffffffffcafebabeL，之后这个数值加上了左操作0x100000000L。当视为int类型时，经过符号扩展之后的右操作数的高32位是-1，而左操作数的第32位是1，两个数值相加得到了0： 
0x 0xffffffffcafebabeL 
+0x 0000000100000000L 
----------------------------- 
0x 00000000cafebabeL 

如果要得到正确的结果0x1cafebabe，则需在第二个操作数组后加上“L”明确看作是正的long型即可，此时相加时拓展符号位就为0：

Java代码 复制代码
  1. System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));// 1cafebabe  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));// 1cafebabe</span>  


5. 窄数字类型提升至宽类型时使用符号位扩展还是零扩展

Java代码 复制代码
  1. System.out.println((int)(char)(byte)-1);// 65535  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println((int)(char)(byte)-1);// 65535</span>  

结果为什么是65535而不是-1？ 

窄的整型转换成较宽的整型时符号扩展规则：如果最初的数值类型是有符号的，那么就执行符号扩展（即如果符号位为1，则扩展为1，如果为零，则扩展为0）；如果它是char，那么不管它将要被提升成什么类型，都执行零扩展。 

了解上面的规则后，我们再来看看迷题：因为byte是有符号的类型，所以在将byte数值-1（二进制为：11111111）提升到char时，会发生符号位扩展，又符号位为1，所以就补8个1，最后为16个1；然后从char到int的提升时，由于是char型提升到其他类型，所以采用零扩展而不是符号扩展，结果int数值就成了65535。 

如果将一个char数值c转型为一个宽度更宽的类型时，只是以零来扩展，但如果清晰表达以零扩展的意图，则可以考虑使用一个位掩码：

Java代码 复制代码
  1. int i = c & 0xffff;//实质上等同于：int i = c ;  
Java代码  收藏代码
  1. <span style="font-size: medium;">int i = c & 0xffff;//实质上等同于：int i = c ;</span>  


如果将一个char数值c转型为一个宽度更宽的整型，并且希望有符号扩展，那么就先将char转型为一个short，它与char上个具有同样的宽度，但是它是有符号的：

Java代码 复制代码
  1. int i = (short)c;  
Java代码  收藏代码
  1. <span style="font-size: medium;">int i = (short)c;</span>  



如果将一个byte数值b转型为一个char，并且不希望有符号扩展，那么必须使用一个位掩码来限制它：

Java代码 复制代码
  1. char c = (char)(b & 0xff);// char c = (char) b;为有符号扩展  
Java代码  收藏代码
  1. <span style="font-size: medium;">char c = (char)(b & 0xff);// char c = (char) b;为有符号扩展</span>  


6. ((byte)0x90 == 0x90)?答案是不等的，尽管外表看起来是成立的，但是它却等于false。为了比较byte数值(byte)0x90和int数值0x90，Java通过拓宽原生类型将byte提升为int，然后比较这两个int数值。因为byte是一个有符号类型，所以这个转换执行的是符号扩展，将负的byte数值提升为了在数字上相等的int值（10010000111111111111111111111111 10010000）。在本例中，该转换将(byte)0x90提升为int数值-112，它不等于int数值的0x90，即+144。 
解决办法：使用一个屏蔽码来消除符号扩展的影响，从而将byte转型为int。

Java代码 复制代码
  1. ((byte)0x90 & 0xff)== 0x90  
Java代码  收藏代码
  1. <span style="font-size: medium;">((byte)0x90 & 0xff)== 0x90</span>  



7. 三元表达式（?:）

Java代码 复制代码
  1. char x = 'X';   
  2. int i = 0;   
  3. System.out.println(true ? x : 0);// X   
  4. System.out.println(false ? i : x);// 88  
Java代码  收藏代码
  1. <span style="font-size: medium;">char x = 'X';  
  2. int i = 0;  
  3. System.out.println(true ? x : 0);// X  
  4. System.out.println(false ? i : x);// 88</span>  



条件表达式结果类型的规则： 
（1） 如果第二个和第三个操作数具有相同的类型，那么它就是条件表达式的类型。 
（2） 如果一个操作的类型是T，T表示byte、short或char，而另一个操作数是一个int类型的“字面常量”，并且它的值可以用类型T表示，那条件表达式的类型就是T。 
（3） 否则，将对操作数类型进行提升，而条件表达式的类型就是第二个和第三个操作被提升之后的类型。 

现来使用以上规则解上面的迷题，第一个表达式符合第二条规则：一个操作数的类型是char，另一个的类型是字面常量为0的int型，但0可以表示成char，所以最终返回类型以char类型为准；第二个表达式符合第三条规则：因为i为int型变量，而x又为char型变量，所以会先将x提升至int型，所以最后的结果类型为int型，但如果将i定义成final时，则返回结果类型为char，则此时符合第二条规则，因为final类型的变量在编译时就使用“字面常量0”来替换三元表达式了：

Java代码 复制代码
  1. final int i = 0;   
  2. System.out.println(false ? i : x);// X  
Java代码  收藏代码
  1. <span style="font-size: medium;">final int i = 0;  
  2. System.out.println(false ? i : x);// X</span>  



在JDK1.4版本或之前，条件操作符 ?: 中，当第二个和延续三个操作数是引用类型时，条件操作符要求它们其中一个必须是另一个的子类型，那怕它们有同一个父类也不行：

Java代码 复制代码
  1. public class T {   
  2.     public static void main(String[] args) {   
  3.         System.out.println(f());   
  4.     }   
  5.     public static T f() {   
  6.         // !!1.4不能编译，但1.5可以   
  7.         // !!return true?new T1():new T2();   
  8.         return true ? (T) new T1() : new T2();// T1   
  9.     }   
  10. }   
  11.   
  12. class T1 extends T {   
  13.     public String toString() {   
  14.         return "T1";   
  15.     }   
  16. }   
  17.   
  18. class T2 extends T {   
  19.     public String toString() {   
  20.         return "T2";   
  21.     }   
  22. }  
Java代码  收藏代码
  1. <span style="font-size: medium;">public class T {  
  2.     public static void main(String[] args) {  
  3.         System.out.println(f());  
  4.     }  
  5.     public static T f() {  
  6.         // !!1.4不能编译，但1.5可以  
  7.         // !!return true?new T1():new T2();  
  8.         return true ? (T) new T1() : new T2();// T1  
  9.     }  
  10. }  
  11.   
  12. class T1 extends T {  
  13.     public String toString() {  
  14.         return "T1";  
  15.     }  
  16. }  
  17.   
  18. class T2 extends T {  
  19.     public String toString() {  
  20.         return "T2";  
  21.     }  
  22. }</span>  

在5.0或以上版本中，条件操作符在延续二个和第三个操作数是引用类型时总是合法的。其结果类型是这两种类型的最小公共超类。公共超类总是存在的，因为Object是每一个对象类型的超类型，上面的最小公共超类是T，所以能编译。 
8. +=复合赋值问题x+=i与x=x+i等效吗，许多程序员都会认为第一个表达式x+=i只是第二个表达式x=x+i的简写方式，但这并不准确。 

Java语言规范中提到：复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op (E2))，其中T是E1的类型。 

复合赋值表达式自动地将所执行计算的结果转型为其左侧变量的类型。如果结果的类型与该变量的类型相同，那么这个转型不会造成任何影响，然而，如果结果的类型比该变量的类型要宽，那么复合赋值操作符将悄悄地执行一个窄化原生类型转换，这样就会导致结果不正确：

Java代码 复制代码
  1. short x=0;   
  2. int i = 123456;   
  3. x +=i;   
  4. System.out.println(x);//-7616  
Java代码  收藏代码
  1. <span style="font-size: medium;">short x=0;  
  2. int i = 123456;  
  3. x +=i;  
  4. System.out.println(x);//-7616</span>  



使用简单的赋值方式就不会有这样的问题了，因为宽类型不能自动转换成窄的类型，编译器会报错，这时我们就会注意到错误：x = x + i;//编译通不过 

请不要将复合赋值操作符作用于byte、short或char类型的变量；在将复合赋值操作符作用于int类型的变量时，要确保表达式右侧不是long、float或double类型；在将复合赋值操作符作用于float类型的变量时，要确保表达式右侧不是double类型。其实一句：不要将让左侧的类型窄于右侧的数字类型。 

总之，不要在short、byte或char类型的变量之上使用复合赋值操作符，因为这一过程会伴随着计算前类型的提升与计算后结果的截断，导致最后的计算结果不正确。 
9. i =++i;与i=i++;的区别

Java代码 复制代码
  1. int i = 0;    
  2. i = i++;   
  3. System.out.println(i);  
Java代码  收藏代码
  1. <span style="font-size: medium;">int i = 0;   
  2. i = i++;  
  3. System.out.println(i);</span>  

上面的程序会输出什么？大部分会说是 1，是也，非也。运行时正确结果为0。 

i=++i;相当于以下二个语句（编译时出现警告，与i=i;警告相同）：

Java代码 复制代码
  1. i=i+1;   
  2. i=i;  
Java代码  收藏代码
  1. <span style="font-size: medium;">i=i+1;  
  2. i=i;</span>  



i = i++;相当于以下三个语句：

Java代码 复制代码
  1. int tmp = i;   
  2. i = i + 1;   
  3. i = tmp;  
Java代码  收藏代码
  1. <span style="font-size: medium;">int tmp = i;  
  2. i = i + 1;  
  3. i = tmp;</span>  



下面看看下面程序片段：

Java代码 复制代码
  1. int i = 0, j = 0, y = 0;   
  2. i++;//相当于：i=i+1;   
  3. System.out.println("i=" + i);// i=1   
  4. ++i;//相当于：i=i+1;   
  5. System.out.println("i=" + i);// i=2   
  6. i = i++;//相当于：int tmp=i;i=i+1;i=tmp;   
  7. System.out.println("i=" + i);// i=2   
  8. i = ++i;//编译时出现警告，与i=i;警告相同。相当于：i=i+1;i=i;   
  9. System.out.println("i=" + i);// i=3   
  10. j = i++;//相当于：int tmp=i;i=i+1;j=tmp;   
  11. System.out.println("j=" + j);// j=3   
  12. System.out.println("i=" + i);// i=4   
  13. y = ++i;//相当于：i=i+1;y=i;   
  14. System.out.println("y=" + y);// y=5   
  15. System.out.println("i=" + i);// i=5  
Java代码  收藏代码
  1. <span style="font-size: medium;">int i = 0, j = 0, y = 0;  
  2. i++;//相当于：i=i+1;  
  3. System.out.println("i=" + i);// i=1  
  4. ++i;//相当于：i=i+1;  
  5. System.out.println("i=" + i);// i=2  
  6. i = i++;//相当于：int tmp=i;i=i+1;i=tmp;  
  7. System.out.println("i=" + i);// i=2  
  8. i = ++i;//编译时出现警告，与i=i;警告相同。相当于：i=i+1;i=i;  
  9. System.out.println("i=" + i);// i=3  
  10. j = i++;//相当于：int tmp=i;i=i+1;j=tmp;  
  11. System.out.println("j=" + j);// j=3  
  12. System.out.println("i=" + i);// i=4  
  13. y = ++i;//相当于：i=i+1;y=i;  
  14. System.out.println("y=" + y);// y=5  
  15. System.out.println("i=" + i);// i=5</span>  


10. Integer.MAX_VALUE + 1=? 
System.out.println(Integer.MAX_VALUE + 1); 
上面的程序输出多少？2147483647+1=2147483648？答案为-2147483648。 

查看源码Integer.MAX_VALUE 为MAX_VALUE = 0x7fffffff；所以加1后为0x80000000，又0x80000000为整型字面常量，满了32位，且最位为1，所以字面上等于 -0，但又由于 -0就是等于0，所以-0这个编码就规定为最小的负数，32位的最小负数就是-2147483648。 
11. -1<<32=?、-1<<65=?如果左操作数是int（如果是byte、short、char型时会提升至int型再进行位操作）型，移位操作符只使用其右操作数的低5位作为移位长度（也就是将右操作数除以32取余）；如果左操作数是long型，移位操作符只使用其右操作数的低6位作为移位长度（也就是将右操作数除以64取余）； 

再看看下面程序片段就会知道结果：

Java代码 复制代码
  1. System.out.println(-1 << 31);// -2147483648 向左移31%32=31位   
  2. System.out.println(-1 << 32);// -1 向左移32%32=0位   
  3. System.out.println(-1 << 33);// -2 向左移33%32=1位   
  4. System.out.println(-1 << 1);// -2 向左移1%32=1位   
  5.   
  6. System.out.println(-1L << 63);// -9223372036854775808 向左移63%64=63位  
  7. System.out.println(-1L << 64);// -1 向左移64%64=0位   
  8. System.out.println(-1L << 65);// -2 向左移65%64=1位   
  9. System.out.println(-1L << 1);// -2 向左移1%64=1位   
  10.   
  11. byte b = -1;// byte型在位操作前类型提升至int   
  12. System.out.println(b << 31);// -2147483648 向左移31%32=31位   
  13. System.out.println(b << 63);// -2147483648 向左移63%32=31位   
  14.   
  15. short s = -1;// short型在位操作前类型提升至int   
  16. System.out.println(s << 31);// -2147483648 向左移31%32=31位   
  17. System.out.println(s << 63);// -2147483648 向左移63%32=31位   
  18.   
  19. char c = 1;// char型在位操作前类型提升至int   
  20. System.out.println(c << 31);// -2147483648 向左移31%32=31位   
  21. System.out.println(c << 63);// -2147483648 向左移63%32=31位  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(-1 << 31);// -2147483648 向左移31%32=31位  
  2. System.out.println(-1 << 32);// -1 向左移32%32=0位  
  3. System.out.println(-1 << 33);// -2 向左移33%32=1位  
  4. System.out.println(-1 << 1);// -2 向左移1%32=1位  
  5.   
  6. System.out.println(-1L << 63);// -9223372036854775808 向左移63%64=63位  
  7. System.out.println(-1L << 64);// -1 向左移64%64=0位  
  8. System.out.println(-1L << 65);// -2 向左移65%64=1位  
  9. System.out.println(-1L << 1);// -2 向左移1%64=1位  
  10.   
  11. byte b = -1;// byte型在位操作前类型提升至int  
  12. System.out.println(b << 31);// -2147483648 向左移31%32=31位  
  13. System.out.println(b << 63);// -2147483648 向左移63%32=31位  
  14.   
  15. short s = -1;// short型在位操作前类型提升至int  
  16. System.out.println(s << 31);// -2147483648 向左移31%32=31位  
  17. System.out.println(s << 63);// -2147483648 向左移63%32=31位  
  18.   
  19. char c = 1;// char型在位操作前类型提升至int  
  20. System.out.println(c << 31);// -2147483648 向左移31%32=31位  
  21. System.out.println(c << 63);// -2147483648 向左移63%32=31位</span>  


12. 一个数永远不会等于它自己加1吗？i==i+1一个数永远不会等于它自己加1，对吗？如果数字是整型，则对；如果这个数字是无穷大或都是浮点型足够大（如1.0e40），等式就可能成立了。 

Java强制要求使用IEEE 754浮点数算术运算，它可以让你用一个double或float来表示无穷大。 

浮点型分为double型、float型。 

无穷分为正无穷与负无穷。 

无穷大加1还是无穷大。 

一个浮点数值越大，它和其后继数值之间的间隔就越大。 

对一个足够大的浮点数加1不会改变它的值，因为1不足以“填补它与其后者之间的空隙”。 

浮点数操作返回的是最接近其精确数学结果的浮点数值。 

一旦毗邻的浮点数值之间的距离大于2，那么对其中的一个浮点数值加1将不会产生任何效果，因为其结果没有达到两个数值之间的一半。对于float类型，加1不会产生任何效果的最小数是2^25，即33554432；而对于double类型，最小数是2^54，大约是1.8*10^16。 

33554432F转二进制过程： 
33554432的二进制为：10000000000000000000000000，将该二进制化成规范的小数二进制，即小数从右向左移25位1.0000000000000000000000000，化成浮点数二进制0,25+127, 00000000000000000000000 00（丢弃最后两位），即0, 10011000, 00000000000000000000000，最后的结果为1.00000000000000000000000*2^25 


毗邻的浮点数值之间的距离被称为一个ulp，它是最小单位（unit in the last place）的首字母缩写。在5.0版本中，引入了Math.ulp方法来计算float或double数值的ulp。 

二进制浮点算术只是对实际算术的一种近似。 

Java代码 复制代码
  1. // 注，整型数不能被 0 除，即(int)XX/0运行时抛异常   
  2. double i = 1.0 / 0.0;// 正无穷大   
  3. double j = -1.0 / 0.0;// 负无穷大   
  4. // Double.POSITIVE_INFINITY定义为：POSITIVE_INFINITY = 1.0 / 0.0;   
  5. System.out.println(i + " " + (i == Double.POSITIVE_INFINITY));//Infinity true   
  6. // Double.NEGATIVE_INFINITY定义为：NEGATIVE_INFINITY = -1.0 / 0.0;   
  7. System.out.println(j + " " + (j == Double.NEGATIVE_INFINITY));//-Infinity true   
  8. System.out.println(i == (i + 1));// true   
  9. System.out.println(0.1f == 0.1);// false   
  10. float f = 33554432;   
  11. System.out.println(f + " " + (f==(f+1)));//3.3554432E7 true  
Java代码  收藏代码
  1. <span style="font-size: medium;">// 注，整型数不能被 0 除，即(int)XX/0运行时抛异常  
  2. double i = 1.0 / 0.0;// 正无穷大  
  3. double j = -1.0 / 0.0;// 负无穷大  
  4. // Double.POSITIVE_INFINITY定义为：POSITIVE_INFINITY = 1.0 / 0.0;  
  5. System.out.println(i + " " + (i == Double.POSITIVE_INFINITY));//Infinity true  
  6. // Double.NEGATIVE_INFINITY定义为：NEGATIVE_INFINITY = -1.0 / 0.0;  
  7. System.out.println(j + " " + (j == Double.NEGATIVE_INFINITY));//-Infinity true  
  8. System.out.println(i == (i + 1));// true  
  9. System.out.println(0.1f == 0.1);// false  
  10. float f = 33554432;  
  11. System.out.println(f + " " + (f==(f+1)));//3.3554432E7 true</span>  


13. 自己不等于自己吗？i!=i 
NaN（Not a Number）不等于任何数，包括它自身在内。 

double i = 0.0/0.0;可表示NaN。 

float和double类型都有一个特殊的NaN值，Double.NaN、Float.NaN表示NaN。 

如果一个表达式中产生了NaN，则结果为NaN。 

Java代码 复制代码
  1. System.out.println(0.0 / 0.0);// NaN   
  2. System.out.println(Double.NaN + " " + (Double.NaN == (0.0 / 0.0)));//NaN false  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(0.0 / 0.0);// NaN  
  2. System.out.println(Double.NaN + " " + (Double.NaN == (0.0 / 0.0)));//NaN false</span>  

14. 自动拆箱

Java代码 复制代码
  1. // 為了兼容以前版本，1.5不會自動拆箱   
  2. System.out.println(new Integer(0) == new Integer(0));// false   
  3. // 1.4编译非法，1.5会自动拆箱   
  4. System.out.println(new Integer(0) == 0);// true  
Java代码  收藏代码
  1. <span style="font-size: medium;">// 為了兼容以前版本，1.5不會自動拆箱  
  2. System.out.println(new Integer(0) == new Integer(0));// false  
  3. // 1.4编译非法，1.5会自动拆箱  
  4. System.out.println(new Integer(0) == 0);// true</span>  


15. 为什么-0x00000000==0x00000000、-0x80000000== 0x80000000为了取一个整数类型的负值，要对其每一位取反（如果是对某个十六进制形式整数求负，如：-0x00000000则直接对这个十六进制数进行各位取反操作——但不包括前面的负号；如果是对某个十进制求负，如-0，则需先求其绝对值的十六进制的原码后，再各位取反），然后再加1。 
注：如果是对某个十进制数求负，如-1（0xffffffff），实质上按照平时求一个负数补码的方式来处理也是一样的，求某个负数的补码规则为：先求这个数绝对值的原码，然后从该二进制的右边开始向左找第一个为1的位置，最后将这个1前的各位取反（包括最高位符号位，即最高位0取反后为1），其他位不变，最终所得的二进制就为这个负数的补码，也就是最终在内存中负数所表示的形式。不过在找这个第一个为1时可能找不到或在最高位，比如-0，其绝对值为0（0x00000000）；也有可能最高位为1，比如-2147483648，其绝对值为2147483648（0x80000000），如果遇到绝对值的原码为0x00000000或0x80000000的情况下则不变，即为绝对值的原码本身。 

-0x00000000的运算过程：对0x00000000先取反得到0xffffffff，再加1，-0x00000000的最后结果就为 0xffffffff+1，其最后的结果还是0x00000000，所以-0x00000000 == 0x00000000。前面是对0x00000000求负的过程，如果是对0求负呢?先求0的十六进制形式0x00000000，再按前面的过程来即可。或者根据前面规则对0x00000000求负不变，即最后结果还是0x00000000。 

-0x80000000的运算过程：对0x80000000先取反得到0x7fffffff，再加1，-0x80000000的最后结果就为 0x7fffffff+1，其最后的结果还是0x80000000，即-0x80000000 == 0x80000000。前面是对0x80000000求负的过程，如果是对2147483648求负呢?先求2147483648的十六进制形式0x80000000，再按前面的过程来即可。或者根据前面规则对0x80000000求负不变，即最后结果还是0x80000000。 

-0x00000001的运算过程，实质上就是求-1的补码过程，即对其绝对值的十六进制0x00000001求补码，即为0xffffffff，即-1的补码为0xffffffff。 

Java代码 复制代码
  1. System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE);// true    
  2. /*  
  3.  *  0x80000000取反得0x7fffffff，再加1得0x80000000，因为负数是  
  4.  *  以补码形式存储于内存中的，所以推导出结果原码为：0x80000000，  
  5.  *  即为-0，又因为-0是等于0的，所以不需要-0这个编码位，那就多了  
  6.  *  一个0x80000000编码位了，所以最后就规定0x80000000为最小负数   
  7.  */  
  8. System.out.println(-0x80000000);// -2147483648   
  9. /*  
  10.  *  0x7fffffff取反得0x80000000，再加1得0x80000001，因为负数是  
  11.  *  以补码形式存储于内存中的，所以推导出结果原码为：0xffffffff，  
  12. *  第一位为符号位，所以最后的结果就为 -0x7fffffff = -2147483647  
  13.  */  
  14. System.out.println(-0x7fffffff);// -2147483647  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE);// true      
  2. /* 
  3.  *  0x80000000取反得0x7fffffff，再加1得0x80000000，因为负数是 
  4.  *  以补码形式存储于内存中的，所以推导出结果原码为：0x80000000， 
  5.  *  即为-0，又因为-0是等于0的，所以不需要-0这个编码位，那就多了 
  6.  *  一个0x80000000编码位了，所以最后就规定0x80000000为最小负数  
  7.  */  
  8. System.out.println(-0x80000000);// -2147483648  
  9. /* 
  10.  *  0x7fffffff取反得0x80000000，再加1得0x80000001，因为负数是 
  11.  *  以补码形式存储于内存中的，所以推导出结果原码为：0xffffffff， 
  12. *  第一位为符号位，所以最后的结果就为 -0x7fffffff = -2147483647 
  13.  */  
  14. System.out.println(-0x7fffffff);// -2147483647</span>  




另外，还发现有趣现象：最大整数加1后会等于最小整数：

Java代码 复制代码
  1. // MAX_VALUE = 0x7fffffff; MIN_VALUE = 0x80000000;   
  2. System.out.println((Integer.MAX_VALUE + 1) == Integer.MIN_VALUE);// true   
  3. // MIN_VALUE = 0x8000000000000000L; MIN_VALUE = 0x8000000000000000L;   
  4. System.out.println((Long.MAX_VALUE + 1) == Long.MIN_VALUE);// true  
Java代码  收藏代码
  1. <span style="font-size: medium;">// MAX_VALUE = 0x7fffffff; MIN_VALUE = 0x80000000;  
  2. System.out.println((Integer.MAX_VALUE + 1) == Integer.MIN_VALUE);// true  
  3. // MIN_VALUE = 0x8000000000000000L; MIN_VALUE = 0x8000000000000000L;  
  4. System.out.println((Long.MAX_VALUE + 1) == Long.MIN_VALUE);// true</span>  



当然，-Byte. MIN_VALUE==Byte.MIN_VALUE、-Short.MIN_VALUE== Short.MIN_VALUE、-Long.MIN_VALUE== Long.MIN_VALUE，也是成立的。 
16. Math.abs结果一定为非负数吗?

Java代码 复制代码
  1. System.out.println(Math.abs(Integer.MIN_VALUE));// -2147483648  
Java代码  收藏代码
  1. <span style="font-size: medium;">System.out.println(Math.abs(Integer.MIN_VALUE));// -2147483648</span>  

上面的程序不会输出2147483648，而是-2147483648，为什么？ 

其实我们看一下Math.abs源码就知道为什么了，源码：(a < 0) ? -a : a;，结合上面那个迷题，我们就发现-Integer.MIN_VALUE= Integer.MIN_VALUE，所以上面的答案就是最小整数自己。 

另外我们也可以从API文档看到对Math.abs()方法的解释：如果参数等于 Integer.MIN_VALUE 的值（即能够表示的最小负 int 值），则结果与该值相同且为负。 

所以Math.abs不能保证一定会返回非负结果。 

当然，Long.MIN_VALUE也是这样的。 
17. 不要使用基于减法的比较器

Java代码 复制代码
  1. Comparator<Integer> c = new Comparator<Integer>() {   
  2.     public int compare(Integer i1, Integer i2) {   
  3.         return i1 - i2;// 升序   
  4.     }   
  5. };   
  6. List<Integer> l = new ArrayList<Integer>();   
  7. l.add(new Integer(-2000000000));   
  8. l.add(new Integer(2000000000));   
  9. Collections.sort(l, c);   
  10. System.out.println(l);// [2000000000, -2000000000]  
Java代码  收藏代码
  1. <span style="font-size: medium;">Comparator<Integer> c = new Comparator<Integer>() {  
  2.     public int compare(Integer i1, Integer i2) {  
  3.         return i1 - i2;// 升序  
  4.     }  
  5. };  
  6. List<Integer> l = new ArrayList<Integer>();  
  7. l.add(new Integer(-2000000000));  
  8. l.add(new Integer(2000000000));  
  9. Collections.sort(l, c);  
  10. System.out.println(l);// [2000000000, -2000000000]</span>  


上面程序的比较器是升序，结果却不是这样，比较时出现了什么问题？ 

先看看下面程序片断：

Java代码 复制代码
  1. int x = -2000000000;   
  2. int y = 2000000000;   
  3. /*  
  4.  * -2000000000 即 -(01110111001101011001010000000000)  
  5.  * 的补码为：                10001000110010100110110000000000  
  6.  *   
  7.  * 计算过程使用竖式表示：  
  8.  * 10001000110010100110110000000000  
  9.  * 10001000110010100110110000000000  
  10.  * --------------------------------  
  11.  * 00010001100101001101100000000000  
  12.  *   
  13.  * 计算结果溢出，结果为294967296  
  14.  */  
  15. System.out.println(x - y);
0 0
淘宝自动好评是多久 淘宝自动好评是多久
原创粉丝点击
热门IT博客
华为nova如何切换网络华为nova如何切换网络
cg动画软件cg动画软件
小漠淘宝
命运之手2mac破解版
手机台湾网络电视直播
java 快速排序算法
淘宝卖真aj的店铺
md5解密软件
dnf如何在淘宝上卖金币
final static 数组
电路仿真软件手机版
程序员砍死设计师
电力预算软件那个好
网络233什么意思啊
淘宝银行卡怎么解绑
手机电子书软件
c51单片机编程实例
长城三公主知乎
淘宝叶子类目是什么
皮皮麻将 玩网络
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 婚礼主持人台词 经典台词对白 经典台词大全 经典对白台词 搏击俱乐部台词 v字仇杀队 台词 断背山经典台词 v字仇杀队台词 碟中谍经典台词 结婚主持人台词 主持人台词大全 听说经典台词 中国机长经典台词 河东狮吼经典台词 中国机长经典台词敬畏 中国机长经典台词三个敬畏 伴郎叫门经典台词 花样年华经典台词 秒速5厘米经典台词 秘密花园经典台词 廊桥遗梦经典台词 蓝色大门经典台词 一代宗师经典台词 蓝莓之夜经典台词 我是传奇经典台词 面对巨人经典台词 独自等待经典台词 情癫大圣经典台词 金粉世家经典台词 魔兽世界经典台词 行运超人经典台词 换子疑云经典台词 迫在眉梢经典台词 世纪之战经典台词 居家男人经典台词 大力水手经典台词 悲惨世界经典台词 骄阳似我经典台词 麦兜故事经典台词 楚汉骄雄经典台词 地狱神探经典台词

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里