巨大的16进制数转到8进制数

以下是原题

问题描述

　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

　　【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

　　【提示】

　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

一、首先，我没有考虑到数据长度有100000的情况，然后就凉了，下面是第一次的代码：

import java.util.Scanner;
import java.util.Stack;

/**
 * @author QiangweiLuo
 */
public class T0011 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int loop = sc.nextInt();

        while (loop-- > 0) {
            Long in = Long.parseLong(sc.next(), 16);
            //System.out.println(in);
            StringBuilder sb = new StringBuilder();
            Stack<Long> st = new Stack<>();
            while(true){
                long temp = in % 8;
                in /= 8;
                st.push(temp);
                if(in < 8){
                    st.push(in);
                    break;
                }
            }
            while(st.size() > 0)
                sb.append(st.pop());

            System.out.println(sb.toString());
        }
    }
}

二、以下是考虑后的代码：

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * @author QiangweiLuo
 */
public class T0011_1 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int loop = sc.nextInt();
        ArrayList<String> a = new ArrayList<>();
        for(int i = 0; i < loop; i++){
            String in = sc.next();
            StringBuilder sb = new StringBuilder();
            for(int j = in.length() - 1; j >= 0; j-=3){
                String ch = null;
                if(j > 1)
                    ch = "" + in.charAt(j - 2) + in.charAt(j - 1) + in.charAt(j);
                else if(j == 1)
                    ch = "" + in.charAt(j - 1) + in.charAt(j);
                else
                    ch = "" + in.charAt(j);
                int temp = Integer.valueOf(ch, 16);
                String tStr = Integer.toOctalString(temp);
                //System.err.println(tStr);
                if(tStr.length() < 4 && j > 1) tStr = "0" + tStr;
                if(tStr.length() < 4 && j > 1) tStr = "0" + tStr; // 取巧的方法.....
                if(tStr.length() < 4 && j > 1) tStr = "0" + tStr; // 取巧的方法.....
                if(tStr.length() < 4 && j > 1) tStr = "0" + tStr; // 取巧的方法.....
                sb.insert(0, tStr);
            }
            //System.err.println(sb.toString());
            a.add(sb.toString());
        }

        for(int i = 0; i < a.size(); i++){
            System.out.println(a.get(i));
        }
    }
}

我的思路是：

    3的16进制数可以直接化为相当于4个二进制数（一个16进制数4位，一个8进制数3位，4*3/3=4个8进制数）。

    转化从16进制数的末尾开始，设数长为k，分别取k-2，k-1，k这3个16进制数，通过Integer.valueOf()方法转化成10进制，然后再通过Interger.toOctalString()转化成8进制，最后转化的结果如果没有4个字长，且没有取到k-k这个16进制数，补0直到字长4位。 然后接着取 k-5，k-4，k-3这3个16进制数...

    需要做个判断，如果读取到了最后，只有1位或2位的时候，只取那1位或2位二进制数进行转换。

    转换的依次放入字符串的前面，字符串初值是"" 

三、最简单，但是会超时的方法：

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;

public class T0011_2 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int loop = sc.nextInt();
        ArrayList<String> a = new ArrayList<>();
        for(int i = 0; i < loop; i++){
            a.add(new BigInteger(sc.next(), 16).toString(8));
        }

        for(int i = 0; i < a.size(); i++){
            System.out.println(a.get(i));
        }
    }
}