Java实现Base64互相编解码转换图片与字符串

Base64基本算法原理

字符串实例(对s13进行Base64编解码)
测试：s13
编码：czEz
解码：s13

如何编码s13为czEz的过程分析：

Base64要求把每三个8Bit的字节转换为四个6Bit的字节（3*8 = 4*6 = 24），然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。
s13二进制之间的3*8到4*6的过程
115 49 51
01110011 00110001 00110011（asc转到二进制）
011100 110011 000100 110011（分为4组）
00011100 00110011 00000100 00110011（补全8位一组）
28 51 4 51（得到编码后的asc）
czEz（对应的字符串）
———百度百科

这里介绍三种方法：
1 使用commons-codec.jar包
下载地址http://commons.apache.org/proper/commons-codec/download_codec.cgi
Commons项目中用来处理常用的编码方法的工具类包，例如DES、SHA1、MD5、Base64，URL，Soundx等
不仅是编码，也可用于解码。
2 使用sun.misc.BASE64Encoder
JDK中包含了BASE64Encoder，可以直接使用，但是因为它不属于JDK的标准库范畴，所以eclipse无法直接找到，需要进行相关的配置；
3 直接编写base64的转换逻辑
使用base64进行对字节的转换

commons-codec.jar进行base64转换

// 需要下载应用commons-codec.jar包
package commonscodec.demo.base64;

import java.io.UnsupportedEncodingException;
import org.apache.commons.codec.binary.Base64;

public class Main {
    public static void main(String[] args) {

        String str = "s13";
        Base64 base64 = new Base64();
        try {
            str = base64.encodeToString(str.getBytes("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println("Base64 编码后：" + str);
    }
}

sun.misc.BASE64Encoder进行base64转换

// 如果找不到sun.misc.BASE64Decoder包,需要进行相关的配置
package sunmisc.demo.base64;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
///
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Main {
    public static void main(String[] args) {
        String strImg = GetImageStr();
        System.out.println(strImg);
        GenerateImage(strImg);
    }

    // 图片转化成base64字符串
    public static String GetImageStr() {
        // 将图片文件转化为字节数组字符串，并对其进行Base64编码处理
        String imgFile = "d://test.png";
        InputStream in = null;
        byte[] data = null;
        // 读取图片字节数组
        try {
            in = new FileInputStream(imgFile);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 对字节数组Base64编码
        BASE64Encoder encoder = new BASE64Encoder();
        // 返回Base64编码过的字节数组字符串
        return encoder.encode(data);
    }

    // base64字符串转化成图片
    public static boolean GenerateImage(String imgStr) {
        // 对字节数组字符串进行Base64解码并生成图片
        if (imgStr == null)
            return false;
        BASE64Decoder decoder = new BASE64Decoder();
        try {
            // Base64解码
            byte[] b = decoder.decodeBuffer(imgStr);
            for (int i = 0; i < b.length; ++i) {
                if (b[i] < 0) {// 调整异常数据
                    b[i] += 256;
                }
            }
            // 生成新的图片
            String imgFilePath = "d://222.png";
            OutputStream out = new FileOutputStream(imgFilePath);
            out.write(b);
            out.flush();
            out.close();
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

如果找不到sun.misc.BASE64Decoder包,需要进行相关的配置如下
右键项目-》属性-》Java bulid path-》jre System Library-》access rules-》resolution选择accessible填上** ，点击确定完成配置

直接编写逻辑进行base64转换

//来自http://blog.csdn.net/lastsweetop/article/details/5314640
package com.test.base64;

public class Main {
    /**
     * 将原始数据编码为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 = "s13";
        String strOut = new String(Main.encode(strSrc.getBytes("GB18030")));
        System.out.println("测试：s13");
        System.out.println("编码：" + strOut);
        String strOut2 = new String(Main.decode(strOut.toCharArray()),
                "GB18030");
        System.out.println("解码：" + strOut2);
    }
}

测试代码来自网络
三个测试源码下载 http://pan.baidu.com/s/1kVfiEs3
测试结果

测试：s13
编码：czEz
解码：s13