In this article, we will show you the list of commonly used file utility methods.
You can use these file utility methods in your day-to-day project work. I found these utility methods useful and I thought I should share them with you all.
Java File Utility Class - FileUtils
This File Utility class contains more than 20 commonly used file utility methods. Each file utility method is explained with java-doc or comments. The comments are self-descriptive and we can understand each method's usage via comments.
package com.javaguides.javaio.utility;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.apache.commons.io.IOUtils;
/**
* Commonly used file utility methods.
* @author javaguides.net
*
*/
public class FileUtils {
/**
* Given the size of a file outputs as human readable size using SI prefix.
* <i>Base 1024</i>
* @param size Size in bytes of a given File.
* @return SI String representing the file size (B,KB,MB,GB,TB).
*/
public static String readableFileSize(long size) {
if (size <= 0) {
return "0";
}
final String[] units = new String[] {"B", "KB", "MB", "GB", "TB"};
int digitGroups = (int)(Math.log10(size) / Math.log10(1024));
return new DecimalFormat("#,##0.#").format(size / Math.pow(1024, digitGroups))
+ " " + units[digitGroups];
}
/**
* Get file extension such as "txt","png","pdf"
* @param file
* @return
*/
public static String getFileExtension(File file){
String fileName = file.getName();
if(fileName.lastIndexOf('.') != -1 && fileName.lastIndexOf('.') != 0){
return fileName.substring(fileName.lastIndexOf('.')+1);
}else{
return "File don't have extension";
}
}
/**
* Check for file extension
* @param file
* @param extension
* @return
*/
public static boolean hasExtension(String file, String extension) {
return file.endsWith(extension);
}
/**
* get last modified given file date
* @param file
* @return
*/
public static long getLastModifiedDate(File file){
return file.lastModified();
}
/**
* check if a file exists in Java
* @param file
* @return
*/
public static boolean checkFileExist(File file){
return file.exists();
}
/**
* Converts InputStream to a String
* @param in
* @return
* @throws IOException
*/
public static String convertInputStreamToString(final InputStream in) throws IOException {
ByteArrayOutputStream result = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int length;
while ((length = in.read(buffer)) != -1) {
result.write(buffer, 0, length);
}
return result.toString(StandardCharsets.UTF_8.name());
}
/**
* Reads content of a file to a String
* @param path
* @return
* @throws IOException
*/
public String readFileAsString(Path path) throws IOException {
return new String(Files.readAllBytes(path));
}
/**
* getCurrentWorkingDirectoryPath
* @return
*/
public static String getCurrentWorkingDirectoryPath() {
return FileSystems.getDefault().getPath("").toAbsolutePath().toString();
}
/**
* Returns the value of java.io.tmpdir system property. It appends separator if not present at the end.
* @return
*/
public static String tmpDirName() {
String tmpDirName = System.getProperty("java.io.tmpdir");
if (!tmpDirName.endsWith(File.separator)) {
tmpDirName += File.separator;
}
return tmpDirName;
}
/**
* Returns the path to the system temporary directory.
*
* @return the path to the system temporary directory.
*/
public static String getTempDirectoryPath() {
return System.getProperty("java.io.tmpdir");
}
/**
* Returns the path to the user's home directory.
*
* @return the path to the user's home directory.
*
* @since 2.0
*/
public static String getUserDirectoryPath() {
return System.getProperty("user.home");
}
/**
* Returns a {@link File} representing the user's home directory.
*
* @return the user's home directory.
*
* @since 2.0
*/
public static File getUserDirectory() {
return new File(getUserDirectoryPath());
}
/**
* Converts a Collection containing java.io.File instanced into array
* representation. This is to account for the difference between
* File.listFiles() and FileUtils.listFiles().
*
* @param files a Collection containing java.io.File instances
* @return an array of java.io.File
*/
public static File[] convertFileCollectionToFileArray(final Collection<File> files) {
return files.toArray(new File[files.size()]);
}
/**
* Gets the extension of a file name, like ".png" or ".jpg".
*
* @param uri
* @return Extension including the dot("."); "" if there is no extension;
* null if uri was null.
*/
public static String getExtension(String uri) {
if (uri == null) {
return null;
}
int dot = uri.lastIndexOf(".");
if (dot >= 0) {
return uri.substring(dot);
} else {
// No extension.
return "";
}
}
/**
* Compares the contents of two files to determine if they are equal or not.
* <p>
* This method checks to see if the two files are different lengths
* or if they point to the same file, before resorting to byte-by-byte
* comparison of the contents.
* <p>
* Code origin: Avalon
*
* @param file1 the first file
* @param file2 the second file
* @return true if the content of the files are equal or they both don't
* exist, false otherwise
* @throws IOException in case of an I/O error
*/
public static boolean contentEquals(final File file1, final File file2) throws IOException {
final boolean file1Exists = file1.exists();
if (file1Exists != file2.exists()) {
return false;
}
if (!file1Exists) {
// two not existing files are equal
return true;
}
if (file1.isDirectory() || file2.isDirectory()) {
// don't want to compare directory contents
throw new IOException("Can't compare directories, only files");
}
if (file1.length() != file2.length()) {
// lengths differ, cannot be equal
return false;
}
if (file1.getCanonicalFile().equals(file2.getCanonicalFile())) {
// same file
return true;
}
try (InputStream input1 = new FileInputStream(file1);
InputStream input2 = new FileInputStream(file2)) {
return IOUtils.contentEquals(input1, input2);
}
}
/**
* Compares the contents of two files to determine if they are equal or not.
* <p>
* This method checks to see if the two files point to the same file,
* before resorting to line-by-line comparison of the contents.
* <p>
*
* @param file1 the first file
* @param file2 the second file
* @param charsetName the character encoding to be used.
* May be null, in which case the platform default is used
* @return true if the content of the files are equal or neither exists,
* false otherwise
* @throws IOException in case of an I/O error
* @see IOUtils#contentEqualsIgnoreEOL(Reader, Reader)
* @since 2.2
*/
public static boolean contentEqualsIgnoreEOL(final File file1, final File file2, final String charsetName)
throws IOException {
final boolean file1Exists = file1.exists();
if (file1Exists != file2.exists()) {
return false;
}
if (!file1Exists) {
// two not existing files are equal
return true;
}
if (file1.isDirectory() || file2.isDirectory()) {
// don't want to compare directory contents
throw new IOException("Can't compare directories, only files");
}
if (file1.getCanonicalFile().equals(file2.getCanonicalFile())) {
// same file
return true;
}
try (Reader input1 = charsetName == null
? new InputStreamReader(new FileInputStream(file1), Charset.defaultCharset())
: new InputStreamReader(new FileInputStream(file1), charsetName);
Reader input2 = charsetName == null
? new InputStreamReader(new FileInputStream(file2), Charset.defaultCharset())
: new InputStreamReader(new FileInputStream(file2), charsetName)) {
return IOUtils.contentEqualsIgnoreEOL(input1, input2);
}
}
/**
* Returns the path only (without file name).
*
* @param file
* @return
*/
public static File getPathWithoutFilename(File file) {
if (file != null) {
if (file.isDirectory()) {
// no file to be split off. Return everything
return file;
} else {
String filename = file.getName();
String filepath = file.getAbsolutePath();
// Construct path without file name.
String pathwithoutname = filepath.substring(0,
filepath.length() - filename.length());
if (pathwithoutname.endsWith("/")) {
pathwithoutname = pathwithoutname.substring(0, pathwithoutname.length() - 1);
}
return new File(pathwithoutname);
}
}
return null;
}
/**
* Tests if the specified <code>File</code> is newer than the specified
* <code>Date</code>.
*
* @param file the <code>File</code> of which the modification date
* must be compared, must not be {@code null}
* @param date the date reference, must not be {@code null}
* @return true if the <code>File</code> exists and has been modified
* after the given <code>Date</code>.
* @throws IllegalArgumentException if the file is {@code null}
* @throws IllegalArgumentException if the date is {@code null}
*/
public static boolean isFileNewer(final File file, final Date date) {
if (date == null) {
throw new IllegalArgumentException("No specified date");
}
return isFileNewer(file, date.getTime());
}
/**
* Tests if the specified <code>File</code> is newer than the specified
* time reference.
*
* @param file the <code>File</code> of which the modification date must
* be compared, must not be {@code null}
* @param timeMillis the time reference measured in milliseconds since the
* epoch (00:00:00 GMT, January 1, 1970)
* @return true if the <code>File</code> exists and has been modified after
* the given time reference.
* @throws IllegalArgumentException if the file is {@code null}
*/
public static boolean isFileNewer(final File file, final long timeMillis) {
if (file == null) {
throw new IllegalArgumentException("No specified file");
}
if (!file.exists()) {
return false;
}
return file.lastModified() > timeMillis;
}
/**
* Join file and extension
* @param file
* @param ext
* @return
*/
public static String join(String file, String ext) {
return file + '/' + ext;
}
/**
* Check if a directory exists
*
* @param dir
* the directory to check
* @return {@code true} if the {@code dir} exists on the file system
*/
public static boolean exists(String dir) {
File f = new File(dir);
if (f.exists()) {
return true;
}
return false;
}
/**
* A wrapper for {@link java.io.File#renameTo(File)}
*
* @param oldf
* the original filename
* @param newf
* the new filename
* @return {@code true} if the move was successful
*/
public static boolean move(File oldf, File newf) {
return oldf.renameTo(newf);
}
/**
* A wrapper for {@link java.io.File#renameTo(File)} which creates new File
* handles for both args.
*
* @param oldf
* the original filename
* @param newf
* the new filename
* @return {@code true} if the move was successful
*/
public static boolean move(String oldf, String newf) {
return new File(oldf).renameTo(new File(newf));
}
/**
* Creates {@code dir} if it doesn't yet exist. A wrapper for
* {@link java.io.File#mkdir()}
*
* @param dir
* the directory to create
* @return {@code true} if the operation was successful
*/
public static boolean mkdir(String dir) {
boolean success = exists(dir) ? true : new File(dir).mkdir();
return success;
}
/**
* Creates all {@code dir}s in the path as needed. A wrapper for
* {@link java.io.File#mkdirs()}
*
* @param dir
* the path to create
* @return {@code true} if the operation was successful
*/
public static boolean mkdirs(String dir) {
boolean success = exists(dir) ? true : new File(dir).mkdirs();
return success;
}
/**
* Returns the current timestamp in format {@code yyyyMMddHHmmssSSS}
*
* @return the current timestamp
* @see java.text.SimpleDateFormat
*/
public static String getTimeStamp() {
return new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
}
/**
* Get a list of directory contents
*
* @param d
* the directory to list
* @return a list of directory contents
*/
public static List<File> getFileList(File d) {
return getFileList(d, -1);
}
/**
* Gets a recursive list of directory contents
*
* @param d
* the directory to interrogate
* @param depth
* the number of level to recurse
* @return a list of directory contents
*/
public static List<File> getFileList(File d, int depth) {
List<File> fList = new ArrayList<>();
if (d.canRead() && d.isDirectory()) {
File[] list = d.listFiles();
for (int i = 0; i < list.length; i++) {
File f = list[i];
if (f.isFile()) {
fList.add(f);
} else {
if (depth > 0) {
fList.addAll(getFileList(f, depth - 1));
} else if (depth == -1) {
fList.addAll(getFileList(f, -1));
}
}
}
}
return fList;
}
/**
* recursively deletes the path and all it's content and returns true if it succeeds
* Note that the content could be partially deleted and the method return false
*
* @param path the path to delete
* @return true if the path was deleted
*/
public static boolean forceDeletePath(File path) {
if (path == null) {
return false;
}
if (path.exists() && path.isDirectory()) {
File[] files = path.listFiles();
for (File file : files) {
if (file.isDirectory()) {
forceDeletePath(file);
} else {
file.delete();
}
}
}
return path.delete();
}
}
Comments
Post a Comment
Leave Comment