【Java基础整理】基本数据类型及转换

Java基本数据类型及转换

摘要

Java是强类型语言，为每种数据定义了明确的数据类型和内存分配。本文详细介绍Java的基本数据类型、引用数据类型、类型转换机制以及包装类的使用方法和转换规则。

Java数据类型概述

Java是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

数据类型分类

arduino 复制代码

Java数据类型
├── 基本数据类型（8种）
│   ├── 数值型
│   │   ├── 整数类型（byte、short、int、long）
│   │   └── 浮点类型（float、double）
│   ├── 字符型（char）
│   └── 布尔型（boolean）
└── 引用数据类型
    ├── 类（class）
    ├── 接口（interface）
    └── 数组（[]）

基本数据类型

1. 数值型

1.1 整数类型

类型	字节数	位数	取值范围	默认值
`byte`	1字节	8位	-128 ~ 127	0
`short`	2字节	16位	-32,768 ~ 32,767	0
`int`	4字节	32位	-2,147,483,648 ~ 2,147,483,647	0
`long`	8字节	64位	-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807	0L

示例：

java 复制代码

byte b = 127;
short s = 32767;
int i = 2147483647;
long l = 9223372036854775807L;  // long类型需要加L后缀

1.2 浮点类型

类型	字节数	位数	精度	取值范围（大约）	默认值
`float`	4字节	32位	7位小数	±3.4E-38 ~ ±3.4E+38	0.0f
`double`	8字节	64位	15位小数	±1.7E-308 ~ ±1.7E+308	0.0d

示例：

java 复制代码

float f = 3.14f;     // float类型需要加f后缀
double d = 3.14159;  // double类型可以不加后缀

默认类型：

整数默认类型：int
小数默认类型：double

2. 字符型（char）

大小：2字节（16位）
用途：代表一个Unicode字符
取值范围：0 ~ 65,535
默认值 ：\u0000

java 复制代码

char c1 = 'A';        // 字符字面量
char c2 = 65;         // ASCII值
char c3 = '\u0041';   // Unicode编码

3. 布尔型（boolean）

取值：true 或 false
默认值 ：false
注意：Java中boolean不能与数字相互转换

java 复制代码

boolean flag1 = true;
boolean flag2 = false;
boolean result = (10 > 5);  // 条件表达式结果

引用数据类型

引用类型分类

类（class）

java 复制代码

String str = "Hello";
Scanner scanner = new Scanner(System.in);

接口（interface）

java 复制代码

List<String> list = new ArrayList<>();
Map<String, Object> map = new HashMap<>();

数组（[]）

java 复制代码

int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[10];

基本类型 vs 引用类型

特性	基本数据类型	引用数据类型
存储位置	栈内存	堆内存（引用在栈）
默认值	有具体默认值	null
比较方式	直接用 `==`	用 `equals()` 方法
传递方式	值传递	引用传递

基本数据类型转换

1. 自动类型转换（隐式转换）

定义

不需要书写代码，由JVM自动完成的类型转换。将存储范围小的类型 转换为存储范围大的类型。

转换规则

csharp 复制代码

byte → short(char) → int → long → float → double

自动转换示例

java 复制代码

// ✅ 正确：小类型自动转换为大类型
byte b = 1;
int n = b;        // byte 自动转换为 int
long l = n;       // int 自动转换为 long
float f = l;      // long 自动转换为 float
double d = f;     // float 自动转换为 double

// 运算时的自动转换
byte b1 = 10;
byte b2 = 20;
int result = b1 + b2;  // byte运算结果自动提升为int

注意事项

java 复制代码

int n = 1;
byte b = 2;
// b = n + b;  // ❌ 编译错误！int不能自动转换为byte

// 正确做法：使用强制转换
b = (byte)(n + b);  // ✅ 强制转换

2. 强制类型转换（显式转换）

定义

必须书写代码才能完成的类型转换。将存储范围大的类型 转换为存储范围小的类型，可能会出现精度损失。

转换规则

csharp 复制代码

double → float → long → int → short(char) → byte

语法格式

java 复制代码

(目标类型) 需要转换的值;

强制转换示例

java 复制代码

// 基本强制转换
double d = 3.14;
float f = (float) d;    // double → float
int i = (int) f;        // float → int (小数部分丢失)
byte b = (byte) i;      // int → byte

// 可能的精度损失
int bigInt = 300;
byte smallByte = (byte) bigInt;  // 结果: 44 (300 - 256 = 44)

// 浮点数截断
double pi = 3.14159;
int intPi = (int) pi;   // 结果: 3 (小数部分被截断)

强制转换注意事项

java 复制代码

// ⚠️ 数据溢出示例
int maxValue = Integer.MAX_VALUE;  // 2147483647
int overflow = maxValue + 1;       // 结果: -2147483648 (溢出)

// ⚠️ 精度损失示例  
float precision = 123456789.0f;
int lost = (int) precision;        // 可能丢失精度

包装类

定义

Java为8个基本数据类型分别定义了对应的包装类，提供更多的操作方法。

基本类型与包装类对应关系

基本类型	包装类	继承关系
`byte`	`Byte`	extends Number
`short`	`Short`	extends Number
`int`	`Integer`	extends Number
`long`	`Long`	extends Number
`float`	`Float`	extends Number
`double`	`Double`	extends Number
`char`	`Character`	extends Object
`boolean`	`Boolean`	extends Object

自动装箱和拆箱（JDK 1.5+）

自动装箱（基本类型 → 包装类）

java 复制代码

// 自动装箱
Integer i = 10;        // 等价于 Integer i = Integer.valueOf(10);
Double d = 3.14;       // 等价于 Double d = Double.valueOf(3.14);
Boolean b = true;      // 等价于 Boolean b = Boolean.valueOf(true);

自动拆箱（包装类 → 基本类型）

java 复制代码

// 自动拆箱
Integer wrapper = 100;
int primitive = wrapper;    // 等价于 int primitive = wrapper.intValue();

// 运算时的自动拆箱
Integer a = 10;
Integer b = 20;
int sum = a + b;       // 自动拆箱后运算

Integer类详解

构造方法

java 复制代码

Integer i1 = new Integer(10);       // 通过int值构造
Integer i2 = new Integer("20");     // 通过String构造

转换方法

java 复制代码

Integer num = 100;

// 转换为其他基本类型
int i = num.intValue();
byte b = num.byteValue();
short s = num.shortValue();
long l = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();
String str = num.toString();

静态工具方法

java 复制代码

// String → int
int value1 = Integer.parseInt("123");
int value2 = Integer.parseInt("1010", 2);    // 二进制转十进制

// int → String
String str1 = Integer.toString(123);
String str2 = Integer.toString(123, 8);      // 转为八进制字符串

// int → Integer
Integer obj1 = Integer.valueOf(123);
Integer obj2 = Integer.valueOf("123");
Integer obj3 = Integer.valueOf("FF", 16);    // 十六进制转Integer

// 进制转换
String binary = Integer.toBinaryString(255);    // "11111111"
String octal = Integer.toOctalString(255);      // "377"  
String hex = Integer.toHexString(255);          // "ff"

其他包装类（Byte、Short、Long、Float、Double、Boolean）

通用方法模式

以 Xxx 代表任意包装类（除Character外）：

构造方法

java 复制代码

new Xxx(xxx value);     // 通过基本类型构造
new Xxx(String s);      // 通过字符串构造

实例方法

java 复制代码

xxx.byteValue();        // 转为byte
xxx.intValue();         // 转为int
xxx.shortValue();       // 转为short
xxx.longValue();        // 转为long
xxx.floatValue();       // 转为float
xxx.doubleValue();      // 转为double
xxx.toString();         // 转为String

静态工具方法

java 复制代码

Xxx.parseXxx(String s);                    // String → 基本类型
Xxx.parseXxx(String s, int radix);         // 指定进制转换
Xxx.toString(xxx value);                   // 基本类型 → String
Xxx.valueOf(xxx value);                    // 基本类型 → 包装类
Xxx.valueOf(String s);                     // String → 包装类
Xxx.valueOf(String s, int radix);          // 指定进制转换

具体示例

java 复制代码

// Long类示例
Long longObj = 123456789L;
long primitive = longObj.longValue();
String longStr = Long.toString(123456789L);
long parsed = Long.parseLong("123456789");

// Double类示例
Double doubleObj = 3.14159;
double primitive = doubleObj.doubleValue();
String doubleStr = Double.toString(3.14159);
double parsed = Double.parseDouble("3.14159");

// Float类示例（有十六进制转换方法）
String hexFloat = Float.toHexString(3.14f);

Character类

Character类的方法与其他包装类有所不同：

构造方法

java 复制代码

Character ch = new Character('A');

实例方法

java 复制代码

Character ch = 'A';
char primitive = ch.charValue();    // Character → char
String str = ch.toString();         // Character → String

静态工具方法

java 复制代码

// 转换方法
String str = Character.toString('A');           // char → String
Character obj = Character.valueOf('A');         // char → Character

// 字符判断和转换
char lower = Character.toLowerCase('A');        // 转小写: 'a'
char upper = Character.toUpperCase('a');        // 转大写: 'A'
boolean isDigit = Character.isDigit('5');       // 是否为数字
boolean isLetter = Character.isLetter('A');     // 是否为字母
boolean isUpperCase = Character.isUpperCase('A'); // 是否为大写字母
boolean isLowerCase = Character.isLowerCase('a'); // 是否为小写字母

Boolean类

java 复制代码

// 构造和转换
Boolean bool = new Boolean(true);
Boolean bool2 = Boolean.valueOf("true");
boolean primitive = bool.booleanValue();

// 字符串解析
boolean value1 = Boolean.parseBoolean("true");   // true
boolean value2 = Boolean.parseBoolean("TRUE");   // true  
boolean value3 = Boolean.parseBoolean("yes");    // false（只有"true"返回true）

数据类型转换总结

1. 基本类型 ↔ 包装类

基本类型 → 包装类（装箱）

java 复制代码

// 方法1：构造器（不推荐，JDK 9后过时）
Integer i1 = new Integer(10);

// 方法2：valueOf()方法（推荐）
Integer i2 = Integer.valueOf(10);

// 方法3：自动装箱（JDK 1.5+，推荐）
Integer i3 = 10;

包装类 → 基本类型（拆箱）

java 复制代码

Integer wrapper = 100;

// 方法1：xxxValue()方法
int primitive1 = wrapper.intValue();

// 方法2：自动拆箱（JDK 1.5+，推荐）
int primitive2 = wrapper;

2. 包装类 ↔ 其他基本类型

java 复制代码

Integer num = 100;

// 包装类转换为其他基本类型
byte b = num.byteValue();
short s = num.shortValue();
long l = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();

3. 字符串 ↔ 包装类

String → 包装类

java 复制代码

// ⚠️ 注意：可能抛出NumberFormatException
// 参数值必须在对应基本类型的范围内

// 方法1：构造器
Integer i1 = new Integer("123");
Boolean b1 = new Boolean("true");

// 方法2：valueOf()方法（推荐）
Integer i2 = Integer.valueOf("123");
Double d2 = Double.valueOf("3.14");
Boolean b2 = Boolean.valueOf("false");

包装类 → String

java 复制代码

Integer num = 123;
Double pi = 3.14159;

// 实例方法toString()
String str1 = num.toString();
String str2 = pi.toString();

// 静态方法toString()
String str3 = Integer.toString(123);
String str4 = Double.toString(3.14159);

4. 字符串 ↔ 基本类型

String → 基本类型

java 复制代码

// 使用包装类的parseXxx方法
int i = Integer.parseInt("123");
double d = Double.parseDouble("3.14");
boolean b = Boolean.parseBoolean("true");
byte bt = Byte.parseByte("127");
long l = Long.parseLong("123456789");

// 指定进制转换
int binary = Integer.parseInt("1010", 2);      // 二进制转十进制
int hex = Integer.parseInt("FF", 16);          // 十六进制转十进制

基本类型 → String

java 复制代码

// 方法1：使用包装类的toString()方法
String str1 = Integer.toString(123);
String str2 = Double.toString(3.14);

// 方法2：使用String.valueOf()方法
String str3 = String.valueOf(123);
String str4 = String.valueOf(3.14);
String str5 = String.valueOf(true);

// 方法3：字符串连接（不推荐，性能较差）
String str6 = 123 + "";

String → char

java 复制代码

// 使用String的charAt()方法
String text = "Hello";
char firstChar = text.charAt(0);     // 'H'
char lastChar = text.charAt(text.length() - 1);  // 'o'

转换异常处理

java 复制代码

public class TypeConversionExample {
    public static void main(String[] args) {
        // 安全的类型转换
        try {
            int num = Integer.parseInt("123");
            System.out.println("转换成功: " + num);
        } catch (NumberFormatException e) {
            System.err.println("数字格式错误: " + e.getMessage());
        }
        
        // 检查转换范围
        try {
            byte b = Byte.parseByte("200");  // 超出byte范围(-128~127)
        } catch (NumberFormatException e) {
            System.err.println("数值超出byte范围: " + e.getMessage());
        }
        
        // 布尔值转换（不区分大小写）
        boolean b1 = Boolean.parseBoolean("True");   // true
        boolean b2 = Boolean.parseBoolean("FALSE");  // false
        boolean b3 = Boolean.parseBoolean("yes");    // false（只有"true"返回true）
    }
}

实用工具方法

1. 进制转换工具

java 复制代码

public class NumberConversion {
    public static void convertNumber(int number) {
        System.out.println("十进制: " + number);
        System.out.println("二进制: " + Integer.toBinaryString(number));
        System.out.println("八进制: " + Integer.toOctalString(number));
        System.out.println("十六进制: " + Integer.toHexString(number));
    }
    
    public static void main(String[] args) {
        convertNumber(255);
        // 输出:
        // 十进制: 255
        // 二进制: 11111111
        // 八进制: 377
        // 十六进制: ff
    }
}

2. 数值验证工具

java 复制代码

public class NumberValidator {
    // 安全的整数解析
    public static Integer safeParseInt(String str) {
        try {
            return Integer.valueOf(str);
        } catch (NumberFormatException e) {
            return null;
        }
    }
    
    // 检查字符串是否为有效数字
    public static boolean isValidNumber(String str) {
        try {
            Double.parseDouble(str);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }
    
    // 检查数值范围
    public static boolean isInByteRange(int value) {
        return value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE;
    }
}

3. 类型转换工具类

java 复制代码

public class TypeConverter {
    // 通用的安全转换方法
    public static <T extends Number> String numberToString(T number) {
        return number == null ? "0" : number.toString();
    }
    
    // 字符串到数字的安全转换
    public static int stringToInt(String str, int defaultValue) {
        try {
            return Integer.parseInt(str);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }
    
    // 字符处理
    public static boolean isValidChar(String str) {
        return str != null && str.length() == 1;
    }
    
    public static char stringToChar(String str, char defaultValue) {
        return isValidChar(str) ? str.charAt(0) : defaultValue;
    }
}

最佳实践

1. 数据类型选择

场景	推荐类型	原因
循环计数器	`int`	性能好，范围足够
数组下标	`int`	与数组长度类型一致
金融计算	`BigDecimal`	避免浮点精度问题
开关标识	`boolean`	语义明确
字符处理	`char`	单个字符操作
大整数	`long` 或 `BigInteger`	超出int范围

2. 类型转换建议

java 复制代码

// ✅ 好的做法
// 1. 使用自动装箱拆箱
Integer count = 10;
int total = count + 5;

// 2. 进行范围检查
public byte intToByte(int value) {
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException("超出byte范围");
    }
    return (byte) value;
}

// 3. 异常处理
public int safeParseInt(String str) {
    try {
        return Integer.parseInt(str);
    } catch (NumberFormatException e) {
        throw new IllegalArgumentException("无效的数字格式: " + str);
    }
}

// ❌ 避免的做法
// 1. 避免不必要的装箱拆箱
Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i;  // 每次循环都会装箱拆箱，性能差
}

// 2. 避免精度丢失
float money = 0.1f + 0.2f;  // 结果不是0.3，而是0.30000001

3. 性能考虑

java 复制代码

// 使用基本类型池（-128~127）
Integer a = 100;
Integer b = 100;
System.out.println(a == b);      // true（使用缓存）

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false（超出缓存范围，创建新对象）

// 推荐使用equals()比较包装类
System.out.println(c.equals(d)); // true

4. 常见陷阱

java 复制代码

public class CommonTraps {
    public static void main(String[] args) {
        // 陷阱1：包装类比较
        Integer a = new Integer(10);
        Integer b = new Integer(10);
        System.out.println(a == b);        // false（不同对象）
        System.out.println(a.equals(b));   // true（值相等）
        
        // 陷阱2：null值拆箱
        Integer nullInt = null;
        // int value = nullInt;  // NullPointerException!
        
        // 陷阱3：浮点精度
        System.out.println(0.1 + 0.2 == 0.3);  // false
        
        // 陷阱4：字符和数字混淆
        char ch = '5';
        int num = ch;              // 结果是53（ASCII值），不是5
        int correctNum = ch - '0'; // 正确获取数字5
    }
}

总结

数据类型使用指南

基本类型优先：在不需要null值和额外方法时，优先使用基本类型
合理选择精度：根据数据范围选择合适的类型
注意类型转换：避免精度损失和数据溢出
安全转换：使用try-catch处理转换异常
性能考虑：避免不必要的装箱拆箱操作

类型转换记忆口诀

复制代码

小转大，自动转；
大转小，强制转；
包装类，有方法；
字符串，需解析。

通过深入理解Java数据类型体系和转换机制，能够更好地进行数据处理和类型安全的编程。

【Java基础整理】基本数据类型及转换

Java基本数据类型及转换

摘要

目录

Java数据类型概述

数据类型分类

基本数据类型

1. 数值型

1.1 整数类型

1.2 浮点类型

2. 字符型（char）

3. 布尔型（boolean）

引用数据类型

引用类型分类

基本类型 vs 引用类型

基本数据类型转换

1. 自动类型转换（隐式转换）

定义

转换规则

自动转换示例

注意事项

2. 强制类型转换（显式转换）

定义

转换规则

语法格式

强制转换示例

强制转换注意事项

包装类

定义

基本类型与包装类对应关系

自动装箱和拆箱（JDK 1.5+）

自动装箱（基本类型 → 包装类）

自动拆箱（包装类 → 基本类型）

Integer类详解

构造方法

转换方法

静态工具方法

其他包装类（Byte、Short、Long、Float、Double、Boolean）

通用方法模式

构造方法

实例方法

静态工具方法

具体示例

Character类

构造方法

实例方法

静态工具方法

Boolean类

数据类型转换总结

1. 基本类型 ↔ 包装类

基本类型 → 包装类（装箱）

包装类 → 基本类型（拆箱）

2. 包装类 ↔ 其他基本类型

3. 字符串 ↔ 包装类

String → 包装类

包装类 → String

4. 字符串 ↔ 基本类型

String → 基本类型

基本类型 → String

String → char

转换异常处理

实用工具方法

1. 进制转换工具

2. 数值验证工具

3. 类型转换工具类

最佳实践

1. 数据类型选择

2. 类型转换建议

3. 性能考虑

4. 常见陷阱

总结

数据类型使用指南

类型转换记忆口诀