Java基本数据类型转换

来源：互联网发布：淘宝让你提供质检报告编辑：程序博客网时间：2024/05/19 09:14

变量赋给变量

boolean类型不可赋给其他基本数据类型
对于数值类型（包括字符型char），有以下规则：

低取值范围赋给高取值范围则隐式转换（自动转换，因为能“装下”）
高取值范围赋给低取值范围则显示转换（强制转换/手动转换，因为可能“装不下”）
如果要强转的数超过低取值范围，则会被截断而导致数值发生不预期的变化。
数值型取值范围由小到大如下：byte -> short -> int -> long -> float -> double
?
1
2
3
4
5
6
7
8
9
int a1 = 1;
long a2;

// 将int型变量赋给long型变量，自动进行隐式转换
a2 = a1;
// 将long型变量赋给int型变量，必须手动显示强转，否则编译失败
// 至于是否会发生截断，主要看a2的值是否超过a1的取值范围
// a2的值1L没有超过a1的int型取值范围，所以不截断，数值不变
a1 = (int) a2;
比较特殊的char，char虽然在最大数上比byte和short都大，但char是无符号的，假如将byte类型的-1赋给char，显然不合理，所以byte和char之间没有包含关系。

所以byte <-> char以及short <-> char互相赋值时，都需要显示强转。
?
1
2
3
4
5
6
7
8
byte b = -1;
char c;

c = (char) b ; // -1赋给char必须显示强转，但会溢出而导致数据变化
System.out.println(c+0); // 打印65535而非-1

b = (byte) c; // 必须显示强转
System.out.println(b); // 打印-1而非65535

直接量赋给变量

字面量true、false只能赋给boolean，字符直接量只能赋给char，字符串直接量只能赋给String，null直接量只能赋给引用类型。
对于数值直接量，有以下规则：

取值范围由小到大如下： int -> long –> float -> double
?
1
2
3
4
5
long l = 12; // 隐式转换:int -> long
float f1 = 12L; // 隐式转换:long -> float

float f2 = (float) 3.14; // 必须显示强转:double -> float
double d2 = 3.14f; // 隐式转换: float -> double
注意，对于数值直接量，是没有byte,char,short类型直接量的，这三种类型赋值遵守的规则是：如果直接量超出它们的取值范围，则需要强转。
?
1
2
3
4
5
6
byte b1 = 127; // 正确
byte b2 = 128; // 错误，必须显示强转
byte b3 = 1L; // 错误，必须显示强转
byte b4 = 1d; // 错误，必须显示强转
char c1 = 65535; // 正确
char c2 = 65536; // 错误，必须显示强转

运算时的转换

算数运算时，所有低取值范围的数值，都将先隐式转换为算数式中取值范围最高的类型，然后再进行算数运算，这样的话，结果肯定也是取值范围最高的类型。
数值型取值范围由小到大如下： byte,char,short -> int –> long -> float -> double
?
1
2
3
4
5
6
7
8
9
10
11
12
13
byte byte1 = 1;
char char1 = 1;
short short1 = 1;
int int1 = 1;
long long1 = 1;
float float1 = 1;
double double1 = 1;

float f1 = int1 + float1; // 正确，结果为float型4.0（其实是两个float相加）
int i1 = int1 + float1; // 错误，不可把float赋给int

double d1 = float1 + 1.0; // 正确，结果为double，因为直接量1.0是double型
int i2 = 1 + 1.0; // 错误，结果为double型2.0，不能直接赋给int
比较特殊的是byte,char,short相互间不转换，它们都将先上升转换为int型再运算。
?
1
2
short s = byte1 + short1; // 错误，结果为int型，int型不能直接赋给short
int i3 = 1 + short1; // 正确，结果为int型

超出范围

超出某类型范围的直接量赋值给该类型时，将导致编译不通过
?
1
byte b = 128; // 错误，超过byte最大值127，这个128是int型，不能赋给byte
超出类型范围的运算结果赋值给该类型时，编译不会出错，但会因截断而导致数据发生不预期的变化
?
1
2
3
4
System.out.println(Integer.MAX_VALUE + 1);
// 结果-2147483648，因为它的结果是int且超出int的范围，故被截断
System.out.println(Integer.MAX_VALUE + 1L);
// 结果2147483648，因为它的结果是Long且没有超出long的范围，故相加的结果正确
2147483648和9223372036854775808L是两个表达有问题的直接量
根据第一点可以看出，比int最大值2147483647还大1的数2147483648，在Java中只能表达成2147483648L，否则无法使用这个直接量；
同样比long最大值还大1的数不能通过基本数据类型来表示了，因为它超过了Java基本数据类型整数的取值范围。需要用到BigDecimal或BigInteger类来表达。
?
1
2
int i = 2147483648; // 错误
long l = 9223372036854775808L; // 错误

JDK5.0新特性——自动装箱和拆箱

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * 基本数据类型可以直接赋给其包装类（自动装箱），
 * 相反，包装类也可以直接赋给基本数据类型（自动拆箱），
 * 在表达式中,基本数据类型和包装类可以进行运算
 * 基本数据类型的数组不能实现自动装箱和拆箱,即int[]不能当成Integer[]使用
 */
Boolean b = new Boolean(true); // 原本需要这么写
b = false; ; // 利用自动装箱特性，直接赋字面量
 
int i = 1;
i = new Integer(1); // 利用自动拆箱，将Integer对象赋给int型
 
Integer m = new Integer(2);
int n = 1 + m; // 运算，利用自动拆箱，将Integer对象赋给int型
 
// 只对该类型的直接量才可以自动装箱
int int1 = 1;
float f1 = int1; // 正确
float f2 = 1; // 正确
Float f3 = int1; // 错误，int型不能自动装箱成Float
Float f4 = 1; // 错误，字面量1不是float型不能自动装箱成Float
 
float f5 = new Integer(1); // 正确，将Integer自动拆箱成int再赋给float

转载自：http://my.oschina.net/brucelee80/blog

0 0