java使用移位运算进行进制转化

2019年11月9日 136次阅读

最近在练习进制转换算法，学习了一种使用移位运算进行进制的方法分享给大家。

  • 16进制转换8进制
 问题描述:
        输入格式
            输入的第一行为一个正整数n （1<=n<=10）。
            接下来n行，每行一个由0~9、大写字母A~F组成的字符串，
            表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
        输出格式
            输出n行，每行为输入对应的八进制正整数。
        注意
            输入的十六进制数不会有前导0，比如012A。输出的八进制数也不能有前导0。
        样例输入
            239123ABC
        样例
            71
            4435274

我一开始的解法，1个16进制数可以转化为4个2进制数，再通过每3个二进制数可以转化为1个8进制数。不过有一点需要注意转化成8进制数要从2进制字符串后面开始，到最前面时需要判断还剩下几位，不够3位要补0。

package 十六进制转八进制;

import java.text.DecimalFormat;
import java.util.Scanner;
import java.util.Stack;
public class Main {
    static Scanner scan = new Scanner(System.in);
    static DecimalFormat decimalFormat=new DecimalFormat("0000");
    static DecimalFormat d2=new DecimalFormat("000");
    public static void change(String str){

        String s = "";

        int top = 0;
        char[] c = str.toCharArray();   
        for (int k = 0; k < c.length; k++) {
            if (c[k] >= '0' && c[k] <= '9') {       
                s+=decimalFormat.format(Integer.parseInt(Integer.toBinaryString(c[k]-48)));
            }else if(c[k] >= 'A' && c[k] <= 'F'){
                s+=decimalFormat.format(Integer.parseInt(Integer.toBinaryString(c[k]-55)));
            }   
        }
        int num = s.length();
        if(num%3==1)
            s="00"+s;
        else if(num%3==2)
            s="0"+s;
        if(s.substring(0, 3).equals("000")){
            s=s.substring(3);
        }
        for (int i = 0; i < s.length(); i=i+3) {

            String xStr = s.substring(i,i+3);
            System.out.print(Integer.parseInt(xStr.substring(0,1))*4+
                                Integer.parseInt(xStr.substring(1,2))*2+
                                Integer.parseInt(xStr.substring(2,3))*1);
        }


    }
    public static void main(String[] args) { 
        int n = Integer.parseInt(scan.nextLine());
        String[] strs = new String[n];
        for (int i = 0; i < strs.length; i++) {     
            strs[i] = scan.nextLine();      
        }
        for (int i = 0; i < strs.length; i++) {
            change(strs[i]);
            System.out.println();
        }
    }
}

使用题目给的测试可以通过，我自己设置的测试数据也可以通过，然后去蓝桥杯测试平台上跑结果炸了！去看测试数据，10个16进制数，最长的10万位，估计是溢出了。去调试发现是在2进制转化为8进制的时候出错了，for循环次数太多了。for里还有数值运算比较费时，改了好久测试总是通不过。去百度发现一种运用java移位运算进行转化的，写了试了一下发现可以通过了。

使用java移位运算符进行转化
import java.util.Scanner;
public class Main {
 public static void main(String[] args) {
     new Main().systemScanner();
 }
 public void systemScanner() {
     Scanner jin = new Scanner(System.in);
     while (jin.hasNext()) {
         int length = jin.nextInt();
         for (int i = 0; i < length; i++){
             String strTmp=jin.next();
             tranform(strTmp.toCharArray(), strTmp.length());
         }
     }
 }
 /* * 3位16进制等价于4位8进制 */
 int[] stack=new int[40000];
 public void tranform(char[] str, int length) {
     char[] buff = new char[4];
     int top = -1;
     for (int i = length - 1; i >= 0; i -= 3) {
         int sum = 0;
         for (int j = 0; j < 3 && i - j >= 0; j++) {// i-j>=0防止不够三个的情况
             int tmp = str[i - j] >= '0' && str[i - j] <= '9' ? str[i - j] - '0': str[i - j] - 'A' + 10;//区分是数字，还是字符，进行对应转换
             sum+=(tmp<<(4*j));//这句很重要，通过这句就可以从16变成10进制了。
         }
         stack[++top]=sum;//sum的结果是16进制转化10进制的结果，每3个16进制变成10进制，再变8进制
     }
     while(stack[top]==0){//排除前导为0的判断
         top--;
     }
     for(int i=top;i>=0;i--){
         String str1=Integer.toOctalString(stack[i]);//从10进制转化成8进制
         if(i!=top&&str1.length()<4){
             //不是最左边的一个，就不用去掉前导0,而默认是去掉0的，所以要进行补会
             for(int y=0;y<4-str1.length();y++)
                 System.out.print("0");
         }
         System.out.print(str1);
     }
     System.out.println();
     }
}

这种解法的思路是：1位16进制可以代表4位2进制， 1位8进制可以代表3位二进制，得出3位16进制求和入栈输出表示4位8进制，然后出栈输出。由16进制转化为10进制的时候，使用 << 使16进制数转化为8进制。

例子：

0x11 << 4 => 17;

/* 11的二进制编码是 1011，个位是1 编码是0001，十位是1 编码也是0001。 根据位数进行移位运算，个位左移(4*0)位还是0001，十位左移(4*1)位变成00010000 */

0001 << 4*1 = 00010000; 0001 << 4*0 = 0001;

/* 整个数就变成了00010001 也就是10001 转换为10进制是为17。这里可以看到一个16进 制数通过按位数分别左移4*(n-1)位就可以转化为10进制数了。具体的原因是每一个整 数左移4位等于这数的二进制表示后面多了4个0，相当于2进制乘法乘了一个二进制10000()。 */
1*16^1+1*16^0 = 17;
/* 10000转化为10进制为16也就是每位乘了16^(n-1)进而把一个16进制数转化为10进制数。 */

这种算法的效率非常高，运算十分较少。可以通过蓝桥杯测试系统的变态数据。

点赞