base64.java

一个学习程序

package WebMail;

/**
 * <p>Title: 企业邮箱管理系统</p>
 * <p>Description: 收发邮件</p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: 南京仕邦有限公司</p>
 * @author W.L.B
 * @version 1.0
 */

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 byte PAD                = (byte) '=';
  static private byte [] base64Alphabet       = new byte[BASELENGTH];
  static private byte [] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];
  static
  {
    for (int i = 0; i < BASELENGTH; i++ )
    {
      base64Alphabet[i] = -1;
    }
    for (int i = 'Z'; 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] = (byte) ('A' + i);

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

    for (int i = 52,  j = 0; i <= 61; i++, j++ )
      lookUpBase64Alphabet[i] = (byte) ('0' + j);

    lookUpBase64Alphabet[62] = (byte) '+';
    lookUpBase64Alphabet[63] = (byte) '/';
  }

 public static boolean isBase64( String isValidString )
 {
   return isArrayByteBase64(isValidString.getBytes());
 }

 public static boolean isBase64( byte octect )
 {
   //shall we ignore white space? JEFF??
   return (octect == PAD || base64Alphabet[octect] != -1);
 }

 public static boolean isArrayByteBase64( byte[] arrayOctect )
 {
   int length = arrayOctect.length;
   if (length == 0)
   {
     // shouldn't a 0 length array be valid base64 data?
     // return false;
     return true;
   }
   for (int i=0; i < length; i++)
   {
     if ( !Base64.isBase64(arrayOctect[i]) )
       return false;
   }
   return true;
 }

 /**
     * Encodes hex octects into Base64.
     *
     * @param binaryData Array containing binary data to encode.
     * @return Base64-encoded data.
     */
 public static byte[] encode( byte[] binaryData )
 {
   int      lengthDataBits    = binaryData.length*EIGHTBIT;
   int      fewerThan24bits   = lengthDataBits%TWENTYFOURBITGROUP;
   int      numberTriplets    = lengthDataBits/TWENTYFOURBITGROUP;
   byte     encodedData[]     = null;

   if (fewerThan24bits != 0)
   {
     //data not divisible by 24 bit
     encodedData = new byte[ (numberTriplets + 1 ) * 4 ];
   }
   else
   {
     // 16 or 8 bit
     encodedData = new byte[ numberTriplets * 4 ];
   }

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

   int encodedIndex = 0;
   int dataIndex   = 0;
   int i           = 0;
   for ( i = 0; i<numberTriplets; i++ )
   {
     dataIndex = i*3;
     b1 = binaryData[dataIndex];
     b2 = binaryData[dataIndex + 1];
     b3 = binaryData[dataIndex + 2];

     l  = (byte)(b2 & 0x0f);
     k  = (byte)(b1 & 0x03);

     encodedIndex = i * 4;
     byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
     byte val2 = ((b2 & SIGN)==0)?(byte)(b2>>4):(byte)((b2)>>4^0xf0);
     byte val3 = ((b3 & SIGN)==0)?(byte)(b3>>6):(byte)((b3)>>6^0xfc);

     encodedData[encodedIndex]   = lookUpBase64Alphabet[ val1 ];
     encodedData[encodedIndex+1] =
         lookUpBase64Alphabet[ val2 | ( k<<4 )];
     encodedData[encodedIndex+2] =
         lookUpBase64Alphabet[ (l <<2 ) | val3 ];
     encodedData[encodedIndex+3] = lookUpBase64Alphabet[ b3 & 0x3f ];
   }

   // form integral number of 6-bit groups
   dataIndex    = i*3;
   encodedIndex = i*4;
   if (fewerThan24bits == EIGHTBIT )
   {
     b1 = binaryData[dataIndex];
     k = (byte) ( b1 &0x03 );
     byte val1 = ((b1 & SIGN)==0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
     encodedData[encodedIndex]     = lookUpBase64Alphabet[ val1 ];
     encodedData[encodedIndex + 1] = lookUpBase64Alphabet[ k<<4 ];
     encodedData[encodedIndex + 2] = PAD;
     encodedData[encodedIndex + 3] = PAD;
   }
   else if (fewerThan24bits == SIXTEENBIT)
   {

     b1 = binaryData[dataIndex];
     b2 = binaryData[dataIndex +1 ];
     l = (byte) (b2 & 0x0f);
     k = (byte) (b1 & 0x03);

     byte val1 = ((b1 & SIGN) == 0)?(byte)(b1>>2):(byte)((b1)>>2^0xc0);
     byte val2 = ((b2 & SIGN) == 0)?(byte)(b2>>4):(byte)((b2)>>4^0xf0);

     encodedData[encodedIndex]     = lookUpBase64Alphabet[ val1 ];
     encodedData[encodedIndex + 1] =
         lookUpBase64Alphabet[ val2 | ( k<<4 )];
     encodedData[encodedIndex + 2] = lookUpBase64Alphabet[ l<<2 ];
     encodedData[encodedIndex + 3] = PAD;
   }
   return encodedData;
 }

 /**
  * Decodes Base64 data into octects
  *
  * @param binaryData Byte array containing Base64 data
  * @return Array containing decoded data.
  */
 public static byte[] decode( byte[] base64Data )
 {
   // handle the edge case, so we don't have to worry about it later
   if(base64Data.length == 0) { return new byte[0]; }

   int      numberQuadruple    = base64Data.length/FOURBYTE;
   byte     decodedData[]      = null;
   byte     b1=0,b2=0,b3=0, b4=0, marker0=0, marker1=0;

   // Throw away anything not in base64Data

   int encodedIndex = 0;
   int dataIndex    = 0;
   {
     // this sizes the output array properly - rlw
     int lastData = base64Data.length;
     // ignore the '=' padding
     while (base64Data[lastData-1] == PAD)
     {
       if (--lastData == 0)
       {
         return new byte[0];
       }
     }
     decodedData = new byte[ lastData - numberQuadruple ];
   }

   for (int i = 0; i < numberQuadruple; i++)
   {
     dataIndex = i * 4;
     marker0   = base64Data[dataIndex + 2];
     marker1   = base64Data[dataIndex + 3];

     b1 = base64Alphabet[base64Data[dataIndex]];
     b2 = base64Alphabet[base64Data[dataIndex +1]];

     if (marker0 != PAD && marker1 != PAD)
     {
       //No PAD e.g 3cQl
       b3 = base64Alphabet[ marker0 ];
       b4 = base64Alphabet[ marker1 ];

       decodedData[encodedIndex]   = (byte)(  b1 <<2 | b2>>4 ) ;
       decodedData[encodedIndex + 1] =
           (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) );
       decodedData[encodedIndex + 2] = (byte)( b3<<6 | b4 );
     }
     else if (marker0 == PAD)
     {
       //Two PAD e.g. 3c[Pad][Pad]
       decodedData[encodedIndex]   = (byte)(  b1 <<2 | b2>>4 ) ;
     }
     else if (marker1 == PAD)
     {
       //One PAD e.g. 3cQ[Pad]
       b3 = base64Alphabet[ marker0 ];

       decodedData[encodedIndex]   = (byte)(  b1 <<2 | b2>>4 );
       decodedData[encodedIndex + 1] =
           (byte)(((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) );
     }
     encodedIndex += 3;
   }
   return decodedData;
 }

 /**
  * 测试用
  * @param arg
  */
 public static void main(String arg[])
 {
   String dd = "PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwv"+
       "L0VOIj4NCjxIVE1MPjxIRUFEPg0KPE1FVEEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVu"+
       "dD0idGV4dC9odG1sOyBjaGFyc2V0PWdiMjMxMiI+DQo8TUVUQSBjb250ZW50PSJNU0hUTUwgNi4w"+
       "MC4yNzI2LjI1MDAiIG5hbWU9R0VORVJBVE9SPg0KPFNUWUxFPjwvU1RZTEU+DQo8L0hFQUQ+DQo8"+
       "Qk9EWSBiZ0NvbG9yPSNmZmZmZmY+DQo8RElWPjxGT05UIHNpemU9Mj48L0ZPTlQ+Jm5ic3A7PC9E"+
       "SVY+PC9CT0RZPjwvSFRNTD4NCg==";
   String ss = new String( decode(dd.getBytes()) );
   System.out.println(ss);

 }

}