Top File Utility Methods - RameshMF/java-io-guide GitHub Wiki

/**
 * get last modified given file date
 * @param file
 * @return
 */
public static long getLastModifiedDate(File file){
	return file.lastModified();
}

/**
 * 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";
	}
}

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

/**
 * Get current working directory path
 * @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");
}

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

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

public static boolean isFileNewer(final File file, final Date date) {
	if (date == null) {
		throw new IllegalArgumentException("No specified date");
	}
	return isFileNewer(file, date.getTime());
}

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 existss
 * 
 * @param dir
 *            the directory to check
 * @return {@code true} if the {@code dir} exists on the file system
 */
public static boolean exists(String dir) {
	l.debug("Checking existence of directory [" + dir + "]");
	File f = new File(dir);
	if (f.exists()) {
		l.debug("[" + dir + "] exists.");
		return true;
	}
	l.debug("[" + dir + "] does not exist.");
	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);
}

/**
 * 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;
}

/**
   * 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();
  }

/**
 * 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<>();
	l.debug("checking [" + d.getName() + "]");
	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);
				l.debug("Adding [" + f.getName() + "]");
			} else {
				if (depth > 0) {
					l.debug("Descending...");
					fList.addAll(getFileList(f, depth - 1));
				} else if (depth == -1) {
					fList.addAll(getFileList(f, -1));
				}
			}
		}
	}
	return fList;
}