Byte[]

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.xml.bind.DatatypeConverter;

public final class BytesStreamsAndFiles {

    private static final String INPUT_FILE_NAME = "C:\\Users\\abhinav\\Documents\\LTA.zip";

    private static final String OUTPUT_FILE_NAME = "C:\\Users\\abhinav\\Documents\\lta.txt.zip";

    private static final String OUTPUT_benc = "C:\\Users\\abhinav\\Documents\\lta.txt";

    public static void main(String... aArgs) {
        BytesStreamsAndFiles test = new BytesStreamsAndFiles();
        // read in the bytes
        byte[] fileContents = test.read(INPUT_FILE_NAME);

        String benc = DatatypeConverter.printBase64Binary(fileContents);
        // test.readAlternateImpl(INPUT_FILE_NAME);
        // write it back out to a different file name
        // test.write(fileContents, OUTPUT_FILE_NAME);

        log(benc.length());
        test.write2(benc, OUTPUT_benc);

        byte[] newFile = DatatypeConverter.parseBase64Binary(benc);

        test.write(newFile, OUTPUT_FILE_NAME);

        log("done...");

    }

    byte[] read(String aInputFileName) {
        log("Reading in binary file named : " + aInputFileName);
        File file = new File(aInputFileName);
        log("File size: " + file.length());
        byte[] result = new byte[(int)file.length()];
        try {
            InputStream input = null;
            try {
                int totalBytesRead = 0;
                input = new BufferedInputStream(new FileInputStream(file));
                while (totalBytesRead < result.length) {
                    int bytesRemaining = result.length - totalBytesRead;
                    // input.read() returns -1, 0, or more :
                    int bytesRead = input.read(result, totalBytesRead, bytesRemaining);
                    if (bytesRead > 0) {
                        totalBytesRead = totalBytesRead + bytesRead;
                    }
                }
                /*
                 * the above style is a bit tricky: it places bytes into the
                 * 'result' array; 'result' is an output parameter; the while
                 * loop usually has a single iteration only.
                 */
                log("Num bytes read: " + totalBytesRead);
            } finally {
                log("Closing input stream.");
                input.close();
            }
        } catch (FileNotFoundException ex) {
            log("File not found.");
        } catch (IOException ex) {
            log(ex);
        }
        return result;
    }

    /**
     * Write a byte array to the given file. Writing binary data is
     * significantly simpler than reading it.
     */
    void write2(String aInput, String aOutputFileName) {
        File file = new File(aOutputFileName);
        try {
            // if file doesnt exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(aInput);
            bw.close();

            System.out.println("Done");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    void write(byte[] aInput, String aOutputFileName) {
        log("Writing binary file...");
        try {
            OutputStream output = null;
            try {
                output = new BufferedOutputStream(new FileOutputStream(aOutputFileName));
                output.write(aInput);
            } finally {
                output.close();
            }
        } catch (FileNotFoundException ex) {
            log("File not found.");
        } catch (IOException ex) {
            log(ex);
        }
    }

    /** Read the given binary file, and return its contents as a byte array. */
    byte[] readAlternateImpl(String aInputFileName) {
        log("Reading in binary file named : " + aInputFileName);
        File file = new File(aInputFileName);
        log("File size: " + file.length());
        byte[] result = null;
        try {
            InputStream input = new BufferedInputStream(new FileInputStream(file));
            result = readAndClose(input);
        } catch (FileNotFoundException ex) {
            log(ex);
        }
        return result;
    }

    /**
     * Read an input stream, and return it as a byte array. Sometimes the source
     * of bytes is an input stream instead of a file. This implementation closes
     * aInput after it's read.
     */
    byte[] readAndClose(InputStream aInput) {
        // carries the data from input to output :
        byte[] bucket = new byte[32 * 1024];
        ByteArrayOutputStream result = null;
        try {
            try {
                // Use buffering? No. Buffering avoids costly access to disk or
                // network;
                // buffering to an in-memory stream makes no sense.
                result = new ByteArrayOutputStream(bucket.length);
                int bytesRead = 0;
                while (bytesRead != -1) {
                    // aInput.read() returns -1, 0, or more :
                    bytesRead = aInput.read(bucket);
                    if (bytesRead > 0) {
                        result.write(bucket, 0, bytesRead);
                    }
                }
            } finally {
                aInput.close();
                // result.close(); this is a no-operation for
                // ByteArrayOutputStream
            }
        } catch (IOException ex) {
            log(ex);
        }
        return result.toByteArray();
    }

    private static void log(Object aThing) {
        System.out.println(String.valueOf(aThing));
    }
}

Ref: http://www.javapractices.com/topic/TopicAction.do?Id=245