Java基本的程序结构设计 整形和浮点型

整形：

• int 4字节
• short 2字节
• long 8字节
• byte 1字节

int的大小差不多是20亿。

整形计算

如果两个int进行加减乘除数学运算的时候，最终的结果仍然是int，有可能出现了溢出，那么结果就不是我们想要的了。如下：

1. System.out.println("Integer.MAX_VALUE: " + Integer.MAX_VALUE);
2.       //两个int相加 结果仍然是int 溢出
3.       System.out.println("Integer.MAX_VALUE - Integer.MIN_VALUE: " + (Integer.MAX_VALUE - Integer.MIN_VALUE));
4.       //两个int相加 结果仍然是int 溢出
5.       System.out.println("Integer.MAX_VALUE + 1 : " + (Integer.MAX_VALUE + 1));
6.       //int + long 结果是long 没有溢出
7.       System.out.println("Integer.MAX_VALUE + 1L: " + (Integer.MAX_VALUE + 1L));
8.       //int + long 结果是long 没有溢出
9.       System.out.println("(long)Integer.MAX_VALUE + 1: " + ((long)Integer.MAX_VALUE + 1));

输出：

Integer.MAX_VALUE: 2147483647

Integer.MAX_VALUE - Integer.MIN_VALUE: -1

Integer.MAX_VALUE + 1 : -2147483648

Integer.MAX_VALUE + 1L: 2147483648

(long)Integer.MAX_VALUE + 1: 2147483648

当然，long相加也有这种情况。

两个int进行除法运算，得到的结果是int，不是四舍五入，而是直接截断。其他整形也是一样。

int除法，如果除数是0，那么将会报java.lang.ArithmeticException错误。其他整形也是一样。

long后缀L。

• 16进制：前缀0x
• 8进制：前缀0

尽量不要使用8进制。

java没有任何无符号类型。unsigned type。

浮点型：

• float：4字节
• double：8字节

关于浮点数：

浮点数是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学计数法。

一个浮点数a由两个数m和e来表示：a = m × b^e。在任意一个这样的系统中，我们选择一个基数b（记数系统的基）和精度p（即使用多少位来存储）。m（即尾数）是形如±d.ddd...ddd的p位数（每一位是一个介于0到b-1之间的整数，包括0和b-1)。如果m的第一位是非0整数,m称作规格化的。有一些描述使用一个单独的符号位(s 代表+或者-）来表示正负，这样m必须是正的。e是指数。

结构

由此可以看出，在计算机中表示一个浮点数，其结构如下：

尾数部分（定点小数）

 阶码部分（定点整数）

int是精确的，一个n位的精确存储只能存储2的n次方，因为有正负和0，所以int的取值范围是负2的n次方到2的n次方-1。

float的取值范围是3.4028235E38，有效数字6-7位，以F结尾，double的取值范围是1.7976931348623157E308，有效数字15位，以D结尾。

float是不精确的，所以有有效数字的概念，如float有32位，其实是和int是一样的。int的最大值是2147483647，从十进制来讲，只有10位，float的位数中，一部分要用来定义阶码部分，留给表示位数部分的位数就减少了，划算成10进制，那么能存储的有效数字也就6-7位。如果超过有效位数，那么就不精确了。如123456789123456789和123456789120000000用float来存储，在其实都是123456789120000000f，也就是说超过6-7位精度的部分丢失了。如下：

1. System.out.println(123456789123456789f);
2. System.out.println(123456789120000000f);

结果：

1.23456791E17

1.23456791E17

具体分析，来自网上：

一个float4字节32位，分为三部分：符号位，指数位，尾数位。
(1).符号位(S)：最高位（31位）为符号位，表示整个浮点数的正负，0为正，1为负；
(2).指数位(E)：23-30位共8位为指数位，这里指数的底数规定为2（取值范围：0~255）。这一部分的最终结果格式为：2E−127，即范围-127~128。另外，标准中，还规定了，当指数位8位全0或全1的时候，浮点数为非正规形式（这个时候尾数不一样了），所以指数位真正范围为：-126~127。
(3).尾数位(M)：0-22位共23位为尾数位，表示小数部分的尾数，即形式为1.M或0.M，至于什么时候是1，什么时候是0，则由指数和尾数共同决定。 小数部分最高有效位是1的数被称为正规（规格化）形式。小数部分最高有效位是0的数被称为非正规（非规格化）形式，其他情况是特殊值。 最终float的值 = (−1)S∗(2E−127)∗(1.M)。

float的尾数：23位，其范围为：0~223，而223=8388608=106.92，所以float的精度为6~7位，能保证6位为绝对精确，7位一般也是正确的，8位就不一定了（但不是说8位就绝对不对了），注意这里的6~7位是有效小数位（大的数你先需要转换成小数的指数形式，例如：8317637.5，其有效小数位：8.3176375E6，七位），而有效位（从第一个不为0的开始数）是7~8位，是包括整数位的，像8317637.5，你不转换，则要从有效位的角度来看，有8位有效位。 

因为float只有6-7位有效数字，假如说咱们考虑为7位，所以平时使用的时候，应该是9999999这个大小内是有效的，大约999万，如果要有两位小数的话，那么就是99999.99,就只有10万了。

一旦超过了这个范围，就要开始损失了，损失从右侧开始的，右侧的数字慢慢变成了0.如12345678.92就变成了12345679.00。

double的精度是15位，对应所有的非精确运算一般都够了。

浮点型计算

浮点数的运算和整形差别很大，有一些特殊的逻辑。

浮点数有三种特殊的值，对于float来说有：

• Float.POSITIVE_INFINITY：正无穷大
• Float.NEGATIVE_INFINITY：负无穷大
• Float.NaN：非数字

除数为0，结果为无穷大。

0f/0f，或者负数的平方根结果为NaN。

溢出：超过Float.MAX_VALUE太多，就变成了Float.POSITIVE_INFINITY，小于Float.MIN_VALUE太多，就变成了Float.NEGATIVE_INFINITY。这里说太多，是因为溢出不太多的话，float是识别不到的，得到的结果还是Float.MAX_VALUE。如下：

1. package com.zjf;
2.  
3. public class Test {
4.  
5.    public static void main(String[] args) {
6.       System.out.println(Float.MAX_VALUE);
7.       System.out.println(Float.MAX_VALUE + 10000);
8.       System.out.println(Float.MAX_VALUE * 2);
9.       System.out.println((double)Float.MAX_VALUE * 2);
10.       System.out.println(Float.MAX_VALUE * 2D);
11.       System.out.println(Float.POSITIVE_INFINITY);
12.       System.out.println(Float.NEGATIVE_INFINITY);
13.       System.out.println(0f/0f);
14.       System.out.println(10f/0f);
15.    }
16. }

结果如下：

3.4028235E38

3.4028235E38

Infinity

6.805646932770577E38

6.805646932770577E38

Infinity

-Infinity

NaN

Infinity

 

boolean类型

java的布尔值和整型值之间不能做转换。也就是说0不代表false。这点和c++不一样，和JavaScript也不一样。

运算符

+ - * / %(求余)

在进行这些操作的时候，两个都是整形的话代表整数操作，结果也是整数，否是是浮点数。

ps：可移植性是java语言的设计目标之一。但是java的浮点运算在不同的处理器上的的结算结果是有差别的（特别是intel和非intel处理器之间的差别）。

java的逻辑运算符&&和||是按照"短路"方式求值的。

强制转换

整数可以强制装换为浮点数，但是可能会损失精度，但是在有效数字范围内的部分还是准确的。

浮点数可以强制装换为整数，是采用的直接截断的方式。不是四舍五入。

浮点数可以强制装换为整数，如果超过了整数的取值范围，那么结果是不可预知的。

1. package com.zjf;
2.  
3. public class Test {
4.  
5.    public static void main(String[] args) {
6.  
7.       float f = 1234567891234.23F;
8.       int i = (int)f;
9.       long l = (long)f;
10.       System.out.println(i);
11.       System.out.println(l);
12.    }
13. }

结果：

2147483647

1234567954432

事实上，不只是浮点型和整形的转换，java中数值的转换，如果转换的结果超过了接收方的取值范围，就可能得到一个完全不同的值。