public Base64Decoder(String input) 
{
		byte bytes[];
		try
		{
			bytes = input.getBytes("ISO-8859-1");
		}
		catch (UnsupportedEncodingException ex)
		{
			throw new RuntimeException(
				this.getClass().getName()
					+ "[Constructor] Unable to convert"
					+ "properly char to bytes");
		}
		this.stringp = true;
		this.in = new ByteArrayInputStream(bytes);
		this.out = new ByteArrayOutputStream();
}

Create a decoder to decode a String.

Parameters:

input - The string to be decoded.

 public Base64Decoder(InputStream in,
    OutputStream out) 
{
		this.in = in;
		this.out = out;
		this.stringp = false;
}

Create a decoder to decode a stream.

Parameters:

in - The input stream (to be decoded).

out - The output stream, to write decoded data to.

 public static  void main(String[] args) 
{
		if (args.length == 1)
		{
			try
			{
				Base64Decoder b = new Base64Decoder(args[0]);
				System.out.println("[" + b.processString() + "]");
			}
			catch (Base64FormatException e)
			{
				System.out.println("Invalid Base64 format !");
				System.exit(1);
			}
		}
		else if ((args.length == 2) && (args[0].equals("-f")))
		{
			try
			{
				FileInputStream in = new FileInputStream(args[1]);
				Base64Decoder b = new Base64Decoder(in, System.out);
				b.process();
			}
			catch (Exception ex)
			{
				System.out.println("error: " + ex.getMessage());
				System.exit(1);
			}
		}
		else
		{
			System.out.println("Base64Decoder [strong] [-f file]");
		}
		System.exit(0);
}

Test the decoder. Run it with one argument: the string to be decoded, it will print out the decoded value.

 public  void process() throws Base64FormatException, IOException 
{
		byte buffer[] = new byte[BUFFER_SIZE];
		byte chunk[] = new byte[4];
		int got = -1;
		int ready = 0;
		fill : while ((got = in.read(buffer))  > 0)
		{
			int skiped = 0;
			while (skiped <  got)
			{
				// Check for un-understood characters:
				while (ready <  4)
				{
					if (skiped  >= got)
						continue fill;
					int ch = check(buffer[skiped++]);
					if (ch  >= 0)
						chunk[ready++] = (byte) ch;
				}
				if (chunk[2] == 65)
				{
					out.write(get1(chunk, 0));
					return;
				}
				else if (chunk[3] == 65)
				{
					out.write(get1(chunk, 0));
					out.write(get2(chunk, 0));
					return;
				}
				else
				{
					out.write(get1(chunk, 0));
					out.write(get2(chunk, 0));
					out.write(get3(chunk, 0));
				}
				ready = 0;
			}
		}
		if (ready != 0)
			throw new Base64FormatException("Invalid length.");
		out.flush();
}

Do the actual decoding. Process the input stream by decoding it and emiting the resulting bytes into the output stream.

 public String processString() throws Base64FormatException 
{
		if (!stringp)
			throw new RuntimeException(
				this.getClass().getName()
					+ "[processString]"
					+ "invalid call (not a String)");
		try
		{
			process();
		}
		catch (IOException e)
		{
		}
		String s;
		try
		{
			s = ((ByteArrayOutputStream) out).toString("ISO-8859-1");
		}
		catch (UnsupportedEncodingException ex)
		{
			throw new RuntimeException(
				this.getClass().getName()
					+ "[processString] Unable to convert"
					+ "properly char to bytes");
		}
		return s;
}

Do the decoding, and return a String. This methods should be called when the decoder is used in String mode. It decodes the input string to an output string that is returned.