base64.java

这个是网络上下载的一个struct框架的程序

package com.struts2.framework.util;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Random;

public class Base64
{

    public static final String encode(byte unencoded[])
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream((int)((double)unencoded.length * 1.3700000000000001D));
        int byteCount = 0;
        int carryOver = 0;
        for(int i = 0; i < unencoded.length; i++)
        {
            int bc = byteCount % 3;
            byte b = unencoded[i];
            int lookup = 0;
            if(bc == 0)
            {
                lookup = b >> 2 & 0x3f;
                carryOver = b & 3;
                out.write(chars64[lookup]);
            } else
            if(bc == 1)
            {
                lookup = carryOver << 4 | b >> 4 & 0xf;
                carryOver = b & 0xf;
                out.write(chars64[lookup]);
            } else
            if(bc == 2)
            {
                lookup = carryOver << 2 | b >> 6 & 3;
                out.write(chars64[lookup]);
                lookup = b & 0x3f;
                out.write(chars64[lookup]);
                carryOver = 0;
            }
            byteCount++;
        }

        if(byteCount % 3 == 1)
        {
            int lookup = carryOver << 4 & 0xf0;
            out.write(chars64[lookup]);
            out.write(61);
            out.write(61);
        } else
        if(byteCount % 3 == 2)
        {
            int lookup = carryOver << 2 & 0x3c;
            out.write(chars64[lookup]);
            out.write(61);
        }
        return out.toString();
    }

    public static final byte[] decode(String encoded)
    {
        byte bytes[] = null;
        bytes = encoded.getBytes();
        ByteArrayOutputStream out = new ByteArrayOutputStream((int)((double)bytes.length * 0.67000000000000004D));
        int byteCount = 0;
        int carryOver = 0;
        for(int i = 0; i < bytes.length; i++)
        {
            int ch = bytes[i];
            if(ch == 61)
                break;
            if(ch == 32)
                ch = 43;
            int newbits = ints64[ch];
            int bc = byteCount % 4;
            if(bc == 0)
                carryOver = newbits & 0x3f;
            else
            if(bc == 1)
            {
                int data = (carryOver << 2) + (newbits >> 4 & 3);
                out.write(data);
                carryOver = newbits & 0xf;
            } else
            if(bc == 2)
            {
                int data = (carryOver << 4) + (newbits >> 2 & 0xf);
                out.write(data);
                carryOver = newbits & 3;
            } else
            if(bc == 3)
            {
                int data = (carryOver << 6) + (newbits & 0x3f);
                out.write(data);
                carryOver = 0;
            }
            byteCount++;
        }

        return out.toByteArray();
    }

    public static void main(String args[])
        throws Exception
    {
        test2(args);
    }

    private static void test1(String args[])
    {
        if(args.length > 0)
            str = args[0];
        printString("Start", str);
        String encoded = encode(str.getBytes());
        printString("Encoded", encoded);
        String decoded = new String(decode(encoded));
        printString("Decoded", decoded);
        System.err.println("** " + (decoded.equals(str) ? "SUCCESS" : "FAILURE"));
    }

    public static void test2(String args[])
        throws Exception
    {
        int count = 30;
        if(args.length > 0)
            count = Integer.parseInt(args[0]);
        if(count <= 0)
            count = 30;
        byte data[] = new byte[count];
        Random rand = new Random();
        rand.nextBytes(data);
        printBytes("Source", data);
        String encoded = encode(data);
        printString("Encoded", encoded);
        byte bin[] = decode(encoded);
        printBytes("Final", bin);
        if(bin.length != data.length)
        {
            System.err.println("::FAILURE::");
            return;
        }
        for(int i = 0; i < bin.length; i++)
            if(bin[i] != data[i])
            {
                System.err.println("::FAILURE::");
                return;
            }

        System.err.println("::SUCCESS::");
    }

    private static void printString(String prompt, String s)
    {
        System.err.println("** " + prompt + "='" + s + "' (length=" + s.length() + ")");
    }

    public static void printBytes(String prompt, byte data[])
    {
        System.err.print("** " + prompt + " = [");
        for(int i = 0; i < data.length; i++)
        {
            String sep = ",";
            if(i == 0)
                sep = "";
            System.err.print(sep + data[i]);
        }

        System.err.println("] (length=" + data.length + ")");
    }

    public Base64()
    {
    }

    private static final char chars64[] = {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 
        'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 
        'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
        'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 
        'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', 
        '8', '9', '+', '/'
    };
    private static final int ints64[];
    public static String str = "This is a test";

    static  
    {
        ints64 = new int[128];
        for(int i = 0; i < 64; i++)
            ints64[chars64[i]] = i;

    }
}