Java tutorial
/* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package dodola.anole.lib; import com.google.common.base.Charsets; import com.google.common.base.Function; import com.google.common.base.Joiner; import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.FluentIterable; import com.google.common.collect.Iterables; import com.google.common.hash.HashCode; import com.google.common.hash.HashFunction; import com.google.common.hash.Hashing; import com.google.common.io.Closeables; import com.google.common.io.Files; import java.io.EOFException; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import java.util.List; import java.util.regex.Pattern; import static com.google.common.base.Preconditions.checkArgument; public final class FileUtils { private FileUtils() { } private static final Joiner PATH_JOINER = Joiner.on(File.separatorChar); private static final Joiner COMMA_SEPARATED_JOINER = Joiner.on(", "); private static final Joiner UNIX_NEW_LINE_JOINER = Joiner.on('\n'); public static final Function<File, String> GET_NAME = new Function<File, String>() { @Override public String apply(File file) { return file.getName(); } }; public static final Function<File, String> GET_PATH = new Function<File, String>() { @Override public String apply(File file) { return file.getPath(); } }; public static Predicate<File> withExtension(final String extension) { checkArgument(extension.charAt(0) != '.', "Extension should not start with a dot."); return new Predicate<File>() { @Override public boolean apply(File input) { return Files.getFileExtension(input.getName()).equals(extension); } }; } public static void deleteFolder(final File folder) throws IOException { if (!folder.exists()) { return; } File[] files = folder.listFiles(); if (files != null) { // i.e. is a directory. for (final File file : files) { deleteFolder(file); } } if (!folder.delete()) { throw new IOException(String.format("Could not delete folder %s", folder)); } } public static void emptyFolder(final File folder) throws IOException { deleteFolder(folder); if (!folder.mkdirs()) { throw new IOException(String.format("Could not create empty folder %s", folder)); } } public static void copy(final File from, final File toDir) throws IOException { File to = new File(toDir, from.getName()); if (from.isDirectory()) { mkdirs(to); File[] children = from.listFiles(); if (children != null) { for (File child : children) { copy(child, to); } } } else if (from.isFile()) { Files.copy(from, to); } } public static void mkdirs(File folder) { // attempt to create first. // if failure only throw if folder does not exist. // This makes this method able to create the same folder(s) from different thread if (!folder.mkdirs() && !folder.exists()) { throw new RuntimeException("Cannot create directory " + folder); } } public static void delete(File file) throws IOException { boolean result = file.delete(); if (!result) { throw new IOException("Failed to delete " + file.getAbsolutePath()); } } public static void deleteIfExists(File file) throws IOException { boolean result = file.delete(); if (!result && file.exists()) { throw new IOException("Failed to delete " + file.getAbsolutePath()); } } public static void renameTo(File file, File to) throws IOException { boolean result = file.renameTo(to); if (!result) { throw new IOException("Failed to rename " + file.getAbsolutePath() + " to " + to); } } /** * Joins a list of path segments to a given File object. * * @param dir the file object. * @param paths the segments. * @return a new File object. */ public static File join(File dir, String... paths) { if (paths.length == 0) { return dir; } return new File(dir, PATH_JOINER.join(paths)); } /** * Joins a list of path segments to a given File object. * * @param dir the file object. * @param paths the segments. * @return a new File object. */ public static File join(File dir, Iterable<String> paths) { return new File(dir, PATH_JOINER.join(paths)); } /** * Joins a set of segment into a string, separating each segments with a host-specific * path separator. * * @param paths the segments. * @return a string with the segments. */ public static String join(String... paths) { return PATH_JOINER.join(paths); } /** * Joins a set of segment into a string, separating each segments with a host-specific * path separator. * * @param paths the segments. * @return a string with the segments. */ public static String join(Iterable<String> paths) { return PATH_JOINER.join(paths); } /** * Loads a text file forcing the line separator to be of Unix style '\n' rather than being * Windows style '\r\n'. */ public static String loadFileWithUnixLineSeparators(File file) throws IOException { return UNIX_NEW_LINE_JOINER.join(Files.readLines(file, Charsets.UTF_8)); } /** * Computes the relative of a file or directory with respect to a directory. * * @param file the file or directory, which must exist in the filesystem * @param dir the directory to compute the path relative to * @return the relative path from {@code dir} to {@code file}; if {@code file} is a directory * the path comes appended with the file separator (see documentation on {@code relativize} * on java's {@code URI} class) */ public static String relativePath(File file, File dir) { checkArgument(file.isFile() || file.isDirectory(), "%s is not a file nor a directory.", file.getPath()); checkArgument(dir.isDirectory(), "%s is not a directory.", dir.getPath()); return relativePossiblyNonExistingPath(file, dir); } /** * Computes the relative of a file or directory with respect to a directory. * For example, if the file's absolute path is {@code /a/b/c} and the directory * is {@code /a}, this method returns {@code b/c}. * * @param file the path that may not correspond to any existing path in the filesystem * @param dir the directory to compute the path relative to * @return the relative path from {@code dir} to {@code file}; if {@code file} is a directory * the path comes appended with the file separator (see documentation on {@code relativize} * on java's {@code URI} class) */ public static String relativePossiblyNonExistingPath(File file, File dir) { String path = dir.toURI().relativize(file.toURI()).getPath(); return toSystemDependentPath(path); } /** * Converts a /-based path into a path using the system dependent separator. * * @param path the system independent path to convert * @return the system dependent path */ public static String toSystemDependentPath(String path) { if (File.separatorChar != '/') { path = path.replace('/', File.separatorChar); } return path; } /** * Converts a system-dependent path into a /-based path. * * @param path the system dependent path * @return the system independent path */ public static String toSystemIndependentPath(String path) { if (File.separatorChar != '/') { path = path.replace(File.separatorChar, '/'); } return path; } public static String sha1(File file) throws IOException { return Hashing.sha1().hashBytes(Files.toByteArray(file)).toString(); } public static FluentIterable<File> getAllFiles(File dir) { return Files.fileTreeTraverser().preOrderTraversal(dir).filter(Files.isFile()); } public static String getNamesAsCommaSeparatedList(Iterable<File> files) { return COMMA_SEPARATED_JOINER.join(Iterables.transform(files, GET_NAME)); } /** * Chooses a directory name, based on a JAR file name, considering exploded-aar and classes.jar. */ public static String getDirectoryNameForJar(File inputFile) { // add a hash of the original file path. HashFunction hashFunction = Hashing.sha1(); HashCode hashCode = hashFunction.hashString(inputFile.getAbsolutePath(), Charsets.UTF_16LE); String name = Files.getNameWithoutExtension(inputFile.getName()); if (name.equals("classes") && inputFile.getAbsolutePath().contains("exploded-aar")) { // This naming scheme is coming from DependencyManager#computeArtifactPath. File versionDir = inputFile.getParentFile().getParentFile(); File artifactDir = versionDir.getParentFile(); File groupDir = artifactDir.getParentFile(); name = Joiner.on('-').join(groupDir.getName(), artifactDir.getName(), versionDir.getName()); } name = name + "_" + hashCode.toString(); return name; } public static void createFile(File file, String content) throws IOException { checkArgument(!file.exists(), "%s exists already.", file); Files.createParentDirs(file); Files.write(content, file, Charsets.UTF_8); } /** * Find a list of files in a directory, using a specified path pattern. */ public static List<File> find(File base, final Pattern pattern) { checkArgument(base.isDirectory(), "'base' must be a directory."); return Files.fileTreeTraverser().preOrderTraversal(base) .filter(Predicates.compose(Predicates.contains(pattern), GET_PATH)).toList(); } /** * Find a file with the specified name in a given directory . */ public static Optional<File> find(File base, final String name) { checkArgument(base.isDirectory(), "'base' must be a directory."); return Files.fileTreeTraverser().preOrderTraversal(base) .filter(Predicates.compose(Predicates.equalTo(name), GET_NAME)).last(); } /** * Reads a portion of a file to memory. * * @param file the file to read data from * @param start the offset in the file to start reading * @param length the number of bytes to read * @return the bytes read * @throws Exception failed to read the file */ public static byte[] readSegment(File file, long start, int length) throws Exception { Preconditions.checkArgument(start >= 0, "start < 0"); Preconditions.checkArgument(length >= 0, "length < 0"); byte data[]; boolean threw = true; RandomAccessFile raf = new RandomAccessFile(file, "r"); try { raf.seek(start); data = new byte[length]; int tot = 0; while (tot < length) { int r = raf.read(data, tot, length - tot); if (r < 0) { throw new EOFException(); } tot += r; } threw = false; } finally { Closeables.close(raf, threw); } return data; } }