【计算机运算】基本数据类型间的转化02

计算机组织与结构

主要内容：

       32位二进制补码整数与整数型int的互相转化（intToBinary，binaryToInt）。
       IEEE类型数据与单精度浮点数float的互相转化（floatToBinary，binaryToFloat）。
       BCD码与整数型int的互相转化（NBCDToDecimal，decimalToNBCD）。

知识储备：

       对于单精度浮点数的认识。

方法实现：

代码如下：

package EightWeek;

public class Transformer_again {

	public String intToBinary(String numStr) {
		
		String res=Integer.toBinaryString(Integer.parseInt(numStr));
		for(int i=res.length();i<32;i++)
			res="0"+res;
		return res;
	}
	
	public String binaryToInt(String binStr) {
		
		boolean isN=false;//是否为负
		String res="";
		if(binStr.charAt(0)=='1'){
			isN=true;
			for(int i=0;i<binStr.length();i++)
				res+=(binStr.charAt(i)=='0') ? "1" : "0";
		}
		int ans=Integer.parseInt(res, 2);
		if(isN) return String.valueOf(-ans-1);
		return String.valueOf(ans);
	}
	
	public String floatToBinary(String floatStr) {//7.5
		
		double f=Double.parseDouble(floatStr);
		boolean isN=f<0;//是否为负
		if(Double.isNaN(f)) return "NaN";
		if(!isFinite(f)) return isN ? "-Inf" : "+Inf";
		
		String res=isN ? "1" : "0";
		
		if(f==0.0) return res+"0000000000000000000000000000000";
		double fl=Math.abs(f);
		int bias=127;
		boolean expisO=fl<Math.pow(2, -126);
		
		if(expisO){
			res=res+"00000000";
			fl*=Math.pow(2, 126);//fl=0.xxx
			return res+findPoint(fl);
		}
		
		//fl>=Math.pow(2, -126);
		int exp=getExp(fl);
		String e=Integer.toBinaryString(exp+bias);
		for(int i=e.length();i<8;i++)
			e="0"+e;
		fl=fl/Math.pow(2, exp);//fl=1.xxx
		return res+e+findPoint(fl-1);
		
	}
	
	private boolean isFinite(double f) {
		
		double result=(Math.pow(2, 24)-1)*Math.pow(2, Math.pow(2, 8)-1-1-127-23);//注意：两个-1啊
		return f>=-result&&f<=result;
	}

	private int getExp(double fl) {
		
		if(fl==0) return 0;
		int exp=0;
		while(fl>=2){
			fl/=2;
			exp++;
		}
		while(fl<1){
			fl*=2;
			exp--;
		}
		return exp;
	}

	public String findPoint(double d){
		
		String res="";
		d= (d<1) ? d : d-(int) d;  //d = 0.xxxxx
		int count=0;
		while(count<23&&d!=0.0){
			d*=2;
			res+=(d>=1) ? "1" : "0";
			if(d>=1) d-=1;
			count++;
		}
		for(int i=res.length();i<23;i++)
			res+="0";
		return res;
	}
	
	public String binaryToFloat(String binStr) {
		
		boolean isN=binStr.charAt(0)=='1';
		String exp=binStr.substring(1, 9);
		String decimal=binStr.substring(9);
		
		if(exp.equals("11111111")){
			if(decimal.contains("1")) return "NaN";
			return isN ? "-Inf" : "+Inf";
		}
		if(exp.equals("00000000")){
			if(decimal.contains("1")){
				double fl=0.0;
				int temp=1;
				for(char fc : decimal.toCharArray()){
					fl+=Integer.parseInt(String.valueOf(fc))/Math.pow(2, temp);
					temp++;
				}
				fl*=Math.pow(2, -126);//应该×2^-127但是在上面的循环中一开始就多乘了一个0.1
				return isN ? String.valueOf(-fl) : String.valueOf(fl);
			}
			return "0.0";//!decimal.contains("1")
		}
		//exp="xxxxxxxx";
		
		double fl=0.0;
		int temp=1;
		for(char fc : decimal.toCharArray()){
			fl+=Integer.parseInt(String.valueOf(fc))/Math.pow(2, temp);
			temp++;
		}
		fl=(1+fl)*Math.pow(2, Integer.parseInt(exp, 2)-127);
		return isN ? String.valueOf(-fl) : String.valueOf(fl);
	}
	
	public String decimalToNBCD(String decimal) {
		
		int n=Integer.parseInt(decimal);
		String res= (n<0) ? "1101" : "1100";
		n=Math.abs(n);
		int i=7;String ult="";
		while(i>0){
			if(n==0) ult="0000"+ult;
			int x=n%10;
			n=(n-x)/10;
			String r=Integer.toString(x, 2);
			for(int k=r.length();k<4;k++)
				r="0"+r;
			ult=r+ult;
			i--;
		}
		return res+ult;
	}
	
	public String NBCDToDecimal(String NBCDStr) {
		
		boolean isN= NBCDStr.charAt(3)=='1';
		String temp="";
		int res=0;
		for(int i=4;i<=28;i=i+4){
			temp=NBCDStr.substring(i, i+4);
			res=10*res+Integer.parseInt(temp, 2);
		}
		return isN ? String.valueOf(-res) : String.valueOf(res);
	}
}

方法检验：

package EightWeek;

public class Transformer_again_test {
	
	public static void main(String args[]){
		
		Transformer_again t=new Transformer_again();
		
		System.out.println(t.binaryToFloat("00000000010000000000000000000000"));
		System.out.println(Math.pow(2, -127));
		System.out.println(t.floatToBinary(String.valueOf(Math.pow(2, -127))));

		System.out.println(t.binaryToFloat("00000000011000000000000000000000"));
		System.out.println(0.75 * Math.pow(2, -126));
		System.out.println(t.floatToBinary(String.valueOf(0.75 * Math.pow(2, -126))));

		System.out.println(t.binaryToFloat("01001001110100010000000000000000"));
		System.out.println(1.6328125 * Math.pow(2, 20));
		System.out.println(t.floatToBinary(String.valueOf(1.6328125 * Math.pow(2, 20))));

		System.out.println(t.binaryToFloat("11001001110100010000000000000000"));
		System.out.println(-1.6328125 * Math.pow(2, 20));
		System.out.println(t.floatToBinary(String.valueOf(-1.6328125 * Math.pow(2, 20))));

		System.out.println(t.binaryToFloat("00110101110100010000000000000000"));
		System.out.println(1.6328125 * Math.pow(2, -20));
		System.out.println(t.floatToBinary(String.valueOf(1.6328125 * Math.pow(2, -20))));

		System.out.println(t.binaryToFloat("10110101110100010000000000000000"));
		System.out.println(-1.6328125 * Math.pow(2, -20));
		System.out.println(t.floatToBinary(String.valueOf(-1.6328125 * Math.pow(2, -20))));

		System.out.println(t.binaryToFloat("11111111100000000000000000000000"));
		System.out.println(t.binaryToFloat("01111111100000000000000000000000"));
		System.out.println(t.binaryToFloat("00000000000000000000000000000000"));
		
	}
}

结果如下：

5.8774717541114375E-39
5.8774717541114375E-39
00000000010000000000000000000000
8.816207631167156E-39
8.816207631167156E-39
00000000011000000000000000000000
1712128.0
1712128.0
01001001110100010000000000000000
-1712128.0
-1712128.0
11001001110100010000000000000000
1.55717134475708E-6
1.55717134475708E-6
00110101110100010000000000000000
-1.55717134475708E-6
-1.55717134475708E-6
10110101110100010000000000000000
-Inf
+Inf
0.0

总结：

       了解计算机如何进行各种数据类型的计算非常重要，要好好把握。