1.30号Java复习题目——Java的基本数据类型和包装类（基础知识整理）

1. 基本数据类型

Java 基本数据按类型可以分为四大类：布尔型、整数型、浮点型、字符型，这四大类包含 8 种基本数据类型。

• 布尔型：boolean
• 整数型：byte、short、int、long
• 浮点型：float、double
• 字符型：char

8 种基本类型取值如下（了解查看即可）：

数据类型	代表含义	默认值	取值	包装类
boolean	布尔型	false	0(false) 到 1(true)	Boolean
byte	字节型	(byte)0	﹣128 到 127	Byte
char	字符型	'\u0000'(空)	'\u0000' 到 '\uFFFF'	Character
short	短整数型	(short)0	-${\mathrm{215215 到 215215-1}}^{}$	Short
int	整数型	0	﹣${\mathrm{231231 到 231231-1}}^{}$	Integer
long	长整数型	0L	﹣${\mathrm{263263 到 263263-1}}^{}$	Long
float	单浮点型	0.0f	1.4e-45 到 3.4e+38	Float
double	双浮点型	0.0d	4.9e-324 到 1.798e+308	Double

记忆：除 char 的包装类 Character 和 int 的包装类 Integer 之外，其他基本数据类型的包装类只需要首字母大写即可。

可以通过代码，查看某种类型的取值范围，代码如下：

1 public static void main(String[] args) {
2     // Byte 取值：-128 ~ 127
3     System.out.println(String.format("Byte 取值：%d ~ %d", Byte.MIN_VALUE, Byte.MAX_VALUE));
4     // Int 取值：-2147483648 ~ 2147483647
5     System.out.println(String.format("Int 取值：%d ~ %d", Integer.MIN_VALUE, Integer.MAX_VALUE));
6 }

 

2. 包装类型（***注意一下***）

8 种基本数据类型都有其对应的包装类，因为 Java 的设计思想是万物既对象，有很多时候我们需要以对象的形式操作某项功能，比如说获取哈希值（hashCode）或获取类（getClass）等。

那包装类特性有哪些？

1. 功能丰富：包装类本质上是一个对象，对象就包含有属性和方法，比如 hashCode、getClass 、max、min 等。

2. 可定义泛型类型参数：包装类可以定义泛型，而基本类型不行。比如使用 Integer 定义泛型

1 List list = new ArrayList<>();

如果使用 int 定义就会报错

List list = new ArrayList<>();  // 编译器代码报错

3. 序列化

因为包装类都实现了 Serializable 接口，所以包装类天然支持序列化和反序列化。比如 Integer 的类图如下：

4. 类型转换

包装类提供了类型转换的方法，可以很方便的实现类型之间的转换，比如 Integer 类型转换

1 String age = "18";
2 int ageInt = Integer.parseInt(age) + 2;
3 // 输出结果：20
4 System.out.println(ageInt);

 

5. 高频区间的数据缓存

此特性为包装类很重要的用途之一，用于高频区间的数据缓存，以 Integer 为例来说，在数值区间为 -128~127 时，会直接复用已有对象，在这区间之外的数字才会在堆上产生。

我们使用 == 对 Integer 进行验证，代码如下：

 1 public static void main(String[] args) {
 2         // Integer 高频区缓存范围 -128~127
 3         Integer num1 = 127;
 4         Integer num2 = 127;
 5         // Integer 取值 127 == 结果为 true（值127 num1==num2 => true）
 6         System.out.println("值127 num1==num2 => " + (num1 == num2));
 7         Integer num3 = 128;
 8         Integer num4 = 128;
 9         // Integer 取值 128 == 结果为 false（值128 num3==num4 => false）
10         System.out.println("值128 num3==num4 => " + (num3 == num4));
11     }

从上面的代码很明显可以看出，Integer 为 127 时复用了已有对象，当值为 128 时，重新在堆上生成了新对象。

为什么会产生高频区域数据缓存？我们查看源码就能发现“线索”，源码版本 JDK8，源码如下：

1 public static Integer valueOf(int i) {
2   if (i >= IntegerCache.low && i <= IntegerCache.high)
3     return IntegerCache.cache[i + (-IntegerCache.low)];
4   return new Integer(i);
5 }

 

由此可见，高频区域的数值会直接使用已有对象，非高频区域的数值会重新 new 一个新的对象。

 

各包装类高频区域的取值范围（了解一下）：

• Boolean：使用静态 final 定义，就会返回静态值
• Byte：缓存区 -128~127
• Short：缓存区 -128~127
• Character：缓存区 0~127
• Long：缓存区 -128~127
• Integer：缓存区 -128~127

 

2.1 包装类的注意事项（***注意一下***）

• int 的默认值是 0，而 Integer 的默认值是 null。

• 推荐所有包装类对象之间的值比较使用 equals() 方法，因为包装类的非高频区数据会在堆上产生，而高频区又会复用已有对象，这样会导致同样的代码，因为取值的不同，而产生两种截然不同的结果。代码示例：

 1 public static void main(String[] args) {
 2     // Integer 高频区缓存范围 -128~127
 3     Integer num1 = 127;
 4     Integer num2 = 127;
 5     // Integer 取值 127 == 结果为 true（值127 num1==num2 => true）
 6     System.out.println("值127 num1==num2 => " + (num1 == num2));
 7     Integer num3 = 128;
 8     Integer num4 = 128;
 9     // Integer 取值 128 == 结果为 false（值128 num3==num4 => false）
10     System.out.println("值128 num3==num4 => " + (num3 == num4));
11     // Integer 取值 128 equals 结果为 true（值128 num3.equals(num4) => true）
12     System.out.println("值128 num3.equals(num4) => " + num3.equals(num4));
13 }

• Float 和 Double 不会有缓存，其他包装类都有缓存。

• Integer 是唯一一个可以修改缓存范围的包装类，在 VM optons 加入参数：

-XX:AutoBoxCacheMax=666 即修改缓存最大值为 666 。

示例代码如下：

 1 public static void main(String[] args) {
 2     Integer num1 = -128;
 3     Integer num2 = -128;
 4     System.out.println("值为-128 => " + (num1 == num2));
 5     Integer num3 = 666;
 6     Integer num4 = 666;
 7     System.out.println("值为666 => " + (num3 == num4));
 8     Integer num5 = 667;
 9     Integer num6 = 667;
10     System.out.println("值为667 => " + (num5 == num6));
11 }

 

执行结果如下：

值为-128 => true
值为666 => true
值为667 => false 

由此可见将 Integer 最大缓存修改为 666 之后，667 不会被缓存，而 -128~666 之间的数都被缓存了。