Java常见疑难问题-数值表达式2


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。

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

// 注,整型数不能被 0 除,即(int)XX/0运行时抛
double i = 1.0 / 0.0;// 正无穷大
double j = -1.0 / 0.0;// 负无穷大
// Double.POSITIVE_INFINITY定义为:POSITIVE_INFINITY = 1.0 / 0.0;
System.out.println(i + ” ” + (i == Double.POSITIVE_INFINITY));//Infinity true
// Double.NEGATIVE_INFINITY定义为:NEGATIVE_INFINITY = -1.0 / 0.0;
System.out.println(j + ” ” + (j == Double.NEGATIVE_INFINITY));//-Infinity true
System.out.println(i == (i + 1));// true
System.out.println(0.1f == 0.1);// false
float f = 33554432;
System.out.println(f + ” ” + (f==(f+1)));//3.3554432E7 true
13. 自己不等于自己吗?i!=i
NaN(Not a Number)不等于任何数,包括它自身在内。

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

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

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

System.out.println(0.0 / 0.0);// NaN
System.out.println(Double.NaN + ” ” + (Double.NaN == (0.0 / 0.0)));//NaN false
14. 自动拆箱
// 為了兼容以前版本,1.5不會自動拆箱
System.out.println(new Integer(0) == new Integer(0));// false
// 1.4编译非法,1.5会自动拆箱
System.out.println(new Integer(0) == 0);// true
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。

System.out.println(Integer.MIN_VALUE == -Integer.MIN_VALUE);// true
/*
* 0x80000000取反得0x7fffffff,再加1得0x80000000,因为负数是
* 以补码形式存储于内存中的,所以推导出结果原码为:0x80000000,
* 即为-0,又因为-0是等于0的,所以不需要-0这个编码位,那就多了
* 一个0x80000000编码位了,所以最后就规定0x80000000为最小负数
*/
System.out.println(-0x80000000);// -2147483648
/*
* 0x7fffffff取反得0x80000000,再加1得0x80000001,因为负数是
* 以补码形式存储于内存中的,所以推导出结果原码为:0xffffffff,
* 第一位为符号位,所以最后的结果就为 -0x7fffffff = -2147483647
*/
System.out.println(-0x7fffffff);// -2147483647
另外,还发现有趣现象:最大整数加1后会等于最小整数:
// MAX_VALUE = 0x7fffffff; MIN_VALUE = 0x80000000;
System.out.println((Integer.MAX_VALUE + 1) == Integer.MIN_VALUE);// true
// MIN_VALUE = 0x8000000000000000L; MIN_VALUE = 0x8000000000000000L;
System.out.println((Long.MAX_VALUE + 1) == Long.MIN_VALUE);// true

当然,-Byte. MIN_VALUE==Byte.MIN_VALUE、-Short.MIN_VALUE== Short.MIN_VALUE、
-Long.MIN_VALUE== Long.MIN_VALUE,也是成立的。

声明: 除非转自他站(如有侵权,请联系处理)外,本文采用 BY-NC-SA 协议进行授权 | 智乐兔
转载请注明:转自《Java常见疑难问题-数值表达式2
本文地址:https://www.zhiletu.com/archives-235.html
关注公众号:智乐兔

赞赏

wechat pay微信赞赏alipay pay支付宝赞赏

上一篇
下一篇

相关文章

在线留言

你必须 登录后 才能留言!

在线客服
在线客服 X

售前: 点击这里给我发消息
售后: 点击这里给我发消息

智乐兔官微