Java实现Base64工具类（编码和解码）

最新推荐文章于 2024-06-13 09:43:23 发布

嘉禾嘉宁papa

最新推荐文章于 2024-06-13 09:43:23 发布

阅读量1.1w

点赞数 6

分类专栏： Java常用工具类文章标签： java base64 字符串

本文链接：https://blog.csdn.net/Alian_1223/article/details/117459951

版权

Java常用工具类专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、Base64简介

Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。大家可查看RFC2045～RFC2049，上面有MIME的详细规范。

Base64转换表

索引	对应的字符	索引	对应的字符	索引	对应的字符
0	A	26	a	52	0
1	B	27	b	53	1
2	C	28	c	54	2
3	D	29	d	55	3
4	E	30	e	56	4
5	F	31	f	57	5
6	G	32	g	58	6
7	H	33	h	59	7
8	I	34	i	60	8
9	J	35	j	61	9
10	K	36	k	62	+
11	L	37	l	63	/
12	M	38	m
13	N	39	n
14	O	40	o
15	P	41	p
16	Q	42	q
17	R	43	r
18	S	44	s
19	T	45	t
20	U	46	u
21	V	47	v
22	W	48	w
23	X	49	x
24	Y	50	y
25	Z	51	z

二、Base64编译过程

获取原始字符串对应的ASCII的值
把ASCII的值转成二进制数据
把所有的二进制数据进行合并
将合并后的数据每6个一组进行分组，不足6位则补零
把分组后的数据前面补两个零变成二进制
把补零后的二进制数据转换为十进制
参照base64转换表找到对应的数值
对结果长度不是4的倍数则进行填充（一般是"="符号）

Base64编译过程图解如下：
在这里插入图片描述
编译结果校验：

/**
     * Java原生Base64编码校验（Alian编码后的值）
     * 此处单元测试的注解是采用:org.junit.Test
     */
    @Test
    public void verify() {
        System.out.println("------------------Java原生Base64编码校验--------------------------");
        //定义要编码的字符串
        String plainText = "Alian";
        System.out.println("原始字符串：" + plainText);
        //获取Java原生的Base64编码对象(java.util.Base64.getEncoder())
        String encode = Base64.getEncoder().encodeToString(plainText.getBytes(StandardCharsets.UTF_8));
        System.out.println("Java原生编码后的base64字符串：" + encode);
    }

运行结果：

------------------Java原生Base64编码校验--------------------------
原始字符串：Alian
Java原生编码后的base64字符串：QWxpYW4=

由此可见，我们的编译流程得出的结果和Java原生得到的结果是一致的，解码流程就反过来就行了。

三、Base64工具类

来来来，直接上工具类，进行测试。

Base64Util.java

package com.alian.csdn.utils;

/**
 * @program: CSDN
 * @description: Base64工具类
 * @author: Alian
 * @create: 2021-06-02 11:20:10
 **/
public final class Base64Util {

    static private final int BASELENGTH = 128;
    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 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 < 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] = (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] = '+';
        lookUpBase64Alphabet[63] = '/';
    }

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

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

    private static boolean isData(char octect) {
        return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    }

    /**
     * 将十六进制八位字节编码为Base64
     *
     * @param binaryData 包含二进制数据的数组
     * @return 编码Base64字符串
     */
    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 ? numberTriplets + 1 : numberTriplets;
        char[] encodedData = new char[numberQuartet * 4];
        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        if (fDebug) {
            System.out.println("number of triplets = " + numberTriplets);
        }
        for (int i = 0; i < numberTriplets; i++) {
            b1 = binaryData[dataIndex++];
            b2 = binaryData[dataIndex++];
            b3 = binaryData[dataIndex++];
            if (fDebug) {
                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3);
            }
            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);
            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
            if (fDebug) {
                System.out.println("val2 = " + val2);
                System.out.println("k4   = " + (k << 4));
                System.out.println("vak  = " + (val2 | (k << 4)));
            }
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
        }
        if (fewerThan24bits == EIGHTBIT) {
            b1 = binaryData[dataIndex];
            k = (byte) (b1 & 0x03);
            if (fDebug) {
                System.out.println("b1=" + b1);
                System.out.println("b1<<2 = " + (b1 >> 2));
            }
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
            encodedData[encodedIndex++] = PAD;
            encodedData[encodedIndex++] = 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++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
            encodedData[encodedIndex++] = PAD;
        }
        return new String(encodedData);
    }

    /**
     * 将Base64数据解码为八位字节
     *
     * @param encoded 包含Base64数据的字符串
     * @return 包含解码数据的数组.
     */
    public static byte[] decode(String encoded) {
        if (encoded == null) {
            return null;
        }
        char[] base64Data = encoded.toCharArray();
        //删除空白
        int len = removeWhiteSpace(base64Data);
        //应该可以被四整除
        if (len % FOURBYTE != 0) {
            return null;
        }
        int numberQuadruple = (len / FOURBYTE);
        if (numberQuadruple == 0) {
            return new byte[0];
        }
        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
        int i = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        byte[] decodedData = new byte[(numberQuadruple) * 3];
        for (; i < numberQuadruple - 1; i++) {
            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                    || !isData((d3 = base64Data[dataIndex++]))
                    || !isData((d4 = base64Data[dataIndex++]))) {
                return null;
            }//没有数据直接返回null
            b1 = base64Alphabet[d1];
            b2 = base64Alphabet[d2];
            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);
        }
        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
            return null;没有数据直接返回null
        }
        b1 = base64Alphabet[d1];
        b2 = base64Alphabet[d2];
        d3 = base64Data[dataIndex++];
        d4 = base64Data[dataIndex++];
        if (!isData((d3)) || !isData((d4))) {
            //检查是否为填充字符
            if (isPad(d3) && isPad(d4)) {
                if ((b2 & 0xf) != 0) {//最后四位应为0
                    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)) {
                b3 = base64Alphabet[d3];
                if ((b3 & 0x3) != 0){//最后2位应为零
                    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;
            }
        } 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;
    }

    /**
     * 从包含编码Base64数据的MIME中删除空白
     *
     * @param data base64数据的字节数组（带空白）
     * @return 新的长度
     */
    private static int removeWhiteSpace(char[] data) {
        if (data == null) {
            return 0;
        }
        int newSize = 0;
        int len = data.length;
        for (int i = 0; i < len; i++) {
            if (!isWhiteSpace(data[i])) {
                data[newSize++] = data[i];
            }
        }
        return newSize;
    }
}

四、实践

对于Base64的编码和解码我一般是推荐使用：java.util.Base64

java.util.Base64

    /**
     * Java原生Base64编码和解码
     * 此处单元测试的注解是采用:org.junit.Test
     */
    @Test
    public void javaBase64(){
        System.out.println("------------------Java原生Base64编码、解码--------------------------");
        //定义要编码的字符串
        String plainText="https://blog.csdn.net/Alian_1223";
        System.out.println("原始字符串："+plainText);
        System.out.println("原始字符串长度："+plainText.length());
        //获取Java原生的Base64编码对象(java.util.Base64.getEncoder())
        String encode = Base64.getEncoder().encodeToString(plainText.getBytes(StandardCharsets.UTF_8));
        System.out.println("Java原生编码后的base64字符串："+encode);
        System.out.println("Java原生编码后的base64字符串长度："+encode.length());
        //获取Java原生的Base64解码密对象(java.util.Base64.getDecoder())
        byte[] decode = Base64.getDecoder().decode(encode);
        System.out.println("Java原生解码后的字符串："+new String(decode));
        System.out.println("Java原生解码后的字符串长度："+new String(decode).length());
    }

运行结果：

------------------Java原生Base64编码、解码--------------------------
原始字符串：https://blog.csdn.net/Alian_1223
原始字符串长度：32
Java原生编码后的base64字符串：aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWFuXzEyMjM=
Java原生编码后的base64字符串长度：44
Java原生解码后的字符串：https://blog.csdn.net/Alian_1223
Java原生解码后的字符串长度：32

Base64Util.java

既然我们的工具类也写好了，我们也测试一下我们的工具类Base64Util。

    /**
     * Base64Util编码和解码
     * 此处单元测试的注解是采用:org.junit.Test
     */
    @Test
    public void base64Util(){
        System.out.println("------------------Base64Util编码、解码--------------------------");
        String plainText="https://blog.csdn.net/Alian_1223";
        System.out.println("原始字符串："+plainText);
        System.out.println("原始字符串长度："+plainText.length());
        //直接调用encode方法
        String encode = Base64Util.encode(plainText.getBytes(StandardCharsets.UTF_8));
        System.out.println("Base64Util编码后的base64字符串："+encode);
        System.out.println("Base64Util编码后的base64字符串长度："+encode.length());
        //直接调用decode方法
        byte[] decode = Base64Util.decode(encode);
        System.out.println("Base64Util解码后的字符串："+new String(decode));
        System.out.println("Base64Util解码后的字符串长度："+new String(decode).length());
    }

运行结果：

------------------Base64Util编码、解码--------------------------
原始字符串：https://blog.csdn.net/Alian_1223
原始字符串长度：32
Base64Util编码后的base64字符串：aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FsaWFuXzEyMjM=
Base64Util编码后的base64字符串长度：44
Base64Util解码后的字符串：https://blog.csdn.net/Alian_1223
Base64Util解码后的字符串长度：32

不管是使用Java原生的Base64，还是使用我们自己的工具类，结果都是一样的。但是Java原生Base64工具是从JDK1.8开始加的，如果你的环境低于JDK1.8的话，比如1.6，还是可以使用我们的工具类Base64Util来实现编码和解码的。Base64编码之后的文本，要比原文大约三分之一，同时如果是sun.misc.BASE64Encoder还可能出现换行的情况，大家也要注意点。

结语

以上就是今天要讲的内容，本文简单介绍了Base64，并编写了一个Base64Util工具类，用Java原生的Base64及我们的工具类都实现了Base64的编码和解码，但是我还是建议大家使用Java原生的【java.util.Base64】工具类，开箱即用，并且还减少了程序的代码量。如果觉得对你有帮助，欢迎大家评论交流。

嘉禾嘉宁papa

关注

6
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
Java实现Base64工具类（编码和解码）

目录一、Base64简介二、Base64编译过程三、Base64工具类四、实践结语一、Base64简介 Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。大家可查看RFC2045～RFC2049，上面有MIME的详细规范。Base64转换表索引对应的字符索引对应的字符索引对应的字符0A26a5201B27b5312C28c5423D29d
复制链接

扫一扫

专栏目录

索引	对应的字符	索引	对应的字符	索引	对应的字符
0	A	26	a	52	0
1	B	27	b	53	1
2	C	28	c	54	2
3	D	29	d	55	3
4	E	30	e	56	4
5	F	31	f	57	5
6	G	32	g	58	6
7	H	33	h	59	7
8	I	34	i	60	8
9	J	35	j	61	9
10	K	36	k	62	+
11	L	37	l	63	/
12	M	38	m
13	N	39	n
14	O	40	o
15	P	41	p
16	Q	42	q
17	R	43	r
18	S	44	s
19	T	45	t
20	U	46	u
21	V	47	v
22	W	48	w
23	X	49	x
24	Y	50	y
25	Z	51	z

索引	对应的字符	索引	对应的字符	索引	对应的字符
0	A	26	a	52	0
1	B	27	b	53	1
2	C	28	c	54	2
3	D	29	d	55	3
4	E	30	e	56	4
5	F	31	f	57	5
6	G	32	g	58	6
7	H	33	h	59	7
8	I	34	i	60	8
9	J	35	j	61	9
10	K	36	k	62	+
11	L	37	l	63	/
12	M	38	m
13	N	39	n
14	O	40	o
15	P	41	p
16	Q	42	q
17	R	43	r
18	S	44	s
19	T	45	t
20	U	46	u
21	V	47	v
22	W	48	w
23	X	49	x
24	Y	50	y
25	Z	51	z

Java实现Base64工具类（编码和解码）

目录

一、Base64简介

二、Base64编译过程

三、Base64工具类

四、实践

结语

“相关推荐”对你有帮助么？

索引	对应的字符	索引	对应的字符	索引	对应的字符
0	A	26	a	52	0
1	B	27	b	53	1
2	C	28	c	54	2
3	D	29	d	55	3
4	E	30	e	56	4
5	F	31	f	57	5
6	G	32	g	58	6
7	H	33	h	59	7
8	I	34	i	60	8
9	J	35	j	61	9
10	K	36	k	62	+
11	L	37	l	63	/
12	M	38	m
13	N	39	n
14	O	40	o
15	P	41	p
16	Q	42	q
17	R	43	r
18	S	44	s
19	T	45	t
20	U	46	u
21	V	47	v
22	W	48	w
23	X	49	x
24	Y	50	y
25	Z	51	z