标签：OLE eof min 机制 range -128 重复 计算 class
java是一种强类型语言，这就意味着必须为每一个声明变量声明一种类型。在java中，一共有8种数据类型，其中4种整型，2种浮点类型，1种字符类型和一种表示真值的boolean类型。
整型用于表示没有小数部分的整数部分，java提供了4中整型，如下表所示：
| 类 型 | 存储大小 | 取值范围 |
|---|---|---|
| int | 4字节 | -2^31 ~ 2^31 - 1 |
| short | 2字节 | -2^15 ~ 2^15 - 1 |
| long | 8字节 | -2^63 ~ 2^63 - 1 |
| byte | 1字节 | -2^7 ~ 2^7 - 1 |
但是java是一门面向对象的语言，所以对于基本类型java也有其包装类型：Integer,Short,Long,Byte.
为了使基本数据类型灵活转变，java采用了自动装箱与自动拆箱。如下所示：
Integer i = 9; // 装箱
int a = i; // 拆箱装箱就是自动把基本类型转化为包装器类型，拆箱就是自动把包装器类型转化为基本数据类型。
那么java是怎么实现自动装箱和自动拆箱的呢？我们反编译一下：
public static void main(java.lang.String[]);
Code:
0: bipush 9
2: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
6: aload_1
7: invokevirtual #3 // Method java/lang/Integer.intValue:()I
10: istore_2
11: return从反编译的指令中可以看出自动装箱是调用了valueof方法，而拆箱是调用了intValue方法，本着探究的精神再来看看源码：
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high) // 判断是否在Integer缓存区内
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}显然这里返回了new Integer(i),但是前面进行一个判断，我们再接着去看IntegerCache类：
private static class IntegerCache {
static final int low = -128; // 缓存区左闭区间
static final int high; // 缓存区右闭区间
static final Integer cache[]; // 缓存数组
static {
// high value may be configured by property
// 翻译一下，就是high的值可以由属性或者参数配置
int h = 127; // 默认是 127
// 下面就是检测是否修改了high的配置
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
// 如果未修改，直接赋值
high = h;
// 将区间[-128，127]的数值存入缓存数据
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
看过源码我们知道装箱的原理，也了解到Integer里的缓存机制，所以推出一个常见的题目，那就是Integer大小的比较：
for (int i = -200; i <= 200; i++){
Integer a = i;
Integer b = i;
System.out.println("a = " + a + ", b = " + b + ", a == b: " + (a == b));
}答案也很显然了，相信你早就知道了,就是在区间[-128, 127]的值比较都为true，其他都为false。当然只有在装箱情况下的比较才会这样，其他的如:
int a = 1, int b = 1或者Integer a = new Integer(1), Integer b = new Integer(1)都遵循一般情况分别为true和false;所以，由此可以推出Long,
Character等也同理，但是这缓存机制对浮点类型并不适用，你想想从1.0缓存到2.0有多少个小数？无数个！那么为什么要采用缓存机制呢？既然是缓存，那大概是为了避免每次取数都要new一个对象，减少损耗。而且确实int类型使用最多，这样每次在使用时都是重复使用同一个对象。
为了实现“一次编译，到处运行”的理想，java整型的范围与运行java的机器是无关的，这就解决了软件从一个平台移植到另一个平台的诸多问题。不会出现软件在32位机器运行良好，而在16位机器运行就出现问题，所以每一种类型的取值范围都是固定的。
浮点类型表示有小数部分的数值，java有两种浮点类型，如下所示：
| 类 型 | 存储大小 | 取值范围 |
|---|---|---|
| float | 4字节 | 大约±3.40282346638528860e+38（有效数7位） |
| double | 8字节 | 大约 ±1.79769313486231570e+308 （有效数15位） |
（注：取值范围依据根据 IEEE 754 浮点“双精度格式”位布局，返回指定浮点值的表示形式，并保留 NaN 值。 第 63 位（掩码 0x8000000000000000L 选定的位）表示浮点数的符号。第 62-52 位（掩码 0x7ff0000000000000L 选定的位）表示指数。第 51-0 位（掩码 0x000fffffffffffffL 选定的位）表示浮点数的有效数字（有时也称为尾数））
0.8999999999999999那么为什么不是0.9呢？那是因为浮点数值用二进制表示，而二进制系统无法精确表示1/10。所以要进行精确运算时，最好使用BigDecimal类
public static void main(String[] args) {
BigDecimal a = new BigDecimal("2.0");
BigDecimal b = new BigDecimal("1.1");
System.out.println(a.subtract(b));
}结果
0.9标签：OLE eof min 机制 range -128 重复 计算 class
原文地址：https://www.cnblogs.com/curiousforcode/p/11964151.html
