表达式之谜总结

一、奇数表达问题

问题：我们经常会认为i%2==1能够判断是否为奇数。

分析：

(1)取模操作符（%）:当取余操作返回一个非零的结果时，这个结果一定和左操作符有相同的符号。

举例：

• 3%2=1;
• -3%2=-1;对应前面的定义，由于左操作符是-3，因此结果应该也是负数。

(2)初步结果：通过i%2==0来判断是否为奇数。

(3)位运算：位运算比一般的算术运算速度快的多。一般偶数的二进制最低位都是0，不管是用原码、补码。

最终结果：（i&1）！=0

例程：

import java.util.Scanner; public class PuzzleDemo01{ public static void main(String args[]){ Scanner in = new Scanner(System.in); System.out.print("输入一个整数："); int a = in.nextInt(); System.out.println(""); System.out.println("i%2==1 -->"+isOdd1(a)); long begin1 = System.nanoTime(); System.out.println("i%2!=0 -->"+isOdd2(a)); long begin2 = System.nanoTime(); System.out.println("i&1!=0 -->"+isOdd3(a)); long begin3 = System.nanoTime(); System.out.println("isOdd2的运算时间："+(begin2-begin1)+" nano"); System.out.println("isOdd3的运算时间："+(begin3-begin2)+" nano"); } public static boolean isOdd1(int a){ return a%2==1; } public static boolean isOdd2(int a){ return a%2!=0; } public static boolean isOdd3(int a){ return (a&1)!=0; } } /* 测试结果： 输入一个整数：-3 i%2==1 -->false i%2!=0 -->true i&1!=0 -->true isOdd2的运算时间：378819 nano isOdd3的运算时间：368762 nano */

二、二进制浮点数运算的精度问题

问题：2.00-1.10的结果是什么？

分析：

(1)看起来好像很明确是0.90，但是实际上输出的是0.899999。原因：1.10不能被精确的表示成一个double。

(2)因此double和float不适用于精确计算。

(3)java.math.BigDecimal用于精确计算。

(4)用BigDecimal(String)的构造器，而不要用BigDecimal(double)的构造器，因为后者有不可预知性。

最终结果：

new BigDecimal("2.00").subtract(new BigDecimal("1.10"));

import java.math.BigDecimal; public class PuzzleDemo02{ public static void main(String args[]){ System.out.println("*******一般的浮点数运算:*******"); System.out.println(2.00-1.10); //0.8999999999999999 BigDecimal d1 = new BigDecimal("2.00"); BigDecimal d2 = new BigDecimal("1.10"); BigDecimal result = d1.subtract(d2); System.out.println("*******运用全精度后：********"); System.out.println(result); //0.90 } }

三、默认类型问题

问题：long a = 24*60*60*1000*1000;的结果是多少？

分析：

(1)默认来说一个整数的类型就是int，如果是long的话要加L。

(2)以上的运算会先是int的乘法，乘完的结果再转换成long类型，这并不能避免溢出。

(3)int是4字节，因此能表示-2³¹-1~2³¹，而上面的运算远远超出了这个范围，因此溢出。

最终结果：

long a = 24L*60*60*1000*1000;

public class PuzzleDemo03{ public static void main(String args[]){ long MICROS_PER_DAY_ORIGINAL = 24 * 60 * 60 * 1000 * 1000; long MILLIS_PER_DAY_ORIGINAL = 24 * 60 * 60 * 1000; System.out.println("最初的结果：" +MICROS_PER_DAY_ORIGINAL/MILLIS_PER_DAY_ORIGINAL);//5 long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000; long MILLIS_PER_DAY = 24L * 60 * 60 * 1000; System.out.println("改正后的结果：" +MICROS_PER_DAY/MILLIS_PER_DAY); //1000 System.out.println("溢出的结果 --> 24 * 60 * 60 * 1000 * 1000="+MICROS_PER_DAY_ORIGINAL); //500654080 System.out.println("不溢出的结果 --> 24L * 60 * 60 * 1000 * 1000="+MICROS_PER_DAY); //86400000000 } }

四、长整数的表示问题 l还是L？

因为在一般的1和l是差不多的，比如：

最终结果：

(1)在表示long类型的数时要用L.

(2)在表示变量时不能光用 l（小写的L） 表示.

public class PuzzleDemo04{ public static void main(String args[]){ System.out.println("12345+5432l="+(12345+5432l)); System.out.println("12345+54321="+(12345+54321)); System.out.println("12345+5432L="+(12345+5432L)); } } /* 12345+5432l=17777 12345+54321=66666 12345+5432L=17777 */

五、符号扩展和零扩展

问题1：long a = 0xcafebabe;中a的十六进制是多少呢？

分析：

(1)对于有符号数进行扩展时，就需要进行符号扩展。而对于无符号数（char）则采用零扩展。

(2)十六进制和八进制的int型时当最高位是1时，就是负数，符号扩展则高位填1.

最终结果：

结果是0xffffffffcafebabe而不是0x00000000cafebabe;

public class PuzzleDemo05{ public static void main(String args[]){ int a = 0xcafebabe; long b = a; System.out.println(a + " --> " + Integer.toHexString(a)); System.out.println(b + " --> " + Long.toHexString(b)); long c = 0x100000000L; System.out.println("0x100000000L+0xcafebabe="+Long.toHexString(c+b)); long d = 0xcafebabeL; System.out.println("0x100000000L+0xcafebabeL="+Long.toHexString(c+d)); } } /* -889275714 --> cafebabe -889275714 --> ffffffffcafebabe 0x100000000L+0xcafebabe=cafebabe 0x100000000L+0xcafebabeL=1cafebabe */

问题2：int a = (int)(char)-1;的结果是多少？

分析：

(1)-1是int类型的，转换成char，只需要截断即可，得0xffff.

(2)因为char是无符号的，因此零扩展，则a=0x0000ffff，即65535.

最终结果：

a=65535.

public class PuzzleDemo06{ public static void main(String args[]){ System.out.println((int)(char)(byte)-1); int i = -1; char c = (char)i; int j = c & 0xffff; //无符号扩展 int j2 = c; //无符号扩展 int k = (short)c; //有符号扩展 System.out.println("无符号扩展1："+j); System.out.println("无符号扩展2："+j2); System.out.println("有符号扩展1："+k); } }

总结：

(1)我们对于类型转换的扩展问题需要注释好意义。

(2)对于无符号扩展也可以通过位掩码来进行完成。

比如:

short s = -1;

int i = s&0xffff;//由于0xffff是int型的，因此s先进行符号扩展成int型，然后进行与，即把高位清除。

六、条件表达式的规则？：

问题：

int i =0;

true? 'x'：i；的结果是多少？

A?B:C

1.如果B和C具有相同的类型，则返回的就是B和C的类型。

2.如果一个操作数的类型是T（byte，int，char等），另一个是一个常量表达式，则返回的类型就是T。

3.否则对操作数类型进行二进制数字的提升，返回的类型就是B和C被二进制提升后的类型。

例如：

int i =0;

true? 'x'：i；这个由定理2，可以得出结果是int类型，因此结果是‘x’的ASCII码：120；

结论：尽量将B和C的类型相同。

public class PuzzleDemo08{ public static void main(String args[]){ char x = 'X'; int i = 0; System.out.println(true ? x : 0); //x是char类型，0是常量，因此返回char类型 System.out.println(false? i : x); //i是int变量，'x'是常量，因此返回int System.out.println(true? 'x': i); //i是int变量，'x'是常量，因此返回int final int j = 1; System.out.println(true?x:j); //x是char类型，而j是常量，因此返回char类型 } }
?:在jdk1.4和jdk1.5的区别：

在1.4中，当第二个操作数和第三个操作数都是引用类型时，条件操作符要求一个必须是另一个的子类型。

5.0中，第二第三个操作数是引用类型时，返回的结果是两类型的最小公共超类。

七、x+=i和x=x+i相等？不！

x+=i等价于x=(Typex)(x+i)从中看出，中间还有一个隐式的类型转换。

如果 x是short类型，i是int类型，则x+=i等价于x=(short)(x+i);

而x=x+i;则没有这个隐式转换，因此如果x的类型的宽度比i的类型的宽度小，则会发生x=x+i的编译错误，而x+=i不会有错。

public class PuzzleDemo09{ public static void main(String args[]){ short x=0; int i=123456; x += i; //合法 System.out.println(x); x=0; x = (short)(x + i); //x=x+i不合法 System.out.println(x); } } //x+=i 等价于 x=(Typex)(x+i);

但是复合的赋值操作符有一个限制：

(1)左操作数和右操作数都必须是基本数据类型或包装类

(2)如果左操作数的类型是String，则右操作数没有限制。

(3)左操作数不能是其他引用数据类型。

而x=x+i却没有这个限制。

public class PuzzleDemo10{ public static void main(String args[]){ String i = "abc"; Object x = "cba"; //x+=i; 不合法 x=x+i; //合法 System.out.println(x); } }