基于Java实现的Base64加密、解密原理代码

public final class Base64 {

 static private final int BASELENGTH = 255;
 static private final int LOOKUPLENGTH = 64;
 static private final int TWENTYFOURBITGROUP = 24;
 static private final int EIGHTBIT = 8;
 static private final int SIXTEENBIT = 16;
 static private final int SIXBIT = 6;
 static private final int FOURBYTE = 4;
 static private final int SIGN = -128;
 static private final char PAD = '=';
 static private final boolean fDebug = false;
 static final private byte[] base64Alphabet = new byte[BASELENGTH];
 static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

 static {

 for (int i = 0; i = 'A'; i--) {
  base64Alphabet[i] = (byte) (i - 'A');
 }
 for (int i = 'z'; i >= 'a'; i--) {
  base64Alphabet[i] = (byte) (i - 'a' + 26);
 }

 for (int i = '9'; i >= '0'; i--) {
  base64Alphabet[i] = (byte) (i - '0' + 52);
 }

 base64Alphabet['+'] = 62;
 base64Alphabet['/'] = 63;

 for (int i = 0; i <= 25; i++)
  lookUpBase64Alphabet[i] = (char) ('A' + i);

 for (int i = 26, j = 0; i <= 51; i++, j++)
  lookUpBase64Alphabet[i] = (char) ('a' + j);

 for (int i = 52, j = 0; i <= 61; i++, j++)
  lookUpBase64Alphabet[i] = (char) ('0' + j);
 lookUpBase64Alphabet[62] = (char) '+';
 lookUpBase64Alphabet[63] = (char) '/';

 }

 protected static boolean isWhiteSpace(char octect) {
 return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
 }

 protected static boolean isPad(char octect) {
 return (octect == PAD);
 }

 protected static boolean isData(char octect) {
 return (base64Alphabet[octect] != -1);
 }

 protected static boolean isBase64(char octect) {
 return (isWhiteSpace(octect) || isPad(octect) || isData(octect));
 }

 /**
 * Encodes hex octects into Base64
 * 
 * @param binaryData
 *      Array containing binaryData
 * @return Encoded Base64 array
 */
 public static String encode(byte[] binaryData) {

 if (binaryData == null)
  return null;

 int lengthDataBits = binaryData.length * EIGHTBIT;
 if (lengthDataBits == 0) {
  return "";
 }

 int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
 int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
 int numberQuartet = fewerThan24bits != 0 &＃63; numberTriplets + 1
  : numberTriplets;
 int numberLines = (numberQuartet - 1) / 19 + 1;
 char encodedData[] = null;

 encodedData = new char[numberQuartet * 4 + numberLines];

 byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

 int encodedIndex = 0;
 int dataIndex = 0;
 int i = 0;
 if (fDebug) {
  System.out.println("number of triplets = " + numberTriplets);
 }

 for (int line = 0; line > 4);
  decodedData[encodedIndex++] = (byte) (((b2 & 0xf) <<4) | ((b3 >> 2) & 0xf));
  decodedData[encodedIndex++] = (byte) (b3 <<6 | b4);
 }

 if (!isData((d1 = base64Data[dataIndex++]))
  || !isData((d2 = base64Data[dataIndex++]))) {
  return null;// if found "no data" just return null
 }

 b1 = base64Alphabet[d1];
 b2 = base64Alphabet[d2];

 d3 = base64Data[dataIndex++];
 d4 = base64Data[dataIndex++];
 if (!isData((d3)) || !isData((d4))) {// Check if they are PAD characters
  if (isPad(d3) && isPad(d4)) { // Two PAD e.g. 3c[Pad][Pad]
  if ((b2 & 0xf) != 0)// last 4 bits should be zero
   return null;
  byte[] tmp = new byte[i * 3 + 1];
  System.arraycopy(decodedData, 0, tmp, 0, i * 3);
  tmp[encodedIndex] = (byte) (b1 <<2 | b2 >> 4);
  return tmp;
  } else if (!isPad(d3) && isPad(d4)) { // One PAD e.g. 3cQ[Pad]
  b3 = base64Alphabet[d3];
  if ((b3 & 0x3) != 0)// last 2 bits should be zero
   return null;
  byte[] tmp = new byte[i * 3 + 2];
  System.arraycopy(decodedData, 0, tmp, 0, i * 3);
  tmp[encodedIndex++] = (byte) (b1 <<2 | b2 >> 4);
  tmp[encodedIndex] = (byte) (((b2 & 0xf) <<4) | ((b3 >> 2) & 0xf));
  return tmp;
  } else {
  return null;// an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX"
    // where X is non data
  }
 } else { // No PAD e.g 3cQl
  b3 = base64Alphabet[d3];
  b4 = base64Alphabet[d4];
  decodedData[encodedIndex++] = (byte) (b1 <<2 | b2 >> 4);
  decodedData[encodedIndex++] = (byte) (((b2 & 0xf) <<4) | ((b3 >> 2) & 0xf));
  decodedData[encodedIndex++] = (byte) (b3 <<6 | b4);

 }

 return decodedData;
 }

 /**
 * remove WhiteSpace from MIME containing encoded Base64 data.
 * 
 * @param data
 *      the byte array of base64 data (with WS)
 * @return the new length
 */
 protected static int removeWhiteSpace(char[] data) {
 if (data == null)
  return 0;

 // count characters that's not whitespace
 int newSize = 0;
 int len = data.length;
 for (int i = 0; i