package ;
import .*;
import ;
import ;
import ;
public final class FileReaderUtils {
/**
* Read small file, buffer buffer at one time, read out all file contents. If it cannot be read out one time, throw IOException and do not perform data reading operations.
*
* @paramfileFullName file reads full path name
* @return
*/
public static byte[] readOnce(String fileFullName) throws IOException {
// open the file
File file = new File(fileFullName);
return readOnce(file);
}
/**
* Read small file, buffer buffer at one time, read out all file contents. If it cannot be read out one time, throw IOException and do not perform data reading operations.
*
* @param file
* @return
*/
public static byte[] readOnce(File file) throws IOException {
//check the file is Exists
checkFileExists(file);
// check the file is too long, if the file length is too long ,returned. because the byte array can not buffered.
// byte array bufferSize=,and must between 0 and Integer_MAX_VALUE
if (() > Integer.MAX_VALUE) {
("file is too big ,not to read !");
throw new IOException(() + " is too big ,not to read ");
}
int _bufferSize = (int) ();
//Define the buffer buffer size
byte[] buffer = new byte[_bufferSize];
FileInputStream in = null;
try {
in = new FileInputStream(file);
int len = 0;
if ((len = ()) <= ) {
(buffer, 0, len);
}
} finally {
closeInputStream(in);
}
return buffer;
}
public static byte[] readByByteArrayOutputStream(File file) throws IOException {
checkFileExists(file);
// Traditional IO method
//1. Define a Byte byte array output stream and set the size to file size
//2. Convert the open file input stream into a Buffer input stream, loop to read the buffer input stream to the buffer[] buffer, and input the buffer buffer data to the target output stream.
//3. Convert the target output stream into a byte array.
ByteArrayOutputStream bos = new ByteArrayOutputStream((int) ());
BufferedInputStream bin = null;
try {
bin = new BufferedInputStream(new FileInputStream(file));
byte[] buffer = new byte[1024];
while ((buffer) > 0) {
(buffer);
}
return ();
} finally {
closeInputStream(bin);
closeOutputStream(bos);
}
}
public static byte[] readByNIO(File file) throws IOException {
checkFileExists(file);
//1. Define a File pipeline, open the file input stream, and obtain the input stream pipeline.
//2. Define a ByteBuffer and allocate the memory space of the specified size
//3. While loop to read the pipeline data to the byteBuffer until all the pipeline data is read
//4. Convert byteBuffer to byte array to return
FileChannel fileChannel = null;
FileInputStream in = null;
try {
in = new FileInputStream(file);
fileChannel = ();
ByteBuffer buffer = ((int) ());
while ((buffer) > 0) {
}
return ();
} finally {
closeChannel(fileChannel);
closeInputStream(in);
}
}
public static byte[] readRandomAccess(File file) throws IOException {
//1. Use RandomAccessFile to open the file pipeline
//2. Create a MappedByteBuffer, and use NIO pipeline to map data, load data into physical memory
//3. Read data into the byte array.
FileChannel channel = new RandomAccessFile(file, "r").getChannel();
int fileSize = (int) ();
try {
//load(): Load the contents of this buffer into physical memory. This method does its best to ensure that when it returns, the contents of the buffer reside in physical memory. Calling this method may cause some page faults and I/O operations.
MappedByteBuffer buffer = (.READ_ONLY, 0, fileSize).load();
//remaining() Returns the number of elements between the current position and the limit. The number of elements remaining in this buffer
byte[] result = new byte[fileSize];
if (() > 0) {
(result, 0, fileSize);
}
();
return result;
} finally {
closeChannel(channel);
}
}
private static void checkFileExists(File file) throws FileNotFoundException {
if (file == null || !()) {
("file is not null or exist !");
throw new FileNotFoundException(());
}
}
private static void closeChannel(FileChannel channel) {
try {
();
} catch (IOException e) {
();
}
}
private static void closeOutputStream(OutputStream bos) {
try {
();
} catch (IOException e) {
();
}
}
private static void closeInputStream(InputStream in) {
try {
();
} catch (IOException e) {
();
}
}
}