基础数据类型包括：byte、short、int、long、float、double、char、String、boolean，在许多场合需要用到它们的相互转换。本文，将介绍几种转换方式，以及对转换方式的原理简要介绍。
法则与特性
数据类型转换必须满足如下规则：
- 不能对boolean类型进行类型转换。
- 不能把对象类型转换成不相关类的对象。
特性：
- 在把容量大的类型转换为容量小的类型时，必须使用强制类型转换。
- 转换过程中可能导致溢出或损失精度，高级向低级转换；
- char与int之间的不转换，参与运算的都是int
数据类型转换的方式：
- 级别
从低到高为：byte, char, short(这三个平级)–>int–>float–>long–>double;
注意：byte, short, char相互之间不转换，他们参与运算首先转换为int类型
-
自动类型转换：从低级别到高级别，系统自动转的；
-
强制类型转换：什么情况下使用? 把一个高级别的数赋给一个比该数的级别低的变量；
格式：目标类型 变量名=(目标类型)(被转换的数据);
字节(byte)相关转换
byte特性：
- byte能表示的数的范围是：[-128, +127]
- byte[]只能用于保存范围在[-128,+127]之间的数字，常用于字节流时做缓冲数组；
你可能会问： 为毛最大值和最小值的绝对值不一样？
解答： 8位的byte，最高位是符号位；于是最大值的二进制位是0111 1111，十进制为127；最小值就是上面的二进制位取反，符号位是1，于是最小值的二进制位是1000 0000，十进制为-128；
获取byte基础信息：
System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println("包装类：java.lang.Byte");
System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE); //获取Byte的最大值:127
System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE); //获取Byte的最小值:-128
byte数组赋值：
// byte数组赋值
byte[] b = new byte[10]; //一个字节(byte) = 一个char
for(int i=0;i<b.length;i++) {
b[i]=(byte)(65+i); //字节数组的赋值，赋值的范围[-127,+127]
}
byte数组的输出：
//byte数组的输出
for(int i=0;i<b.length;i++) {
System.out.println((char)b[i]); //将ASCII码转换为字符输出；
System.out.println(b[i]); //直接输出，则输出该byte数组元素的ASCII码；
}
byte（字节）数组、String、Char的相互转换：
char[] ch = new char[3];
ch[0]='a';
ch[1]='b';
ch[2]='c';
String str = new String(ch); //char[]转String；
//char[]转byte[]：char-->String-->byte;
byte[] bb = str.getBytes(); //String转byte[];
char[] chStr = new char[3];
for(int i=0;i<chStr.length;i++) {
chStr[i]=(char)bb[i]; //byte[]转char[];
}
String ss = new String(chStr); //char[]转String
System.out.println(new String(ss));
byte[] bbb = new byte[3];
for(int i=0;i<bbb.length;i++) {
bbb[i]=(byte)ch[i]; //char[]转byte[]：强制类型转换；
}
八个基础类型与String互转
八个基础数组类型与String互转都可以使用以下方法，这里使用int型为例子。
如果字符串是StringBuffer或者是StringBuilder，则先转换为String，再做转换。
int -> String：
int i=12345;
String s="";
第一种方法：s=i+"";
第二种方法：s=String.valueOf(i);
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
第一种方法：s=i+""; //会产生两个String对象
第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象
第三种方法：s=Integer.toString(i);
Integer i2 = new Integer(40);
String s = i2.toString();
String -> int：
s="12345";
int i;
第一种方法：static int parseInt(String s); 方法
第二种方法：int intValue();方法
public class Main {
public static void main(String[] args) {
// Integer(String s) 方法
Integer i = new Integer("10");
int a = i.intValue(); // 转换为int
System.out.println(a + 10); // int型运算并输出
// static int parseInt(String s) 方法
int b = Integer.parseInt("20");
System.out.println(b + 30); // int型运算并输出
}
}
这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？
第一种方法： i=Integer.parseInt(s); //直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法： i=Integer.valueOf(s).intValue(); //Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象
使用拼接符示例
//使用拼接符示例
public class Main {
public static void main(String args[]) {
int i = 123;
short sh = 456;
long ong = 789L;
//直接使用拼接符：“+”
String s = new String();
s+=i;
s+=sh;
s+=ong;
System.out.println("The String: " + s); //输出：123456789
float f = 111.134f;
double d = 222.3414d;
char ch = 'A';
boolean b = true;
String ss = new String();
ss += f;
ss += d;
ss +=ch;
ss += b;
System.out.println("The New String: " + ss); //111.134222.3414Atrue
}
}
使用String.valueOf
//String.valueOf示例
public class Main {
public static void main(String args[]) {
int i = 123;
short sh = 456;
long ong = 789L;
String s = new String();
s = String.valueOf(i);
System.out.println("i: " + getType(i) + "; s: " + getType(s));
//输出：i: class java.lang.Integer; s: class java.lang.String
s = String.valueOf(sh);
System.out.println("sh: " + getType(sh) + "; s: " + getType(s));
//输出：sh: class java.lang.Short; s: class java.lang.String
s = String.valueOf(ong);
System.out.println("ong: " + getType(ong) + "; s: " + getType(s));
//输出：ong: class java.lang.Long; s: class java.lang.String
//其他类型同理
}
public static String getType(Object o){ //获取变量类型方法
return o.getClass().toString();
}
}
使用toString
toString方法
public class Main {
public static void main(String args[]) {
int i = 123; //short、long同理
Integer ii = new Integer(i);
String s = ii.toString();
System.out.println("ii: " + getType(i) + "; s: " + getType(s));
//输出：ii: class java.lang.Integer; s: class java.lang.String
double d = 10.134d; //float同理
Double dd = new Double(d);
String ss = dd.toString();
System.out.println("dd: " + getType(dd) + "; sd: " + getType(ss));
//输出：ii: class java.lang.Double; s: class java.lang.String
}
public static String getType(Object o){ //获取变量类型方法
return o.getClass().toString();
}
}
使用parseXxx
//parseXxx示例
public class Main {
public static void main(String args[]) {
String s = "1234";
int a = Integer.parseInt(s);
System.out.println("s:"+getType(s) + "; a:" + getType(a));
//输出：s:class java.lang.String; a:class java.lang.Integer
String ss = "56.78f";
float ff = Float.parseFloat(ss);
System.out.println("ss:"+getType(ss) + "; ff:" + ff +", " + getType(ff));
//输出：ss:class java.lang.String; ff:56.78, class java.lang.Float
String sss = "89.1234d";
double dd = Double.parseDouble(sss);
System.out.println("sss:"+getType(sss) + "; dd:" + dd +", " + getType(dd));
//输出：sss:class java.lang.String; dd:89.1234, class java.lang.Double
}
public static String getType(Object o){ //获取变量类型方法
return o.getClass().toString();
}
}
使用xxxValue
//xxxValue示例
public class Main {
public static void main(String args[]) {
String s = "1234";
Integer i = new Integer(s);
int a = i.intValue(); //转换为int
System.out.println("s:"+getType(s) + "; a:" + getType(a));
//输出：s:class java.lang.String; a:class java.lang.Integer
String ss = "56.78f";
Float f = new Float(ss);
float ff = f.floatValue();
System.out.println("ss:"+getType(ss) + "; ff:" + ff +", " + getType(ff));
//输出：ss:class java.lang.String; ff:56.78, class java.lang.Float
String sss = "89.1234d";
Double d = new Double(sss);
double dd = d.doubleValue();
System.out.println("sss:"+getType(sss) + "; dd:" + dd +", " + getType(dd));
//输出：sss:class java.lang.String; dd:89.1234, class java.lang.Double
}
public static String getType(Object o){ //获取变量类型方法
return o.getClass().toString();
}
}
