Base64的Java代码实现

欢迎拍砖~

在数据二进制和byte互相转换的地方方法写得有点挫，不知道有没有更好的方法~

顺便复习了java的一些基础东西，如位操作，原码反码补码

可以在这篇blog里学习到详细的知识点：http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html

直接上代码吧，知识点在注释上

编码器：

package jdbc.pro.lin;

import java.util.HashMap;
import java.util.Map;

public class MyBase64Encoder {

    private static final Map<Integer, Character> INDEX_MAP = new HashMap<Integer, Character>();

    private static final char PADDING_CHAR = '=';
    static {
        int index = 0;
        for (int i = 0; i <= 25; i++) {
            INDEX_MAP.put(index, (char) ((int) 'A' + i));
            index++;
        }

        for (int j = 0; j <= 25; j++) {
            INDEX_MAP.put(index, (char) ((int) 'a' + j));
            index++;
        }

        for (int k = 0; k <= 9; k++) {
            INDEX_MAP.put(index, (char) ((int) '0' + k));
            index++;
        }

        INDEX_MAP.put(index, '+');
        index++;
        INDEX_MAP.put(index, '/');
    }

    public static String encode(byte[] bytes) throws Exception {
        /**
         * 1.转成二进制的字符串(长度为6的倍数)
         * 2.获取转义后的字符串 
         * 3.不是4的位数，填充=号
         */
        String binaryString = convertByteArray2BinaryString(bytes);
        String escapeString = escapeBinaryString(binaryString);
        return paddingEscapeString(escapeString);
    }

    private static String convertByteArray2BinaryString(byte[] bytes) {

        StringBuilder binaryBuilder = new StringBuilder();
        for (byte b : bytes) {
            binaryBuilder.append(convertByte2BinaryString(b));
        }

        int paddingCount = binaryBuilder.length() % 6;
        int totalCount = paddingCount > 0 ? binaryBuilder.length() / 6 + 1
                : binaryBuilder.length() / 6;
        int actualLength = 6 * totalCount;

        //百分号后面的-号表示长度不够规定长度时，右填充。否则左填充。
        return String.format("%-" + actualLength + "s",
                binaryBuilder.toString()).replace(' ', '0');
    }

    private static String escapeBinaryString(String binaryString)
            throws Exception {
        if (null == binaryString || binaryString.isEmpty()
                || binaryString.length() % 6 != 0) {
            System.out.println("error");
            throw new Exception("escape binary string error.");
        }

        StringBuilder escapeBuilder = new StringBuilder();
        for (int i = 0; i <= binaryString.length() - 1; i += 6) {
            String escapeString = binaryString.substring(i, i + 6);
            int index = Integer.parseInt(escapeString, 2);
            escapeBuilder.append(INDEX_MAP.get(index));
        }

        return escapeBuilder.toString();
    }

    private static String paddingEscapeString(String escapeString) {
        int paddingCount = escapeString.length() % 4;
        int totalCount = paddingCount > 0 ? escapeString.length() / 4 + 1
                : escapeString.length() / 4;
        int actualCount = 4 * totalCount;
        return String.format("%-" + actualCount + "s", escapeString).replace(
                ' ', PADDING_CHAR);
    }

    private static String convertByte2BinaryString(byte b) {
        
        /**
         * 对于非负数，直接使用Integer.toBinaryString方法把它打印出来
         */
        if (b >= 0) {
            StringBuilder builder = new StringBuilder();
            builder.append(Integer.toBinaryString(b));
            return String.format("%08d", Integer.parseInt(builder.toString()));
        } else {
            /**
             * 对于负数，要记住内存保存的是补码。
             * 不能直接使用Byte.parseByte()方法。
             * 因为这个方法最终调的是Integer.parseInt()方法，也就是说，负数如：10000001
             * 对Integer.parseInt()来说并不会认为是负数，符号位1被当作数值位，是129
             * 同时Byte.parseByte()方法里还对数值范围做了校验，符号位1，已超出范围，这样
             * 会抛出异常。而Byte又没有提供toBinaryString的方法
             * 为了保存byte的二进制值，可利用按位与的方法
             * 例如有一个负数1000 1111，要把它以字符串保留出来，利用它与1111 1111的与操作，
             * 再转成int类型。1000 1111 & 1111 1111
             * 在内存中保存的就是 00000000 10001111，这时保存的是一个正整数。但我们不关心整数的正负，
             * 因为我们的目的是要把这串字符串截取出来
             * 再利用Integer.toBinaryString()打印出来。
             * Integer.toBinaryString()对于正数，会将前面的零去掉，如上将打印出1000 1111，这就是我们要的结果。
             */
            int value = b & 0xFF;
            return Integer.toBinaryString(value);
        }
    }

}

解码器：

package jdbc.pro.lin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyBase64Decoder {
    private static final char PADDING_CHAR = '=';

    private static final Map<Character, Integer> VALUE_MAP = new HashMap<Character, Integer>();
    static {
        int index = 0;
        for (char i = 'A'; i <= 'Z'; i++, index++) {
            VALUE_MAP.put(i, index);
        }

        for (char j = 'a'; j <= 'z'; j++, index++) {
            VALUE_MAP.put(j, index);
        }

        for (char k = '0'; k <= '9'; k++, index++) {
            VALUE_MAP.put(k, index);
        }

        VALUE_MAP.put('+', index);
        index++;
        VALUE_MAP.put('/', index);
    }

    public static byte[] decode(String base64String) {

        if (null == base64String || base64String.isEmpty()) {
            return null;
        }
        /**
         * 1.去掉末尾拼凑的=符号 2.转成二进制 3.去掉末尾拼凑的0 4.截取每8位取数
         */
        base64String = removePaddingChar(base64String);
        String binaryString = getBinaryString(base64String);
        binaryString = removePaddingNumber(binaryString);

        return convertBinaryString2Bytes(binaryString);

    }

    /**
     * 删除末尾拼凑的=符号
     * 
     * @param base64String
     * @return
     */
    private static String removePaddingChar(String base64String) {
        int firstPaddingIndex = base64String.indexOf(PADDING_CHAR);
        return firstPaddingIndex >= 0 ? base64String.substring(0,
                firstPaddingIndex) : base64String;
    }

    /**
     * 将base64字符串转成二进制字符串
     * 
     * @param base64String
     * @return
     */
    private static String getBinaryString(String base64String) {
        StringBuilder binaryBuilder = new StringBuilder();
        for (char c : base64String.toCharArray()) {
            int value = VALUE_MAP.get(c);
            binaryBuilder.append(String.format("%6s",
                    Integer.toBinaryString(value)).replace(" ", "0"));
        }

        return binaryBuilder.toString();
    }

    /**
     * 二进制字符串中的末尾有一些0是因为不足6的倍数而填充的，需要删除
     * 
     * @param binaryString
     * @return
     */
    private static String removePaddingNumber(String binaryString) {
        int remainder = binaryString.length() % 8;

        binaryString = binaryString.substring(0, binaryString.length()
                - remainder);

        return binaryString;
    }

    private static byte[] convertBinaryString2Bytes(String binaryString) {
        if (null == binaryString || binaryString.length() % 8 != 0) {
            System.out.println("binary string not well formatted.");
            return null;
        }
        int size = binaryString.length() / 8;
        byte[] bytes = new byte[size];
        int arrayIndex = 0;
        for (int i = 0; i <= binaryString.length() - 1; i += 8, arrayIndex++) {
            String byteString = binaryString.substring(i, i + 8);
            /**
             * 非负数，直接使用Byte.parseByte()方法
             */
            if (byteString.startsWith("0")) {
                bytes[arrayIndex] = Byte.parseByte(byteString, 2);
            } else {
                /**
                 * 10000000为-128是规定而来的。 -128并没有原码和反码表示。对-128的补码表示[10000000]补
                 * 算出来的原码是[0000 0000]原, 这是不正确的)
                 */
                if (byteString.equals("1000000")) {
                    bytes[arrayIndex] = (byte) -128;
                    continue;
                }
                /**
                 * 其他的负数，就要按照补码的规则来计算 即，原码取反+1=补码 那么，补码-1取反=原码
                 * 注意这都是真值部分的计算，符号位不能变
                 */
                // 补码
                String twosComplement = byteString.substring(1);
                byte twoComplementValue = Byte.parseByte(twosComplement, 2);

                // 反码
                byte oneComplementValue = (byte) (twoComplementValue - 1);

                /**
                 * 这里用到的是0x7F而不是0xFF。因为oneComplementValue是0开头
                 * 若与1开头的异或，结果为1，而在int中该位不是符号位，会当成数值计算，造成数值错误。
                 * 因此，必须结果是0，即，两个0的异或。
                 */
                // 真值 8位的计算
                int trueValue = oneComplementValue ^ 0x7F;

                bytes[arrayIndex] = (byte) (trueValue * (-1));

            }
        }

        return bytes;
    }
}

测试代码：

package jdbc.pro.lin;

import oracle.net.aso.i;

import org.apache.commons.codec.binary.Base64;

public class TestMain {
    public static void main(String[] args) throws Exception {
        byte[] binaryData = { 0, -2, -128, 127, 1, -1, 3, 4, 89, 45, 0 };
        String thirdPartyBase64String = Base64.encodeBase64String(binaryData);
        String myBase64String = MyBase64Encoder.encode(binaryData);
        System.out.println("ThirdParty encode: " + thirdPartyBase64String);
        System.out.println("MyBase64 encode: " + myBase64String);

        System.out.print("ThirdParty decode: ");
        printBytes(Base64.decodeBase64(thirdPartyBase64String.getBytes()));

        System.out.print("MyBase64 decode: ");
        printBytes(MyBase64Decoder.decode(thirdPartyBase64String));
        
    }

    private static void printBytes(byte[] bytes) {
        for (byte b : bytes) {
            System.out.print(b);
            System.out.print(" ");
        }
        System.out.println("");
    }
}

测试结果：

附Byte.parseByte()的反编译源码，确实是调用了Integer.parseInt()方法，导致符号位失效，对于10001111这样的数值认为是正数