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这样的数值认为是正数