首页 > > 程序设计 > Java技术 >

算法---进制转换，八进制，十六进制，二进制

2018-06-18 02:51:00来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

一、 十六进制转换为八进制

主要思想为：

  1. 十六进制转化为二进制
  2. 二进制转化为八进制

（1）十六进制转化为二进制

  1. 从字符串数组中使用charat(i)函数逐个读取字符，并使用switch将其逐步转化为二进制形式
  2. 转化后的结果保存在stringBuffer对象中，使用append方法；
  3. 结果转化为字符串并传回main函数中，字符串进行判断，根据位数书，判断是否是4的倍数，若不是，则前头补0；

（2）二进制转化为八进制

  1. 首先判断二进制数的前三位，若全为0，则跳过从第四位开始读，此举是为了防止转化为八进制后首位为0的情况。
  2. 使用substring方法每3位都一次，转化后放进stringbuffer对象中。
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
              //读取输入的十六进制数字个数
                Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String[] hexa = new String[n];
        String string;
        scanner.nextLine();
        for(int i=0;i<n;i++)
        {
                       //读取十六进制数存入字符串数组中
            hexa[i] = scanner.next();
        }
        for(int i=0;i<n;i++)
        {
                       //调用函数，将十六进制数转化为二进制数，返回字符串
            string = tobinary(hexa[i]);
            int length_bin = string.length();
                        //对不满足4倍个数的字符串前头补0
            if(length_bin%3==1) string = "000"+string;
            if(length_bin%3==2) string = "00"+string;
                        //调用函数，将二进制数转化为八进制数
            String stroct = toOct(string);
                       //输出结果
            System.out.println(stroct);
        }
        
    }
    //将十六进制转化为二进制
    private static String tobinary(String hexa)
    {
        int length = hexa.length();
        StringBuffer aBuffer = new StringBuffer();    
        for(int i=0;i<length;i++)
        {
            //在字符串中逐步读取字符并替换为相应的二进制数，注意！！charat函数是从头开始读
            switch (hexa.charAt(i)) {
            case '0':
                aBuffer.append("0000");
                break;
            case '1':
                aBuffer.append("0001");
                break;
            case '2':
                aBuffer.append("0010");
                break;
            case '3':
                aBuffer.append("0011");
                break;
            case '4':
                aBuffer.append("0100");
                break;
            case '5':
                aBuffer.append("0101");
                break;
            case '6':
                aBuffer.append("0110");
                break;
            case '7':
                aBuffer.append("0111");
                break;
            case '8':
                aBuffer.append("1000");
                break;
            case '9':
                aBuffer.append("1001");
                break;
            case 'A':
                aBuffer.append("1010");
                break;
            case 'B':
                aBuffer.append("1011");
                break;
            case 'C':
                aBuffer.append("1100");
                break;
            case 'D':
                aBuffer.append("1101");
                break;
            case 'E':
                aBuffer.append("1110");
                break;
            case 'F':
                aBuffer.append("1111");
                break;
            default:
                break;
            }
        }
        return aBuffer.toString();
        
    }
    //将二进制转化为八进制
    private static String toOct(String binary)
    {
        int len = binary.length();
        int k;
        StringBuffer stringBuffer = new StringBuffer();
                //判断开始位置，去除转化为八进制数后首位为0的情况
        if(binary.substring(0, 4).equals("000"))
            k=3;
        else
            k=0;
        for(int i=k;i<len-2;i++)
        {
            switch (binary.substring(i,i+3)) {
            case "000":
                stringBuffer.append("0");
                break;
            case "001":
                stringBuffer.append("1");
                break;
            case "010":
                stringBuffer.append("2");
                break;
            case "011":
                stringBuffer.append("3");
                break;
            case "100":
                stringBuffer.append("4");
                break;
            case "101":
                stringBuffer.append("5");
                break;
            case "110":
                stringBuffer.append("6");
                break;
            case "111":
                stringBuffer.append("7");
                break;
            default:
                break;
            }
        }
        return stringBuffer.toString();
}
}

　　

二、十六进制转化为十进制（方法一）

主要思想为：

  1. 十六进制转化为二进制
  2. 二进制转化为十进制

其中步骤一与之前的类似，重点说一下步骤二

  1. 设置标志符号位flag，用于确定字符读到哪一位;
  2. 从首尾开始读，按照2的阶乘的方法计算后各位相加，得到最终的10进制数（常规算法）
/*方法一*/
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner aScanner =new Scanner(System.in);
        String aString;
        long result;
        aString = aScanner.nextLine();
        aString = tobinary(aString);
        result = todec(aString);
        System.out.println(result);
        
    }
    private static String tobinary(String ahex)
    {
        StringBuffer aBuffer = new StringBuffer();
        int len = ahex.length();
        for(int i =0;i<len;i++)
        {
            switch(ahex.charAt(i))
            {
            case '0':
                aBuffer.append("0000");
                break;
            case '1':
                aBuffer.append("0001");
                break;
            case '2':
                aBuffer.append("0010");
                break;
            case '3':
                aBuffer.append("0011");
                break;
            case '4':
                aBuffer.append("0100");
                break;
            case '5':
                aBuffer.append("0101");
                break;
            case '6':
                aBuffer.append("0110");
                break;
            case '7':
                aBuffer.append("0111");
                break;
            case '8':
                aBuffer.append("1000");
                break;
            case '9':
                aBuffer.append("1001");
                break;
            case 'A':
                aBuffer.append("1010");
                break;
            case 'B':
                aBuffer.append("1011");
                break;
            case 'C':
                aBuffer.append("1100");
                break;
            case 'D':
                aBuffer.append("1101");
                break;
            case 'E':
                aBuffer.append("1110");
                break;
            case 'F':
                aBuffer.append("1111");
                break;
            default:
                break;
            }
        }
        return aBuffer.toString();
    }
    private static long todec(String abin)
    {
        long length = abin.length();
        //标志符号位
        long sign = length-1;
        long a = 0;
        for(int i=0;i<length;i++)
        {
            switch(abin.charAt(i))
            {
            case '0':
                sign--;
                break;
            case '1':
                a = (int) (a + Math.pow(2, sign));
                sign--;
                break;
            default:
                break;
            }
        }
        return a;
}
}

 

三、十六进制转化为十进制（方法二，原创）

此类方法使我在考虑到十六进制转化为十进制时对二进制的转化过于繁琐而思索出来的，直接将十六机制转化为十进制的方法

比较上述而言代码长度更短，所用时间也较短。

思想：

  • 从首位开始读取十六进制数AB2，将其转化为对应的10进制数：10 11 2
  • 核心算法：sum = sum + (long) (num*Math.pow(2, (position-1)*4));每位相加，但在相加之前乘以2的(n-1)*4次方，此处的n为位数
  • 即 10*(3-1)*4+11*(2-1)*4+2*(1-1)*4 = result;
  /*方法二*/ 
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
　　　　 Scanner aScanner =new Scanner(System.in);
        String aString;
        aString = aScanner.nextLine();
        char[] abin = new char[8];
        abin = aString.toCharArray();
        int len = abin.length;
        long num = 0 , sum = 0,position = len;
        for(int i=0;i<len;i++)
        {
            if(abin[i]>='A' && abin[i]<='F')
                num = abin[i] - 'A' +10; 
            else
                num = abin[i] - '0';
            sum = sum + (long) (num*Math.pow(2, (position-1)*4));
            position--;
        }
        
        System.out.println(sum);        
}
}

 

四、十进制转化为十六进制

思想

  1. 十进制转化为二进制
  2. 二进制转化为十六进制

（1）十进制转化为二进制

  • 首先使用除2法，得到字符串，而后将字符串反转，得到正确的与十进制数对应的二进制数（见代码，不详解）
  • 补位，验证是否是4的倍数的位数，不足的前面补0

（2）二进制转化为十六进制

  • 此处与二进制转化为八进制思想相同，见前面，较为简单
  • 需要主要持续使用stringbuffer的对象时要注意清零，便于后续使用，可直接使用setlength(0)方法
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
Scanner  aScanner = new Scanner(System.in);
        long ten = aScanner.nextLong();
        String aString;
        StringBuffer aBuffer = new StringBuffer();
        long m=1,n=0;
        do
        {
            n = ten%2;
            ten = ten/2;
            aBuffer.append(n);
        }while(ten!=0);
        aString = aBuffer.toString();
        //反转字符串
        char[] achar = new char[100000];
        achar = aString.toCharArray();
        int start = 0;
        int end = achar.length-1;
        while(start<end)
        {
            char temp = achar[start];
            achar[start++] = achar[end];
            achar[end--] = temp;
        }
        aBuffer.setLength(0); //清空内容
        for(int i=0;i<achar.length;i++)
        {
            aBuffer.append(achar[i]);
        }
        aString = aBuffer.toString();
        char[] ahex = new char[10000];
        //补位
        if(achar.length%4==1) 
            aString= "000"+aString;
        else if(achar.length%4==2)
            aString= "00"+aString;
        else if(achar.length%4==3)
            aString= "0"+aString;
        aBuffer.setLength(0); //清空内容
        for(int i=0;i<aString.length()-3;i=i+4)
        {
            switch (aString.substring(i,i+4)) {
            case "0000":
                aBuffer.append("0");
                break;
            case "0001":
                aBuffer.append("1");
                break;
            case "0010":
                aBuffer.append("2");
                break;
            case "0011":
                aBuffer.append("3");
                break;
            case "0100":
                aBuffer.append("4");
                break;
            case "0101":
                aBuffer.append("5");
                break;
            case "0110":
                aBuffer.append("6");
                break;
            case "0111":
                aBuffer.append("7");
                break;
            case "1000":
                aBuffer.append("8");
                break;
            case "1001":
                aBuffer.append("9");
                break;
            case "1010":
                aBuffer.append("A");
                break;
            case "1011":
                aBuffer.append("B");
                break;
            case "1100":
                aBuffer.append("C");
                break;
            case "1101":
                aBuffer.append("D");
                break;
            case "1110":
                aBuffer.append("E");
                break;
            case "1111":
                aBuffer.append("F");
                break;
            default:
                break;
            }
        }
        System.out.println(aBuffer.toString());
        
        aString = aBuffer.toString();
        
        System.out.println();
        
    }
}

 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：SpringBoot注解大全

下一篇：Ajax 重构的步骤

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签