Java基本数据类型转换

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

变量赋给变量

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

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

  1 int a1 = 1;
  2 long a2;
  3
  4 // 将int型变量赋给long型变量，自动进行隐式转换
  5 a2 = a1;
  6 // 将long型变量赋给int型变量，必须手动显示强转
  7 // 至于是否会发生截，主要看a2的值是否超过a1的取值范围
  8 // a2的值1L没有超过a1的int型取值范围，所以不截断，数值不变
  9 a1 = (int) a2;

  
  
• 比较特殊的char，char虽然在最大数上比byte和short都大，但char是无符号的，假如将byte类型的-1赋给char，显然不合理，所以byte和char之间没有包含关系。
  
  所以byte <-> char以及short <-> char互相赋值时，都需要显示强转。
  

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

直接量赋给变量

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

• 取值范围由小到大如下： int -> long –> float -> double
  

  1 long l = 12; // 隐式转换:int -> long
  2 float f1 = 12L; // 隐式转换:long -> float
  3
  4 float f2 = (float) 3.14; // 必须显示强转:double -> float
  5 double d2 = 3.14f; // 隐式转换: float -> double

• 注意，对于数值直接量，是没有byte,char,short类型直接量的，这三种类型赋值遵守的规则是：如果直接量超出它们的取值范围，则需要强转。
  

  1 byte b1 = 127; // 正确
  2 byte b2 = 128; // 错误，必须显示强转
  3 byte b3 = 1L; // 错误，必须显示强转
  4 byte b4 = 1d; // 错误，必须显示强转
  5 char c1 = 65535; // 正确
  6 char c2 = 65536; // 错误，必须显示强转

运算时的转换

1. 算数运算时，所有低取值范围的数值，都将先隐式转换为算数式中取值范围最高的类型，然后再进行算数运算，这样的话，结果肯定也是取值范围最高的类型。
2. 数值型取值范围由小到大如下： byte,char,short -> int –> long -> float -> double
   

   01 byte byte1 = 1;
   02 char char1 = 1;
   03 short short1 = 1;
   04 int int1 = 1;
   05 long long1 = 1;
   06 float float1 = 1;
   07 double double1 = 1;
   08
   09 float f1 = int1 + float1; // 正确，结果为float型4.0（其实是两个float相加）
   10 int i1 =  int1 + float1; // 错误，不可把float赋给int
   11
   12 double d1 = float1 + 1.0; // 正确，结果为double，因为直接量1.0是double型
   13 int i2 = 1 + 1.0; // 错误，结果为double型2.0，不能直接赋给int

3. 比较特殊的是byte,char,short相互间不转换，它们都将先上升转换为int型再运算。
   

   1 short s = byte1 + short1; // 错误，结果为int型，int型不能直接赋给short
   2 int i3 = 1 + short1; // 正确，结果为int型

超出范围

1. 超出某类型范围的直接量赋值给该类型时，将导致编译不通过
   

   1 byte b = 128; // 错误，超过byte最大值127，这个128是int型，不能赋给byte

2. 超出类型范围的运算结果赋值给该类型时，编译不会出错，但会因截断而导致数据发生不预期的变化
   

   1 System.out.println(Integer.MAX_VALUE + 1);
   2 // 结果-2147483648，因为它的结果是int且超出int的范围，故被截断
   3 System.out.println(Integer.MAX_VALUE + 1L);
   4 // 结果2147483648，因为它的结果是Long且没有超出long的范围，故相加的结果正确

3. 2147483648和9223372036854775808L是两个表达有问题的直接量
   根据第一点可以看出，比int最大值2147483647还大1的数2147483648，在Java中只能表达成2147483648L，否则无法使用这个直接量；
   同样比long最大值还大1的数不能通过基本数据类型来表示了，因为它超过了Java基本数据类型整数的取值范围。需要用到BigDecimal或BigInteger类来表达。
   

   1 int i = 2147483648; // 错误
   2 long l = 9223372036854775808L; // 错误

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

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