Java基本数据类型转换

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

变量赋给变量

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

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

  2long a2;

  3 

  4// 将int型变量赋给long型变量，自动进行隐式转换

  5a2 = a1;

  6// 将long型变量赋给int型变量，必须手动显示强转

  7// 至于是否会发生截，主要看a2的值是否超过a1的取值范围

  8// a2的值1L没有超过a1的int型取值范围，所以不截断，数值不变

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

  2char c;

  3 

  4c = (char) b ; // -1赋给char必须显示强转，但会溢出而导致数据变化

  5System.out.println(c+0); // 打印65535而非-1

  6 

  7b = (byte) c; // 必须显示强转

  8System.out.println(b); // 打印-1而非65535

直接量赋给变量

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

• 取值范围由小到大如下： int -> long –> float -> double
  
  1long l = 12; // 隐式转换:int -> long

  2float f1 = 12L; // 隐式转换:long -> float

  3 

  4float f2 = (float) 3.14; // 必须显示强转:double -> float

  5double d2 = 3.14f; // 隐式转换: float -> double
• 注意，对于数值直接量，是没有byte,char,short类型直接量的，这三种类型赋值遵守的规则是：如果直接量超出它们的取值范围，则需要强转。
  
  1byte b1 = 127; // 正确

  2byte b2 = 128; // 错误，必须显示强转

  3byte b3 = 1L; // 错误，必须显示强转

  4byte b4 = 1d; // 错误，必须显示强转

  5char c1 = 65535; // 正确

  6char c2 = 65536; // 错误，必须显示强转

运算时的转换

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

   02char char1 = 1;

   03short short1 = 1;

   04int int1 = 1;

   05long long1 = 1;

   06float float1 = 1;

   07double double1 = 1;

   08 

   09float f1 = int1 + float1; // 正确，结果为float型4.0（其实是两个float相加）

   10int i1 =  int1 + float1; // 错误，不可把float赋给int

   11 

   12double d1 = float1 + 1.0; // 正确，结果为double，因为直接量1.0是double型

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

   2int i3 = 1 + short1; // 正确，结果为int型

超出范围

1. 超出某类型范围的直接量赋值给该类型时，将导致编译不通过
   
   1byte b = 128; // 错误，超过byte最大值127，这个128是int型，不能赋给byte
2. 超出类型范围的运算结果赋值给该类型时，编译不会出错，但会因截断而导致数据发生不预期的变化
   
   1System.out.println(Integer.MAX_VALUE + 1);

   2// 结果-2147483648，因为它的结果是int且超出int的范围，故被截断

   3System.out.println(Integer.MAX_VALUE + 1L);

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

   2long l = 9223372036854775808L; // 错误

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

view source

print?

01/**

02 * 基本数据类型可以直接赋给其包装类（自动装箱），

03 * 相反，包装类也可以直接赋给基本数据类型（自动拆箱），

04 * 在表达式中,基本数据类型和包装类可以进行运算

05 * 基本数据类型的数组不能实现自动装箱和拆箱,即int[]不能当成Integer[]使用

06 */

07Boolean b = new Boolean(true); // 原本需要这么写

08b = false; ; // 利用自动装箱特性，直接赋字面量

09 

10int i = 1;

11i = new Integer(1); // 利用自动拆箱，将Integer对象赋给int型

12 

13Integer m = new Integer(2);

14int n = 1 + m; // 运算，利用自动拆箱，将Integer对象赋给int型

15 

16// 只对该类型的直接量才可以自动装箱

17int int1 = 1;

18float f1 = int1; // 正确

19float f2 = 1; // 正确

20Float f3 = int1; // 错误，int型不能自动装箱成Float

21Float f4 = 1; // 错误，字面量1不是float型不能自动装箱成Float

22 

23float f5 = new Integer(1); // 正确，将Integer自动拆箱成int再赋给float