Base64 - flyweight RFC 4648 compliant base64 implementation

You can find a multitude of Base64 libraries out there... If you do not need stream processing, here you go with a flyweight, fast implementation totaling to 64 lines of code.

/*
 * Lithium Utilities
 * 
 * Copyright 2003-2014 Tibor Bősze <tibor.boesze@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package hu.lithium.utils.crypto;

/**
 * Utility class for encoding/decoding Base64 strings.
 * 
 * @author tibor.boesze@gmail.com
 * @version 1.1
 */
public class Base64 {

	private static final char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
	private static final byte[] decoder = new byte[256];
	static {
		for (int i = 0; i < 256; i++)
			decoder[i] = -1;
		for (int i = 0; i < 64; i++)
			decoder[alphabet[i]] = (byte) i;
	}

	private Base64() {
	}
	
	public static String encodeString(String s) {
		return new String(encode(s.getBytes()));
	}

	public static char[] encode(byte[] in) {
		return encode(in, in.length);
	}

	public static char[] encode(byte[] in, int iLen) {
		int oDataLen = (iLen * 4 + 2) / 3; // output length without padding
		int oLen = ((iLen + 2) / 3) * 4; // output length including padding
		char[] out = new char[oLen];
		int ip = 0;
		int op = 0;
		while (ip < iLen) {
			int i0 = in[ip++] & 0x000000ff;
			int i1 = ip < iLen ? in[ip++] & 0x000000ff : 0;
			int i2 = ip < iLen ? in[ip++] & 0x000000ff : 0;
			int o0 = i0 >>> 2;
			int o1 = ((i0 & 3) << 4) | (i1 >>> 4);
			int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
			int o3 = i2 & 0x3F;
			out[op++] = alphabet[o0];
			out[op++] = alphabet[o1];
			out[op] = op < oDataLen ? alphabet[o2] : '=';
			op++;
			out[op] = op < oDataLen ? alphabet[o3] : '=';
			op++;
		}
		return out;
	}

	/**
	 * Decodes a string from Base64 format.
	 * 
	 * @param s
	 *            a Base64 String to be decoded.
	 * @return A String containing the decoded data.
	 * @throws IllegalArgumentException
	 *             if the input is not valid Base64 encoded data.
	 */
	public static String decodeString(String s) {
		return new String(decode(s));
	}

	/**
	 * Decodes a byte array from Base64 format.
	 * 
	 * @param s
	 *            a Base64 String to be decoded.
	 * @return An array containing the decoded data bytes.
	 * @throws IllegalArgumentException
	 *             if the input is not valid Base64 encoded data.
	 */
	public static byte[] decode(String s) {
		return decode(s.toCharArray());
	}

	/**
	 * Decodes a byte array from Base64 format. No blanks or line breaks are
	 * allowed within the Base64 encoded data.
	 * 
	 * @param in
	 *            a character array containing the Base64 encoded data.
	 * @return An array containing the decoded data bytes.
	 * @throws IllegalArgumentException
	 *             if the input is not valid Base64 encoded data.
	 */
	public static byte[] decode(char[] in) {
		int iLen = in.length;
		if (iLen % 4 != 0)
			throw new IllegalArgumentException("Length of Base64 encoded input string is not a multiple of 4.");
		while (iLen > 0 && in[iLen - 1] == '=')
			iLen--;
		int oLen = (iLen * 3) / 4;
		byte[] out = new byte[oLen];
		int ip = 0;
		int op = 0;
		while (ip < iLen) {
			int i0 = in[ip++] & 0x000000ff;
			int i1 = in[ip++] & 0x000000ff;
			int i2 = ip < iLen ? in[ip++] & 0x000000ff : 'A';
			int i3 = ip < iLen ? in[ip++] & 0x000000ff : 'A';
			
			int b0 = decoder[i0];
			int b1 = decoder[i1];
			int b2 = decoder[i2];
			int b3 = decoder[i3];
			if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
				throw new IllegalArgumentException("Illegal character in Base64 encoded data.");
			int o0 = (b0 << 2) | (b1 >>> 4);
			int o1 = ((b1 & 0xf) << 4) | (b2 >>> 2);
			int o2 = ((b2 & 3) << 6) | b3;
			out[op++] = (byte) o0;
			if (op < oLen)
				out[op++] = (byte) o1;
			if (op < oLen)
				out[op++] = (byte) o2;
		}
		return out;
	}
	
}