Encoding as Base64 in Java

Use Java 8's never-too-late-to-join-in-the-fun class: java.util.Base64

new String(Base64.getEncoder().encode(bytes)); 

In Java 8 it can be done as: Base64.getEncoder().encodeToString(string.getBytes(StandardCharsets.UTF_8))

Here is a short, self-contained complete example:

import java.nio.charset.StandardCharsets; import java.util.Base64; public class Temp { public static void main(String... args) throws Exception { final String s = "old crow medicine show"; final byte[] authBytes = s.getBytes(StandardCharsets.UTF_8); final String encoded = Base64.getEncoder().encodeToString(authBytes); System.out.println(s + " => " + encoded); } } 

Output:

old crow medicine show => b2xkIGNyb3cgbWVkaWNpbmUgc2hvdw== 

You can also convert using Base64 encoding. To do this, you can use the javax.xml.bind.DatatypeConverter#printBase64Binary method.

For example:

byte[] salt = new byte[] { 50, 111, 8, 53, 86, 35, -19, -47 }; System.out.println(DatatypeConverter.printBase64Binary(salt)); 

With Guava

pom.xml:

<dependency> <artifactId>guava</artifactId> <groupId>com.google.guava</groupId> <type>jar</type> <version>14.0.1</version> </dependency> 

Sample code:

// encode String s = "Hello Việt Nam"; String base64 = BaseEncoding.base64().encode(s.getBytes("UTF-8")); // decode System.out.println("Base64:" + base64); // SGVsbG8gVmnhu4d0IE5hbQ== byte[] bytes = BaseEncoding.base64().decode(base64); System.out.println("Decoded: " + new String(bytes, "UTF-8")); // Hello Việt Nam 

Eclipse gives you an error/warning because you are trying to use internal classes that are specific to a JDK vendor and not part of the public API. Jakarta Commons provides its own implementation of base64 codecs, which of course reside in a different package. Delete those imports and let Eclipse import the proper Commons classs for you.

For Java 6-7, the best option is to borrow code from the Android repository. It has no dependencies.

https://github.com/android/platform_frameworks_base/blob/master/core/java/android/util/Base64.java

Java 8 does contain its own implementation of Base64. However, I found one slightly disturbing difference. To illustrate, I will provide a code example:

My codec wrapper:

public interface MyCodec { static String apacheDecode(String encodedStr) { return new String(Base64.decodeBase64(encodedStr), Charset.forName("UTF-8")); } static String apacheEncode(String decodedStr) { byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8")); return Base64.encodeBase64String(decodedByteArr); } static String javaDecode(String encodedStr) { return new String(java.util.Base64.getDecoder().decode(encodedStr), Charset.forName("UTF-8")); } static String javaEncode(String decodedStr) { byte[] decodedByteArr = decodedStr.getBytes(Charset.forName("UTF-8")); return java.util.Base64.getEncoder().encodeToString(decodedByteArr); } } 

Test Class:

public class CodecDemo { public static void main(String[] args) { String decodedText = "Hello World!"; String encodedApacheText = MyCodec.apacheEncode(decodedText); String encodedJavaText = MyCodec.javaEncode(decodedText); System.out.println("Apache encoded text: " + MyCodec.apacheEncode(encodedApacheText)); System.out.println("Java encoded text: " + MyCodec.javaEncode(encodedJavaText)); System.out.println("Encoded results equal: " + encodedApacheText.equals(encodedJavaText)); System.out.println("Apache decode Java: " + MyCodec.apacheDecode(encodedJavaText)); System.out.println("Java decode Java: " + MyCodec.javaDecode(encodedJavaText)); System.out.println("Apache decode Apache: " + MyCodec.apacheDecode(encodedApacheText)); System.out.println("Java decode Apache: " + MyCodec.javaDecode(encodedApacheText)); } } 

OUTPUT:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA0K Java encoded text: U0dWc2JHOGdWMjl5YkdRaA== Encoded results equal: false Apache decode Java: Hello World! Java decode Java: Hello World! Apache decode Apache: Hello World! Exception in thread "main" java.lang.IllegalArgumentException: Illegal base64 character d at java.util.Base64$Decoder.decode0(Base64.java:714) at java.util.Base64$Decoder.decode(Base64.java:526) at java.util.Base64$Decoder.decode(Base64.java:549) 

Notice that the Apache encoded text contain additional line breaks (white spaces) at the end. Therefore, in order for my codec to yield the same result regardless of Base64 implementation, I had to call trim() on the Apache encoded text. In my case, I simply added the aforementioned method call to the my codec's apacheDecode() as follows:

return Base64.encodeBase64String(decodedByteArr).trim(); 

Once this change was made, the results are what I expected to begin with:

Apache encoded text: U0dWc2JHOGdWMjl5YkdRaA== Java encoded text: U0dWc2JHOGdWMjl5YkdRaA== Encoded results equal: true Apache decode Java: Hello World! Java decode Java: Hello World! Apache decode Apache: Hello World! Java decode Apache: Hello World! 

CONCLUSION: If you want to switch from Apache Base64 to Java, you must:

1. Decode encoded text with your Apache decoder.
2. Encode resulting (plain) text with Java.

If you switch without following these steps, most likely you will run into problems. That is how I made this discovery.

To convert this, you need an encoder & decoder which you will get from Base64Coder - an open-source Base64 encoder/decoder in Java. It is file Base64Coder.java you will need.

Now to access this class as per your requirement you will need the class below:

import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.InputStream; import java.io.IOException; import java.io.OutputStream; public class Base64 { public static void main(String args[]) throws IOException { /* * if (args.length != 2) { * System.out.println( * "Command line parameters: inputFileName outputFileName"); * System.exit(9); * } encodeFile(args[0], args[1]); */ File sourceImage = new File("back3.png"); File sourceImage64 = new File("back3.txt"); File destImage = new File("back4.png"); encodeFile(sourceImage, sourceImage64); decodeFile(sourceImage64, destImage); } private static void encodeFile(File inputFile, File outputFile) throws IOException { BufferedInputStream in = null; BufferedWriter out = null; try { in = new BufferedInputStream(new FileInputStream(inputFile)); out = new BufferedWriter(new FileWriter(outputFile)); encodeStream(in, out); out.flush(); } finally { if (in != null) in.close(); if (out != null) out.close(); } } private static void encodeStream(InputStream in, BufferedWriter out) throws IOException { int lineLength = 72; byte[] buf = new byte[lineLength / 4 * 3]; while (true) { int len = in.read(buf); if (len <= 0) break; out.write(Base64Coder.encode(buf, 0, len)); out.newLine(); } } static String encodeArray(byte[] in) throws IOException { StringBuffer out = new StringBuffer(); out.append(Base64Coder.encode(in, 0, in.length)); return out.toString(); } static byte[] decodeArray(String in) throws IOException { byte[] buf = Base64Coder.decodeLines(in); return buf; } private static void decodeFile(File inputFile, File outputFile) throws IOException { BufferedReader in = null; BufferedOutputStream out = null; try { in = new BufferedReader(new FileReader(inputFile)); out = new BufferedOutputStream(new FileOutputStream(outputFile)); decodeStream(in, out); out.flush(); } finally { if (in != null) in.close(); if (out != null) out.close(); } } private static void decodeStream(BufferedReader in, OutputStream out) throws IOException { while (true) { String s = in.readLine(); if (s == null) break; byte[] buf = Base64Coder.decodeLines(s); out.write(buf); } } } 

In Android you can convert your bitmap to Base64 for Uploading to a server or web service.

Bitmap bmImage = //Data ByteArrayOutputStream baos = new ByteArrayOutputStream(); bmImage.compress(Bitmap.CompressFormat.JPEG, 100, baos); byte[] imageData = baos.toByteArray(); String encodedImage = Base64.encodeArray(imageData); 

This “encodedImage” is text representation of your image. You can use this for either uploading purpose or for diplaying directly into an HTML page as below (reference):

<img alt="" src="data:image/png;base64,<?php echo $encodedImage; ?>" width="100px" /> <img alt="" src="data:image/png;base64,/9j/4AAQ...........1f/9k=" width="100px" /> 

Documentation: http://dwij.co.in/java-base64-image-encoder

On Android, use the static methods of the android.util.Base64 utility class. The referenced documentation says that the Base64 class was added in API level 8 (Android 2.2 (Froyo)).

import android.util.Base64; byte[] encodedBytes = Base64.encode("Test".getBytes()); Log.d("tag", "encodedBytes " + new String(encodedBytes)); byte[] decodedBytes = Base64.decode(encodedBytes); Log.d("tag", "decodedBytes " + new String(decodedBytes)); 

If you are using Spring Framework at least version 4.1, you can use the org.springframework.util.Base64Utils class:

byte[] raw = { 1, 2, 3 }; String encoded = Base64Utils.encodeToString(raw); byte[] decoded = Base64Utils.decodeFromString(encoded); 

It will delegate to Java 8's Base64, Apache Commons Codec, or JAXB DatatypeConverter, depending on what is available.

Apache Commons has a nice implementation of Base64. You can do this as simply as:

// Encrypt data on your side using BASE64 byte[] bytesEncoded = Base64.encodeBase64(str .getBytes()); System.out.println("ecncoded value is " + new String(bytesEncoded)); // Decrypt data on other side, by processing encoded data byte[] valueDecoded= Base64.decodeBase64(bytesEncoded ); System.out.println("Decoded value is " + new String(valueDecoded)); 

You can find more details about base64 encoding at Base64 encoding using Java and JavaScript.

Simple example with Java 8:

import java.util.Base64; String str = "your string"; String encodedStr = Base64.getEncoder().encodeToString(str.getBytes("utf-8")); 

In Java 7 I coded this method

import javax.xml.bind.DatatypeConverter; public static String toBase64(String data) { return DatatypeConverter.printBase64Binary(data.getBytes()); } 

If you are stuck to an earlier version of Java than 8 but already using AWS SDK for Java, you can use com.amazonaws.util.Base64.

I tried with the following code snippet. It worked well. :-)

com.sun.org.apache.xml.internal.security.utils.Base64.encode("The string to encode goes here"); 

public String convertImageToBase64(String filePath) { byte[] fileContent = new byte[0]; String base64encoded = null; try { fileContent = FileUtils.readFileToByteArray(new File(filePath)); } catch (IOException e) { log.error("Error reading file: {}", filePath); } try { base64encoded = Base64.getEncoder().encodeToString(fileContent); } catch (Exception e) { log.error("Error encoding the image to base64", e); } return base64encoded; } 

GZIP + Base64

The length of the string in a Base64 format is greater then original: 133% on average. So it makes sense to first compress it with GZIP, and then encode to Base64. It gives a reduction of up to 77% for strings greater than 200 characters and more. Example:

public static void main(String[] args) throws IOException { byte[] original = randomString(100).getBytes(StandardCharsets.UTF_8); byte[] base64 = encodeToBase64(original); byte[] gzipToBase64 = encodeToBase64(encodeToGZIP(original)); byte[] fromBase64 = decodeFromBase64(base64); byte[] fromBase64Gzip = decodeFromGZIP(decodeFromBase64(gzipToBase64)); // test System.out.println("Original: " + original.length + " bytes, 100%"); System.out.println("Base64: " + base64.length + " bytes, " + (base64.length * 100 / original.length) + "%"); System.out.println("GZIP+Base64: " + gzipToBase64.length + " bytes, " + (gzipToBase64.length * 100 / original.length) + "%"); //Original: 3700 bytes, 100% //Base64: 4936 bytes, 133% //GZIP+Base64: 2868 bytes, 77% System.out.println(Arrays.equals(original, fromBase64)); // true System.out.println(Arrays.equals(original, fromBase64Gzip)); // true } 

public static byte[] decodeFromBase64(byte[] arr) { return Base64.getDecoder().decode(arr); } public static byte[] encodeToBase64(byte[] arr) { return Base64.getEncoder().encode(arr); } 

public static byte[] decodeFromGZIP(byte[] arr) throws IOException { ByteArrayInputStream bais = new ByteArrayInputStream(arr); GZIPInputStream gzip = new GZIPInputStream(bais); return gzip.readAllBytes(); } public static byte[] encodeToGZIP(byte[] arr) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); GZIPOutputStream gzip = new GZIPOutputStream(baos); gzip.write(arr); gzip.finish(); return baos.toByteArray(); } 

public static String randomString(int count) { StringBuilder str = new StringBuilder(); for (int i = 0; i < count; i++) { str.append(" ").append(UUID.randomUUID().toString()); } return str.toString(); } 

^{See also: How to get the JAR file for sun.misc.BASE64Encoder class?}

add this library into your app level dependancies

implementation 'org.apache.commons:commons-collections4:4.4'