算法系列（十一）BASE64算法实现和使用说明

完整的BASE64定义可见RFC 1421和RFC 2045。编码后的数据比原始数据略长，为原来的4/3。在电子邮件中，根据RFC 822规定，每76个字符，还需要加上一个回车换行。可以估算编码后数据长度大约为原长的135.1%。

转换的时候，将三个byte的数据，先后放入一个24bit的缓冲区中，先来的byte占高位。数据不足3byte的话，于缓冲器中剩下的bit用0补足。然后，每次取出6（因为2⁶=64）个bit，按照其值选择ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/中的字符作为编码后的输出。不断进行，直到全部输入数据转换完成。

当原数据长度不是3的整数倍时, 如果最后剩下一个输入数据，在编码结果后加2个“=”；如果最后剩下两个输入数据，编码结果后加1个“=”；如果没有剩下任何数据，就什么都不要加，这样才可以保证数据还原的正确性。

例子

举例来说，一段引用自托马斯·霍布斯《利维坦》的文句：

经过Base64编码之后变成：

TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=

• 编码“Man”

在此例中，Base64算法将三个字符编码为4个字符

Base64索引表：

如果要编码的字节数不能被3整除，最后会多出1个或2个字节，那么可以使用下面的方法进行处理：先使用0字节值在末尾补足，使其能够被3整除，然后再进行Base64的编码。在编码后的Base64文本后加上一个或两个‘=‘号，代表补足的字节数。也就是说，当最后剩余一个八位字节（一个byte）时，最后一个6位的Base64字节块有四位是0值，最后附加上两个等号；如果最后剩余两个八位字节（2个byte）时，最后一个6位的base字节块有两位是0值，最后附加一个等号。 参考下表：

public class Base64
{
  /**
    * 将原始数据编码为base64编码
    */
    static public char[] encode(byte[] data)
    {
        char[] out = new char[((data.length + 2) / 3) * 4];

        for (int i = 0, index = 0; i < data.length; i += 3, index += 4)
        {
                boolean quad = false;
                boolean trip = false;
                int val = (0xFF & (int) data[i]);
                val <<= 8;
                if ((i + 1) < data.length)
                {
                        val |= (0xFF & (int) data[i + 1]);
                        trip = true;
                }
                val <<= 8;
                if ((i + 2) < data.length)
                {
                        val |= (0xFF & (int) data[i + 2]);
                        quad = true;
                }
                out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];
                val >>= 6;
                out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];
                val >>= 6;
                out[index + 1] = alphabet[val & 0x3F];
                val >>= 6;
                out[index + 0] = alphabet[val & 0x3F];
        }
        return out;
    }
    /**
    * 将base64编码的数据解码成原始数据
    */
    static public byte[] decode(char[] data)
    {
      int len = ((data.length + 3) / 4) * 3;
      if(data.length > 0 && data[data.length - 1] == '=')
        --len;
      if(data.length > 1 && data[data.length - 2] == '=')
        --len;
      byte[] out = new byte[len];
      int shift = 0;
      int accum = 0;
      int index = 0;
      for(int ix = 0; ix < data.length; ix++)
      {
        int value = codes[data[ix] & 0xFF];
        if(value >= 0)
        {
          accum <<= 6;
          shift += 6;
          accum |= value;
          if(shift >= 8)
          {
            shift -= 8;
            out[index++] = (byte)((accum >> shift) & 0xff);
          }
        }
      }
      if(index != out.length)
        throw new Error("miscalculated data length!");
      return out;
    }

    static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();

    static private byte[] codes = new byte[256];
    static {
            for (int i = 0; i < 256; i++)
                    codes[i] = -1;
            for (int i = 'A'; i <= 'Z'; i++)
                    codes[i] = (byte) (i - 'A');
            for (int i = 'a'; i <= 'z'; i++)
                    codes[i] = (byte) (26 + i - 'a');
            for (int i = '0'; i <= '9'; i++)
                    codes[i] = (byte) (52 + i - '0');
            codes['+'] = 62;
            codes['/'] = 63;
    }

    public static void main(String[] args) throws Exception
    {
      //加密成base64
      String strSrc = "林";
      String strOut = new String(Base64.encode(strSrc.getBytes()));
      System.out.println(strOut);

      String strOut2 = new String(Base64.decode(strOut.toCharArray()));
      System.out.println(strOut2);
    }
}