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));
}
}
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
