基本类型

基本类型是编程语言提供的最简单的数据类型，它们不是对象。Java定义了以下八种基本类型：

基本类型	占用字节	范围	默认值	示例
byte	1	-128 到 127	0	`byte b = 100;`
short	2	-32,768 到 32,767	0	`short s = 10000;`
int	4	-2^31 到 2^31-1	0	`int i = 1000000;`
long	8	-2^63 到 2^63-1	0L	`long l = 10000000000L;`
float	4	大约 ±3.40282347E+38F	0.0F	`float f = 234.5F;`
double	8	大约 ±1.79769313486231570E+308	0.0	`double d = 123456789.678;`
char	2	'\u0000' 到 '\uffff'	'\u0000'	`char c = 'A';`
boolean	JVM 实现依赖，通常为一个字节	true 或 false	false	`boolean bool = true;`

封装类型

在Java中，除了基本数据类型（如int、double等），还有封装类型，它们是基本数据类型的对象版本，提供了额外的功能和方法，使得处理数据更加方便和灵活。

封装类型主要用于以下几种情况：

在需要对象的情况下使用基本数据类型：例如，在集合框架中，如ArrayList或HashMap，我们不能直接使用基本数据类型，而应该使用它们的封装类型。
提供有用的方法：封装类型提供了许多有用的方法，例如用于转换字符串和基本数据类型之间，比较值等。
支持null值：基本数据类型不能为null，但封装类型可以，这在某些情况下很有用。

以下是Java中基本数据类型及其对应的封装类型：

Integer (int)

构造器/方法/常量	描述
`Integer(int value)`	使用给定的 int 值创建一个 Integer 对象。
`Integer(String s)`	将字符串转换为整数。
`static int parseInt(String s)`	将字符串解析为整数值。
`static Integer valueOf(String s)`	返回保存指定值的 Integer 对象。
`int intValue()`	返回 Integer 的值作为 int 类型。
`String toString()`	返回表示该 Integer 值的字符串。
`byte byteValue()`	将 Integer 转换为 byte 类型。
`short shortValue()`	将 Integer 转换为 short 类型。
`long longValue()`	将 Integer 转换为 long 类型。
`float floatValue()`	将 Integer 转换为 float 类型。
`double doubleValue()`	将 Integer 转换为 double 类型。
`MAX_VALUE`	表示可能的最大值（2^31 - 1）。
`MIN_VALUE`	表示可能的最小值（-2^31）。
`SIZE`	表示此类型使用的基本位数（32 位）。
`TYPE`	表示对应的基本类型 `Class<Integer>`。

Long (long)

构造器/方法/常量	描述
`Long(long value)`	使用给定的 long 值创建一个 Long 对象。
`Long(String s)`	将字符串转换为长整数值。
`static long parseLong(String s)`	将字符串解析为长整数值。
`static Long valueOf(String s)`	返回保存指定值的 Long 对象。
`long longValue()`	返回 Long 的值作为 long 类型。
`String toString()`	返回表示该 Long 值的字符串。
`int intValue()`	将 Long 转换为 int 类型。
`float floatValue()`	将 Long 转换为 float 类型。
`double doubleValue()`	将 Long 转换为 double 类型。
`MAX_VALUE`	表示可能的最大值（2^63 - 1）。
`MIN_VALUE`	表示可能的最小值（-2^63）。
`SIZE`	表示此类型使用的基本位数（64 位）。
`TYPE`	表示对应的基本类型 `Class<Long>`。

Double (double)

构造器/方法/常量	描述
`Double(double value)`	使用给定的 double 值创建一个 Double 对象。
`Double(String s)`	将字符串转换为双精度浮点数值。
`static double parseDouble(String s)`	将字符串解析为双精度浮点数值。
`static Double valueOf(String s)`	返回保存指定值的 Double 对象。
`double doubleValue()`	返回 Double 的值作为 double 类型。
`String toString()`	返回表示该 Double 值的字符串。
`int intValue()`	将 Double 转换为 int 类型。
`long longValue()`	将 Double 转换为 long 类型。
`float floatValue()`	将 Double 转换为 float 类型。
`MAX_VALUE`	表示可能的最大值（约 1.7976931348623157E308）。
`MIN_VALUE`	表示可能的最小正值（约 4.9E-324）。
`NaN`	非数字值。
`POSITIVE_INFINITY`	正无穷大。
`NEGATIVE_INFINITY`	负无穷大。
`SIZE`	表示此类型使用的基本位数（64 位）。
`TYPE`	表示对应的基本类型 `Class<Double>`。

Float (float)

构造器/方法/常量	描述
`Float(float value)`	使用给定的 float 值创建一个 Float 对象。
`Float(String s)`	将字符串转换为单精度浮点数值。
`static float parseFloat(String s)`	将字符串解析为单精度浮点数值。
`static Float valueOf(String s)`	返回保存指定值的 Float 对象。
`float floatValue()`	返回 Float 的值作为 float 类型。
`String toString()`	返回表示该 Float 值的字符串。
`int intValue()`	将 Float 转换为 int 类型。
`long longValue()`	将 Float 转换为 long 类型。
`double doubleValue()`	将 Float 转换为 double 类型。
`MAX_VALUE`	表示可能的最大值（约 3.4028235E38）。
`MIN_VALUE`	表示可能的最小正值（约 1.4E-45）。
`NaN`	非数字值。
`POSITIVE_INFINITY`	正无穷大。
`NEGATIVE_INFINITY`	负无穷大。
`SIZE`	表示此类型使用的基本位数（32 位）。
`TYPE`	表示对应的基本类型 `Class<Float>`。

Boolean (boolean)

构造器/方法/常量	描述
`Boolean(boolean value)`	使用给定的 boolean 值创建一个 Boolean 对象。
`Boolean(String s)`	将字符串转换为布尔值。
`static boolean parseBoolean(String s)`	将字符串解析为布尔值。
`boolean booleanValue()`	返回 Boolean 的值作为 boolean 类型。
`String toString()`	返回表示该 Boolean 值的字符串。
`TRUE`	表示 true 布尔值的对象。
`FALSE`	表示 false 布尔值的对象。
`TYPE`	表示对应的基本类型 `Class<Boolean>`。

Character (char)

构造器/方法/常量	描述
`Character(char value)`	使用给定的 char 值创建一个 Character 对象。
`char charValue()`	返回 Character 的值作为 char 类型。
`String toString()`	返回表示该 Character 值的字符串。
`static boolean isDigit(char ch)`	检查字符是否为数字。
`static boolean isLetter(char ch)`	检查字符是否为字母。
`static boolean isWhitespace(char ch)`	检查字符是否为空白字符。
`static boolean isUpperCase(char ch)`	检查字符是否为大写字母。
`static boolean isLowerCase(char ch)`	检查字符是否为小写字母。
`MIN_VALUE`	表示可能的最小值 (`'\u0000'`)。
`MAX_VALUE`	表示可能的最大值 (`'\uffff'`)。
`TYPE`	表示对应的基本类型 `Class<Character>`。

Byte (byte)

构造器/方法/常量	描述
`Byte(byte value)`	使用给定的 byte 值创建一个 Byte 对象。
`Byte(String s)`	将字符串转换为字节值。
`static byte parseByte(String s)`	将字符串解析为字节值。
`static Byte valueOf(String s)`	返回保存指定值的 Byte 对象。
`byte byteValue()`	返回 Byte 的值作为 byte 类型。
`String toString()`	返回表示该 Byte 值的字符串。
`int intValue()`	将 Byte 转换为 int 类型。
`long longValue()`	将 Byte 转换为 long 类型。
`float floatValue()`	将 Byte 转换为 float 类型。
`double doubleValue()`	将 Byte 转换为 double 类型。
`MAX_VALUE`	表示可能的最大值（127）。
`MIN_VALUE`	表示可能的最小值（-128）。
`SIZE`	表示此类型使用的基本位数（8 位）。
`TYPE`	表示对应的基本类型 `Class<Byte>`。

Short (short)

构造器/方法/常量	描述
`Short(short value)`	使用给定的 short 值创建一个 Short 对象。
`Short(String s)`	将字符串转换为短整数值。
`static short parseShort(String s)`	将字符串解析为短整数值。
`static Short valueOf(String s)`	返回保存指定值的 Short 对象。
`short shortValue()`	返回 Short 的值作为 short 类型。
`String toString()`	返回表示该 Short 值的字符串。
`int intValue()`	将 Short 转换为 int 类型。
`long longValue()`	将 Short 转换为 long 类型。
`float floatValue()`	将 Short 转换为 float 类型。
`double doubleValue()`	将 Short 转换为 double 类型。
`MAX_VALUE`	表示可能的最大值（32,767）。
`MIN_VALUE`	表示可能的最小值（-32,768）。
`SIZE`	表示此类型使用的基本位数（16 位）。
`TYPE`	表示对应的基本类型 `Class<Short>`。

自动装/拆箱

从Java 5开始，Java提供了自动装箱（autoboxing）和拆箱（unboxing）的功能，这使得基本数据类型和封装类型之间的转换更加方便。

自动装箱

自动装箱是指编译器自动将基本数据类型转换为对应的封装类型对象。这个过程无需程序员手动编写代码进行转换。

java

Integer i = 100; // 自动装箱
// 这行代码在编译时会被转换为：
Integer i = Integer.valueOf(100);

在这个例子中，数字100是一个基本数据类型int，但是它被自动装箱成了一个Integer对象。

自动拆箱

自动拆箱是指编译器自动将封装类型对象转换为其对应的基本数据类型。

java

Integer i = 100; // 自动装箱
int n = i; // 自动拆箱
// 这行代码在编译时会被转换为：
int n = i.intValue();

在这个例子中，Integer对象i被自动拆箱成了一个基本数据类型int。

注意事项

性能影响：装箱和拆箱操作虽然方便，但它们涉及到对象的创建和销毁，因此在性能敏感的场合，频繁的装箱和拆箱可能会导致性能问题。
缓存对象：Java为部分封装类型（如Integer）实现了缓存机制。例如，Integer类内部有一个缓存范围，通常是-128到127，这个范围内的整数会被缓存，装箱时不会创建新的对象。
null值问题：基本数据类型不能为null，但封装类型可以为null。在进行自动拆箱时，如果封装类型对象为null，则会抛出NullPointerException。
java
```
Integer i = null;
int n = i; // 这行代码会抛出NullPointerException
```
类型兼容性：自动装箱和拆箱只适用于对应的基本数据类型和封装类型之间。例如，不能将int自动装箱成Double。

基本与封装类型的区别

类型与存储

在Java中，基本类型是值类型，这意味着它们直接存储数值。例如，当我们声明一个int类型的变量时，它直接在栈上分配内存并存储整数值。

java

int number = 10; // 直接在栈上存储值

相反，封装类型是引用类型，它们存储的是对象的引用。例如，当我们创建一个Integer对象时，对象本身存储在堆上，而变量存储的是指向该对象的引用。

java

Integer number = new Integer(10); // 对象在堆上，引用在栈上

默认值

基本类型有固定的默认值。例如，int类型的默认值是0，boolean类型的默认值是false。封装类型的默认值是null，这表示它们没有引用任何对象。

方法支持

基本类型不提供任何方法，因为它们不是对象。而封装类型提供了丰富的静态方法和实例方法来操作数据。例如，Integer类提供了parseInt(String s)和toString(int i)等方法。

java

int parsed = Integer.parseInt("123"); // 将字符串转换为整数
String str = Integer.toString(123);   // 将整数转换为字符串

集合框架

Java的集合框架（如List, Set, Map等）只能存储对象，不能直接存储基本类型。因此，封装类型允许我们将基本类型放入集合中。

java

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);

空值支持

基本类型不能为null，它们总是有具体的值。封装类型可以为null，这在表示可选值或空值时非常有用。

java

Integer age = null; // 表示年龄未知

性能

基本类型通常在性能上优于封装类型，因为它们操作起来更简单，占用的内存更少。封装类型由于是对象，其操作可能涉及更多的内存和时间开销。

线程安全

基本类型通常是线程安全的，因为每个线程有自己的栈空间。某些封装类，如AtomicInteger和AtomicLong，提供了线程安全的方法，适用于并发编程。

扩展性

基本类型无法继承或实现接口。虽然大多数封装类是final的，不允许继承，但可以通过组合或其他设计模式来扩展功能。

基本类型 ​

封装类型 ​

Integer (int) ​

Long (long) ​

Double (double) ​

Float (float) ​

Boolean (boolean) ​

Character (char) ​

Byte (byte) ​

Short (short) ​

自动装/拆箱 ​

自动装箱 ​

自动拆箱 ​

注意事项 ​

基本与封装类型的区别 ​

类型与存储 ​

默认值 ​

方法支持 ​

集合框架 ​

空值支持 ​

性能 ​

线程安全 ​

扩展性 ​

基本类型

封装类型

Integer (int)

Long (long)

Double (double)

Float (float)

Boolean (boolean)

Character (char)

Byte (byte)

Short (short)

自动装/拆箱

自动装箱

自动拆箱

注意事项

基本与封装类型的区别

类型与存储

默认值

方法支持

集合框架

空值支持

性能

线程安全

扩展性