数据类型

基本类型

概述

类型	关键字	大小(位)	范围	默认值	包装类
整数类型	byte	8	-128 ~ 127	0	Byte
整数类型	short	16	-32,768 ~ 32,767	0	Short
整数类型	int	32	-2³¹ ~ 2³¹-1	0	Integer
整数类型	long	64	-2⁶³ ~ 2⁶³-1	0L	Long
浮点类型	float	32	±3.4e-38 ~ ±3.4e+38	0.0f	Float
浮点类型	double	64	±1.7e-308 ~ ±1.7e+308	0.0d	Double
字符类型	char	16	'\u0000' ~ '\uffff'	'\u0000'	Character
布尔类型	boolean	1	true / false	false	Boolean

类型转换

自动转换 (隐式转换)

// 小类型转大类型：自动转换
byte b = 100;
int i = b;        // byte → int (自动)

short s = 1000;
long l = s;       // short → long (自动)

int num = 100;
double d = num;   // int → double (自动)

char c = 'A';
int ascii = c;    // char → int (自动)

强制转换 (显式转换)

// 大类型转小类型：需要强制转换
int largeNum = 300;
byte b = (byte) largeNum;  // 强制转换，可能丢失数据
System.out.println(b);      // 输出: 44 (溢出)

double d = 9.78;
int i = (int) d;           // 强制转换，小数部分被截断
System.out.println(i);      // 输出: 9

// 浮点转整数 - 小心丢失精度
float f = 123.456f;
int intValue = (int) f;     // 123

// 四舍五入的方法
int rounded = Math.round(f);  // 123

包装类型

概述

// 区别： // 1. 基本类型是值，包装类是对象 // 2. 基本类型更快，占用内存更少 // 3. 包装类可以有null值，基本类型不能 // 4. 集合只能存储对象，不能存储基本类型

自动装箱和拆箱

1. 什么是装箱和拆箱？

// 手动装箱：基本类型 → 包装对象
int primitive = 42;
Integer boxed = Integer.valueOf(primitive);  // 手动装箱

// 手动拆箱：包装对象 → 基本类型
Integer wrapper = Integer.valueOf(100);
int unboxed = wrapper.intValue();           // 手动拆箱

// 自动装箱 (Java 5+)
Integer autoBoxed = 42;  // 编译器自动执行：Integer.valueOf(42)

// 自动拆箱 (Java 5+)
Integer autoWrapper = 100;
int autoUnboxed = autoWrapper;  // 编译器自动执行：autoWrapper.intValue()

2. 自动装箱的内部机制

// 自动装箱实际上是调用了包装类的静态方法
Integer a = 100;  // 编译后：Integer a = Integer.valueOf(100);

// valueOf()方法有缓存机制（-128到127）
Integer x = 100;
Integer y = 100;
System.out.println(x == y);  // true - 使用缓存

Integer m = 200;
Integer n = 200;
System.out.println(m == n);  // false - 超出缓存范围，创建新对象

// 证明：查看valueOf源码
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

引用类型

引用类型分类

类型	关键字/示例	特点
类类型	String, Integer, 自定义类	使用class定义
接口类型	List, Runnable	使用interface定义
数组类型	int[], String[]	固定大小容器
枚举类型	enum	有限值集合
注解类型	@Override	元数据

关键特性

1. 默认值为null

String str;                    // 默认值为null
Integer number;                // 默认值为null
int[] array;                   // 默认值为null
Object obj;                    // 默认值为null

// 基本类型有默认值，引用类型没有
int primitive;                 // 默认值为0
Integer reference;             // 默认值为null

2. == 比较的是引用，不是内容

String s1 = new String("Hello");
String s2 = new String("Hello");
String s3 = s1;

System.out.println(s1 == s2);     // false - 不同对象
System.out.println(s1 == s3);     // true  - 同一个对象
System.out.println(s1.equals(s2)); // true  - 内容相同

// 字符串常量池特例
String a = "Hello";      // 放入常量池
String b = "Hello";      // 复用常量池中的字符串
System.out.println(a == b);  // true

3. 参数传递是"按引用值传递"

public class ReferenceDemo {
    public static void modifyString(String str) {
        str = "Modified";  // 不会影响原引用
    }

    public static void modifyArray(int[] arr) {
        arr[0] = 100;      // 会影响原数组内容
        arr = new int[]{0, 0, 0};  // 不会影响原引用
    }

    public static void main(String[] args) {
        String s = "Original";
        modifyString(s);
        System.out.println(s);  // "Original"

        int[] nums = {1, 2, 3};
        modifyArray(nums);
        System.out.println(nums[0]);  // 100
    }
}

4. 垃圾回收机制

// 当对象不再被引用时，会被垃圾回收器回收
Object obj1 = new Object();  // 创建对象1，有一个引用
Object obj2 = new Object();  // 创建对象2，有一个引用

obj1 = obj2;  // 对象1不再被引用，可以被回收
obj2 = null;  // 对象2不再被引用，可以被回收

// 循环引用也会被回收（现代JVM支持）
class Node {
    Node next;
}

Node a = new Node();
Node b = new Node();
a.next = b;
b.next = a;   // 循环引用
a = null;
b = null;     // 两个节点都可以被回收