【Java数据类型】各种数据类型的相互转换总结

基础数据类型包括：byte、short、int、long、float、double、char、String、boolean，在许多场合需要用到它们的相互转换。本文，将介绍几种转换方式，以及对转换方式的原理简要介绍。

法则与特性

数据类型转换必须满足如下规则：

1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。

特性：

1. 在把容量大的类型转换为容量小的类型时，必须使用强制类型转换。
2. 转换过程中可能导致溢出或损失精度，高级向低级转换；
3. char与int之间的不转换，参与运算的都是int

数据类型转换的方式：

1. 级别从低到高为：byte, char, short(这三个平级)–>int–>float–>long–>double;

   注意：byte, short, char相互之间不转换，他们参与运算首先转换为int类型

2. 自动类型转换：从低级别到高级别，系统自动转的；
3. 强制类型转换：什么情况下使用? 把一个高级别的数赋给一个比该数的级别低的变量；

   格式：目标类型 变量名=(目标类型)(被转换的数据);

字节(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();
	}
}

---