1、数值表达式1. 奇偶判断不要使用 i % 2 = 1 来判断是否是奇数，因为 i 为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用高效式 (i /0.8999999999999999上面的计算出的结果不是 0.9，而是一连串的小数。问题在于 1.1 这个数字不能被精确表示为一个 double，因此它被表示为最接近它的 double 值，该程序从 2 中减去的就是这个值，但这个计算的结果并不是最接近 0.9 的 double 值。一般地说，问题在于并不是所有的小数都可以用二进制浮点数精确表示。二进制浮点对于货币计算是非常不适合的，因为它不可能将 1.0 表示成 10 的其
2、他任何负次幂。解决问题的第一种方式是使用货币的最小单位（分）来表示：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.1000000000000000055511151231
3、257827021181583404541015625，正确使用BigDecimal，程序就可以打印出我们所期望的结果0.9：System.out.println(new BigDecimal(“2.0“).subtract(new BigDecimal(“1.10“);/ 0.9另外，如果要比较两个浮点数的大小，要使用BigDecimal的compareTo 方法。3. int 整数相乘溢出我们计算一天中的微秒数：long microsPerDay = 24 * 60 * 60 * 1000 * 1000;/ 正确结果应为：86400000000System.out.println(micr
4、osPerDay);/ 实际上为：500654080问题在于计算过程中溢出了。这个计算式完全是以 int 运算来执行的，并且只有在运算完成之后，其结果才被提升为 long，而此时已经太迟：计算已经溢出。解决方法使计算表达式的第一个因子明确为 long 型，这样可以强制表达式中所有的后续计算都用 long 运算来完成，这样结果就不会溢出：long microsPerDay = 24L * 60 * 60 * 1000 * 1000;4. 负的十六进制与八进制字面常量“数字字面常量”的类型都是 int 型，而不管他们是几进制，所以 “2147483648”、“0x180000000（十六进制，共
5、33 位，所以超过了整数的取值范围） ”字面常量是错误的，编译时会报超过 int 的取值范围了，所以要确定以 long 来表示“2147483648L” 、“0x180000000L”。十进制字面常量只有一个特性，即所有的十进制字面常量都是正数，如果想写一个负的十进制，则需要在正的十进制字面常量前加上“-”即可。十六进制或八进制字面常量可就不一定是正数或负数，是正还是负，则要根据当前情况看：如果十六进制和八进制字面常量的最高位被设置成了 1，那么它们就是负数：System.out.println(0x80);/128 /0x81 看作是 int 型，最高位(第 32 位) 为 0，所以是正数S
6、ystem.out.println(0x81);/129 System.out.println(0x8001);/32769System.out.println(0x70000001);/1879048193 /字面量 0x80000001 为 int 型，最高位(第 32 位) 为 1，所以是负数System.out.println(0x80000001);/-2147483647/字面量 0x80000001L 强制转为 long 型，最高位（第 64 位）为 0，所以是正数System.out.println(0x80000001L);/2147483649/最小 int 型System
7、.out.println(0x80000000);/-2147483648/只要超过 32 位，就需要在字面常量后加 L 强转 long，否则编译时出错System.out.println(0x8000000000000000L);/-9223372036854775808从上面可以看出，十六进制的字面常量表示的是 int 型，如果超过 32 位，则需要在后面加“L”，否则编译过不过。如果为 32，则为负 int 正数，超过 32 位，则为 long 型，但需明确指定为 long。System.out.println(Long.toHexString(0x100000000L + 0xcafe
8、babe);/ cafebabe结果为什么不是 0x1cafebabe？该程序执行的加法是一个混合类型的计算：左操作数是 long型，而右操作数是 int 类型。为了执行该计算，Java 将 int 类型的数值用拓宽原生类型转换提升为 long 类型，然后对两个 long 类型数值相加。因为 int 是有符号的整数类型，所以这个转换执行的是符号扩展。这个加法的右操作数 0xcafebabe 为 32 位，将被提升为 long 类型的数值0xffffffffcafebabeL，之后这个数值加上了左操作 0x100000000L。当视为 int 类型时，经过符号扩展之后的右操作数的高 32 位是-
9、1，而左操作数的第 32 位是 1，两个数值相加得到了 0：0x 0xffffffffcafebabeL+0x 0000000100000000L-0x 00000000cafebabeL如果要得到正确的结果 0x1cafebabe，则需在第二个操作数组后加上“L”明确看作是正的long 型即可，此时相加时拓展符号位就为 0：System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL);/ 1cafebabe5. 窄数字类型提升至宽类型时使用符号位扩展还是零扩展System.out.println(int)(char)(byte
10、)-1);/ 65535结果为什么是 65535 而不是-1？窄的整型转换成较宽的整型时符号扩展规则：如果最初的数值类型是有符号的，那么就执行符号扩展（即如果符号位为 1，则扩展为 1，如果为零，则扩展为 0） ；如果它是 char，那么不管它将要被提升成什么类型，都执行零扩展。了解上面的规则后，我们再来看看迷题：因为 byte 是有符号的类型，所以在将 byte 数值-1（二进制为：11111111）提升到 char 时，会发生符号位扩展，又符号位为 1，所以就补 8个 1，最后为 16 个 1；然后从 char 到 int 的提升时，由于是 char 型提升到其他类型，所以采用零扩展而不是
11、符号扩展，结果 int 数值就成了 65535。如果将一个 char 数值 c 转型为一个宽度更宽的类型时，只是以零来扩展，但如果清晰表达以零扩展的意图，则可以考虑使用一个位掩码：int i = c /实质上等同于：int i = c ;如果将一个 char 数值 c 转型为一个宽度更宽的整型，并且希望有符号扩展，那么就先将char 转型为一个 short，它与 char 上个具有同样的宽度，但是它是有符号的：int i = (short)c;如果将一个 byte 数值 b 转型为一个 char，并且不希望有符号扩展，那么必须使用一个位掩码来限制它：char c = (char)(b / ch
12、ar c = (char) b;为有符号扩展6. (byte)0x90 = 0x90)?答案是不等的，尽管外表看起来是成立的，但是它却等于 false。为了比较 byte 数值(byte)0x90 和 int 数值 0x90，Java 通过拓宽原生类型将 byte 提升为 int，然后比较这两个 int 数值。因为 byte 是一个有符号类型，所以这个转换执行的是符号扩展，将负的 byte 数值提升为了在数字上相等的 int 值（10010000111111111111111111111111 10010000） 。在本例中，该转换将(byte)0x90 提升为 int 数值-112，它不等于
13、 int 数值的 0x90，即+144。解决办法：使用一个屏蔽码来消除符号扩展的影响，从而将 byte 转型为 int。(byte)0x90 int i = 0;System.out.println(true ? x : 0);/ XSystem.out.println(false ? i : x);/ 88条件表达式结果类型的规则：（1） 如果第二个和第三个操作数具有相同的类型，那么它就是条件表达式的类型。（2） 如果一个操作的类型是 T，T 表示 byte、short 或 char，而另一个操作数是一个 int类型的“字面常量” ，并且它的值可以用类型 T 表示，那条件表达式的类型就是T。
14、（3） 否则，将对操作数类型进行提升，而条件表达式的类型就是第二个和第三个操作被提升之后的类型。现来使用以上规则解上面的迷题，第一个表达式符合第二条规则：一个操作数的类型是char，另一个的类型是字面常量为 0 的 int 型，但 0 可以表示成 char，所以最终返回类型以char 类型为准；第二个表达式符合第三条规则：因为 i 为 int 型变量，而 x 又为 char 型变量，所以会先将 x 提升至 int 型，所以最后的结果类型为 int 型，但如果将 i 定义成 final 时，则返回结果类型为 char，则此时符合第二条规则，因为 final 类型的变量在编译时就使用“字面常量 0
15、”来替换三元表达式了：final int i = 0;System.out.println(false ? i : x);/ X在 JDK1.4 版本或之前，条件操作符 ?: 中，当第二个和延续三个操作数是引用类型时，条件操作符要求它们其中一个必须是另一个的子类型，那怕它们有同一个父类也不行：public class T public static void main(String args) System.out.println(f();public static T f() / !1.4 不能编译，但 1.5 可以/ !return true?new T1():new T2();retur
16、n true ? (T) new T1() : new T2();/ T1class T1 extends T public String toString() return “T1“;class T2 extends T public String toString() return “T2“;在 5.0 或以上版本中，条件操作符在延续二个和第三个操作数是引用类型时总是合法的。其结果类型是这两种类型的最小公共超类。公共超类总是存在的，因为 Object 是每一个对象类型的超类型，上面的最小公共超类是 T，所以能编译。8. +=复合赋值问题x+=i 与 x=x+i 等效吗，许多程序员都会认为第
17、一个表达式 x+=i 只是第二个表达式 x=x+i 的简写方式，但这并不准确。Java 语言规范中提到：复合赋值 E1 op= E2 等价于简单赋值 E1 = (T)(E1) op (E2)，其中T 是 E1 的类型。复合赋值表达式自动地将所执行计算的结果转型为其左侧变量的类型。如果结果的类型与该变量的类型相同，那么这个转型不会造成任何影响，然而，如果结果的类型比该变量的类型要宽，那么复合赋值操作符将悄悄地执行一个窄化原生类型转换，这样就会导致结果不正确：short x=0;int i = 123456;x +=i;System.out.println(x);/-7616使用简单的赋值方式就不
18、会有这样的问题了，因为宽类型不能自动转换成窄的类型，编译器会报错，这时我们就会注意到错误：x = x + i;/编译通不过请不要将复合赋值操作符作用于 byte、short 或 char 类型的变量；在将复合赋值操作符作用于 int 类型的变量时，要确保表达式右侧不是 long、float 或 double 类型；在将复合赋值操作符作用于 float 类型的变量时，要确保表达式右侧不是 double 类型。其实一句：不要将让左侧的类型窄于右侧的数字类型。总之，不要在 short、byte 或 char 类型的变量之上使用复合赋值操作符，因为这一过程会伴随着计算前类型的提升与计算后结果的截断，导
19、致最后的计算结果不正确。9. i =+i;与 i=i+;的区别int i = 0; i = i+;System.out.println(i);上面的程序会输出什么？大部分会说是 1，是也，非也。运行时正确结果为 0。i=+i;相当于以下二个语句（编译时出现警告，与 i=i;警告相同）：i=i+1;i=i;i = i+;相当于以下三个语句：int tmp = i;i = i + 1;i = tmp;下面看看下面程序片段：int i = 0, j = 0, y = 0;i+;/相当于：i=i+1;System.out.println(“i=“ + i);/ i=1+i;/相当于：i=i+1;Sys
20、tem.out.println(“i=“ + i);/ i=2i = i+;/相当于：int tmp=i;i=i+1;i=tmp;System.out.println(“i=“ + i);/ i=2i = +i;/编译时出现警告，与 i=i;警告相同。相当于：i=i+1;i=i;System.out.println(“i=“ + i);/ i=3j = i+;/相当于：int tmp=i;i=i+1;j=tmp;System.out.println(“j=“ + j);/ j=3System.out.println(“i=“ + i);/ i=4y = +i;/相当于：i=i+1;y=i;Sy
21、stem.out.println(“y=“ + y);/ y=5System.out.println(“i=“ + i);/ i=510.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 c = new Comparator() public int compare(Integer i1, Integer i2) return i1 - i2;/ 升序
