黑马程序员——Java基础——Java中几种进制的相互转换

最新推荐文章于 2024-07-20 23:55:03 发布

千里路

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量522

点赞数

文章标签：黑马程序员 java 进制工具类

本文链接：https://blog.csdn.net/libin1127/article/details/47083445

版权

点击打开链接点击打开链接点击打开链接 android培训、<a">点击打开链接点击打开链接 java培训、期待与您交流！">点击打开链接点击打开链接

Java中整数的三种表现形式

l 十进制：0-9，满10进1

l 八进制:0-7，满8进1

l 十六进制 0-9，A-F，满16进1，用0x开头表示。

进制的由来：任何数据在计算机中都是以二进制的形式存在的。二进制早起由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1和0组成的数值进行使用很麻烦，所以就想把一大串缩短一点，将二进制中三位用一位表示。这三位中可以取到的最大值是7超过7就进位了，这就是8进制。但是对于过长的二进制变成八进制还是很长，所以出现用4个二进制位表现一位的情况，4个二进制最大的是15，这就是十六进制。

规律：进制越大，表现形式越短。

Java中的基本数据类型byte就是8个二进制代表一个字节。

二进制和十进制之间的转换

十进制转换成二进制，原理是对十进制数进行除2的运算。除2后得到的整数继续除2，直到变为1，其每次的余数排列起来就是其二进制。

二进制转换为十进制，原理是二进制乘以2的过程，例：二进制110，其十进制是：0*20+1*21+1*22=0+2+4=6.

其它进制之间的转换

二进制转换成八进制，三个二进制位代表一位

二进制转换成十六进制，四个二进制位代表一位

二进制的负数表现形式：二进制取反再加上1. 负数的最高位为1，正数最高位为0.

例：6的二进制是110，在内存中的表现形式是：0000-0000 0000-0000 0000-0000 0000-0110

取反，就是将0变1,1变0,6取反就变成：1111-1111 111-1111 111-1111 111-1001

在加上1，就变成了：1111-1111 111-1111 111-1111 111-1010

所以，-6的二进制表现形式就是：1111-1111 111-1111 111-1111 111-1010

习题：进制之间的转换。

//进制转换工具类,以下都是用正整数进行。
class ExchTools   
{
	//十进制转换为二进制，接收int型数据，返回string.
	public static String myToBinaryString(int a)
	{
		//定义一个字符串容器，用于接收二进制
		StringBuilder binary=new StringBuilder();
		for(;a>0;a=a/2)
		{
             binary.insert(0,String.valueOf(a%2));
		}
		return  binary.toString();
	}

	//十进制转换成八进制，利用整数在内存中是二进制的特点
	public static String myToHexString(int a)
	{
		StringBuilder str=new StringBuilder();
		for(;a>0;a=a>>3)
		{
			str.insert(0,String.valueOf(a&7));
		}
		return str.toString();
	}
	//十进制转换成十六进制，
	public static String myToOctalString(int a)
	{
		//定义字符串容器接收十六进制
		StringBuilder str=new StringBuilder();
		str.append("0X");
		//定义数组，使用查表法,让得到的数字找到十六进制中对应的字符。
		char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		int index=0;
		for(;a>0;a=a>>4)
		{
			index=a&15;
			str.insert(2,arr[index]);
		}
		return str.toString();
	}
	//二进制转换成十进制
	public static int myToDec(String str)
	{
		StringBuilder sb=new StringBuilder();
		sb.append(str);
		//定义一个整形用于接收十进制
		int sum=0;
		for(int i=0;i<sb.length();i++)
		{
            //在这里字符不能跟字符串相等，所以一定要把字符转换成字符串
			if("1".equals(String.valueOf(sb.charAt(sb.length()-1-i))))
			    sum=sum+(1<<i);
		}
		return sum;
	}

	//二进制转换成八进制,当然也可以把二进制先转换为十进制，再转换成八进制。
    public static String myToHex(String str)
	{
		StringBuilder sb=new StringBuilder();
		sb.append(str);
		//定义一个容器用于接收八进制
		StringBuilder s=new StringBuilder();
		int sum=0;
		for(int i=0;i<sb.length();i++)
		{
            if("1".equals(String.valueOf(sb.charAt(sb.length()-1-i))))
			    sum=sum+((1<<i%3));
			if((i+1)%3==0||i==sb.length()-1)
			{
				s.insert(0,String.valueOf(sum));
				sum=0;
			}
		}
		return s.toString();
	}

//二进制转换成十六进制,当然也可以把二进制先转换为十进制，再转换成十六进制。
    public static String myToOctal(String str)
	{
		StringBuilder sb=new StringBuilder();
		sb.append(str);
		//定义一个容器用于接收八进制
		StringBuilder s=new StringBuilder();
		s.append("0X");

		char[] arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		int sum=0;
		for(int i=0;i<sb.length();i++)
		{
            if("1".equals(String.valueOf(sb.charAt(sb.length()-1-i))))
			    sum=sum+((1<<i%4));
			if((i+1)%4==0||i==sb.length()-1)
			{
				s.insert(2,arr[sum]);
				sum=0;
			}
		}
		return s.toString();
	}
 //八进制转换成二进制
  public static String HexToBinary(String str)
  {
	  StringBuilder sb=new StringBuilder();
	  StringBuilder s=new StringBuilder();
	  //将八进制变成字符数组
	  char[] arr=str.toCharArray();
	  int a=0;
	  for(int i=0;i<arr.length;i++)
	  {
		  a=Integer.parseInt(String.valueOf(arr[i]));
		  for(;s.length()!=3;a=a/2)
		  {
               s.insert(0,a%2);
		  }
		  sb.append(s);
          s.delete(0,s.length());
	  }
      return sb.toString();
  }
  //八进制转换成十进制
  public static int HexToDec(String str)
  {
	  int sum=0;
	  char[] arr=str.toCharArray();
	  for(int i=arr.length-1;i>=0;i--)
	  {
		  int num=Integer.parseInt(String.valueOf(arr[i]));
		  sum=sum+num*(1<<(3*(arr.length-1-i)));
	  }
	  return sum;
  }
  //八进制转换成十六进制，只能先转换成二进制再转换成十六进制
  //或者先转换成十进制再转换成十六进制
  public static String HexToOctal(String str)
  {
	  return myToOctal(HexToBinary(str));
  }
  //十六进制转换成二进制
 public static String OctalToBinary(String str)
  {
	  StringBuilder sb=new StringBuilder();
	  StringBuilder s=new StringBuilder();
     String ar="0123456789ABCDEF";
	  //将八进制变成字符数组
	  if(str.startsWith("0x"))
	      str=str.substring(2,str.length());
	  else
		  throw new RuntimeException("请输入以0X开头的十六进制数");
	  char[] arr=str.toCharArray();
	  int a=0;
	  for(int i=0;i<arr.length;i++)
	  {
		  a=ar.indexOf(arr[i]);
		  for(;s.length()<4;a=a/2)
		  {
			   if(i==0&&a==0)
				   break;
			   s.insert(0,a%2);
               
		  }
		  sb.append(s);
          s.delete(0,s.length());
	  }
      return sb.toString();
  }

  //十六进制转换成十进制
  public static int OctalToDec(String str)
  {
	  if(str.startsWith("0x"))
	      str=str.substring(2,str.length());
	  else
		  throw new RuntimeException("请输入以0X开头的十六进制数");

	  String st="0123456789ABCDEF";
	  int sum=0;
	  char[] arr=str.toCharArray();
	  for(int i=arr.length-1;i>=0;i--)
	  {
		  int num=st.indexOf(arr[i]);
		  sum=sum+num*(1<<(4*(arr.length-1-i)));
	  }
	  return sum;
  }

  //十六进制转换成八进制
  public static String OctalToHex(String str)
  {
	  return myToHex(OctalToBinary(str));
  }
}

在java中，进制之间的转换被封装在Integer类中，这里特别复习一下Integer类

重要方法：

static String/toBinaryString(int i):十进制转换成二进制，包括负数。

static String/toHexString(int i):十进制转换成把进制，包括负数。

static String/toOctalString(int i):十进制转换成八进制，包括负数。

static string/toString(int i,int radix):十进制转换成其他进制

static int/parseInt(String s.int radix):将其他进制转换成十进制，radix是s的进制表现形式。

static Integer/valueof(String s,int radix):将其他进制转换成十进制的整数对象。

byteValue()、doubleValue()、floatValue()、intValue()、longValue()、shortValue():将Integer转成其他基本数据类型。

static int/parseInt(String s)：将字符串转成十进制数。

static String/toString(int i):将整数转成字符串。

static Integer/valueOf(int i):将int值转成整数对象

static Integer/valueOf(String s)：将字符串转成整数对象。

疑问；负数进制转换问题，在Integer类中整数进制转换包括负整数，二进制还可以理解，但是负数的八进制和十六进制是怎么表示的？API中是这样解释的，但还是看不懂？

toHexString

public static String toHexString(int i)

以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

如果参数为负，那么无符号整数值为参数加上 232；否则等于该参数。将该值转换为十六进制（基数 16）的无前导 0 的 ASCII 数字字符串。如果无符号数的大小值为零，则用一个零字符 '0' (’\u0030’) 表示它；否则，无符号数大小的表示形式中的第一个字符将不是零字符。用以下字符作为十六进制数字：

0123456789abcdef

这些字符的范围是从 '\u0030' 到 '\u0039' 和从 '\u0061' 到 '\u0066'。如果希望得到大写字母，可以在结果上调用String.toUpperCase() 方法：

Integer.toHexString(n).toUpperCase()

参数：

i - 要转换成字符串的整数。

参数的十六进制（基数 16）无符号整数值的字符串表示形式。

从以下版本开始：

JDK1.0.2