* * @author Achim Westermann * * @version 1.1 */ public final class FileUtil extends Object { /** * Cuts all path information of the String representation of the given URL. *
* *
* * "file//c:/work/programming/anyfile.jar" --> "anyfile.jar" * "http://jamwg.de" --> "" // No file part. * "ftp://files.com/directory2/" --> "" // File part of URL denotes a directory. * ** * Assuming, that '/' is the current file separator character. *
*
* @param path
* the absolute file path you want the mere file name of.
*
* @return the
*
*
*
* If your string is retrieved from an URL instance, use
* cutDirectoryInformation(URL path) instead, because URL's do not
* depend on the operating systems file separator!
*
*
* @param path
* the absolute file path you want the mere file name of.
*
* @return the
*
*
*
*
* @param filename
* A String that is interpreted to be a file name: The last dot ('.')
* is interpreted to be the extension delimiter.
*
* @return A java.util.Map.Entry instance containing a String for
* the filename at the key side and a String for the extension at the
* value side.
*/
public static java.util.Map.Entry
*
* Else:
*
*
*
* The potential extension is preserved, but a number is appended to the
* prefix name.
*
*
* @param name
* A desired file name.
*
* @return A String that sticks to the naming convention of the given String
* but is unique in the directory scope of argument name.
*/
public static String getDefaultFileName(final String name) {
String result;
File f = new File(name);
if (!f.exists()) {
result = f.getAbsolutePath();
} else {
final java.util.Map.Entry
*
* The resulting file will have the full path and file name without the
* extension concatenated with the given suffix (if preserveExtension is true
* also the suffix of the original file will be added to the end).
*
*
*
* @param source
* the source file to take the name of.
*
* @param suffix
* the suffix to append.
*
* @param preserveExtension
* if true the suffix of the source file will be appended to the
* result file.
*
* @return A file derived from the original file name.
*
* @throws IOException
* if something goes wrong.
**/
public static File deriveFile(final File source, final String suffix,
final boolean preserveExtension) throws IOException {
File result = null;
Map.Entry
* This does not mean that the file is really an ASCII text file. It just
* might be viewed with an editor showing only valid ASCII characters.
*
*
* @param f
* the file to test.
*
* @return true if all bytes in the file are in the ASCII range.
*
* @throws IOException
* on a bad day.
*/
public static boolean isAllASCII(final File f) throws IOException {
return FileUtil.isAllASCII(new FileInputStream(f));
}
/**
* Tests wether the given input stream only contains ASCII characters if
* interpreted by reading bytes (16 bit).
*
* This does not mean that the underlying content is really an ASCII text
* file. It just might be viewed with an editor showing only valid ASCII
* characters.
*
*
* @param in
* the stream to test.
*
* @return true if all bytes in the given input stream are in the ASCII range.
*
* @throws IOException
* on a bad day.
*/
public static boolean isAllASCII(final InputStream in) throws IOException {
boolean ret = true;
int read = -1;
do {
read = in.read();
if (read > 0x7F) {
ret = false;
break;
}
} while (read != -1);
return ret;
}
/**
* Tests, whether the content of the given file is identical at character
* level, when it is opened with both different Charsets.
*
* This is most often the case, if the given file only contains ASCII codes
* but may also occur, when both codepages cover common ranges and the
* document only contains values m_out of those ranges (like the EUC-CN
* charset contains all mappings from BIG5).
*
*
* @param document
* the file to test.
*
* @param a
* the first character set to interpret the document in.
*
* @param b
* the 2nd character set to interpret the document in.
*
* @throws IOException
* if something goes wrong.
*
* @return true if both files have all equal contents if they are interpreted
* as character data in both given encodings (they may differ at
* binary level if both charsets are different).
*/
public static boolean isEqual(final File document, final Charset a, final Charset b)
throws IOException {
boolean ret = true;
FileInputStream aIn = null;
FileInputStream bIn = null;
InputStreamReader aReader = null;
InputStreamReader bReader = null;
try {
aIn = new FileInputStream(document);
bIn = new FileInputStream(document);
aReader = new InputStreamReader(aIn, a);
bReader = new InputStreamReader(bIn, b);
int readA = -1;
int readB = -1;
do {
readA = aReader.read();
readB = bReader.read();
if (readA != readB) {
// also the case, if one is at the end earlier...
ret = false;
break;
}
} while ((readA != -1) && (readB != -1));
return ret;
} finally {
if (aReader != null) {
aReader.close();
}
if (bReader != null) {
bReader.close();
}
}
}
/**
* Invokes {@link #readRAM(File)}, but decorates the result with a
* {@link java.io.ByteArrayInputStream}.
*
* This means: The complete content of the given File has been loaded before
* using the returned InputStream. There are no IO-delays afterwards but
* OutOfMemoryErrors may occur.
*
*
* @param f
* the file to cache.
*
* @return an input stream backed by the file read into memory.
*
* @throws IOException
* if something goes wrong.
*/
public static InputStream readCache(final File f) throws IOException {
return new ByteArrayInputStream(FileUtil.readRAM(f));
}
/**
* Reads the content of the given File into an array.
*
* This method currently does not check for maximum length and might cause a
* java.lang.OutOfMemoryError. It is only intended for
* performance-measurements of data-based algorithms that want to exclude
* I/O-usage.
*
*
* @param f
* the file to read.
*
* @throws IOException
* if something goes wrong.
*
* @return the contents of the given file.
*
*/
public static byte[] readRAM(final File f) throws IOException {
final int total = (int) f.length();
final byte[] ret = new byte[total];
final InputStream in = new FileInputStream(f);
try {
int offset = 0;
int read = 0;
do {
read = in.read(ret, offset, total - read);
if (read > 0) {
offset += read;
}
} while ((read != -1) && (offset != total));
return ret;
} finally {
in.close();
}
}
/**
* Removes the duplicate line breaks in the given file.
*
*
* Be careful with big files: In order to avoid having to write a tmpfile
* (cannot read and directly write to the same file) a StringBuffer is used
* for manipulation. Big files will cost all RAM and terminate VM hard.
*
*
* @param f
* the file to remove duplicate line breaks in.
*/
public static void removeDuplicateLineBreaks(final File f) {
final String sep = StringUtil.getNewLine();
if (!f.exists()) {
System.err.println("FileUtil.removeDuplicateLineBreak(File f): " + f.getAbsolutePath()
+ " does not exist!");
} else {
if (f.isDirectory()) {
System.err.println("FileUtil.removeDuplicateLineBreak(File f): " + f.getAbsolutePath()
+ " is a directory!");
} else {
// real file
FileInputStream inStream = null;
BufferedInputStream in = null;
FileWriter out = null;
try {
inStream = new FileInputStream(f);
in = new BufferedInputStream(inStream, 1024);
StringBuffer result = new StringBuffer();
int tmpread;
while ((tmpread = in.read()) != -1) {
result.append((char) tmpread);
}
String tmpstring;
final StringTokenizer toke = new StringTokenizer(result.toString(), sep, true);
result = new StringBuffer();
int breaks = 0;
while (toke.hasMoreTokens()) {
tmpstring = toke.nextToken().trim();
if (tmpstring.equals("") && (breaks > 0)) {
breaks++;
// if(breaks<=2)result.append(sep);
continue;
}
if (tmpstring.equals("")) {
tmpstring = sep;
breaks++;
} else {
breaks = 0;
}
result.append(tmpstring);
}
// delete original file and write it new from tmpfile.
f.delete();
f.createNewFile();
out = new FileWriter(f);
out.write(result.toString());
} catch (final FileNotFoundException e) {
// does never happen.
} catch (final IOException g) {
g.printStackTrace(System.err);
} finally {
if (in != null) {
try {
in.close();
} catch (final IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.flush();
out.close();
} catch (final IOException e) {
e.printStackTrace();
}
}
}
}
}
}
/** Needed for localization. */
private static final ResourceBundle m_bundle = ResourceBundle.getBundle("messages");
/**
* Utility class constructor.
*
*/
private FileUtil() {
// nop
}
/**
* Returns the formatted file size to Bytes, KB, MB or GB depending on the
* given value.
*
*
* @param filesize
* in bytes
*
* @param locale
* the locale to translate the result to (e.g. in France they us
*
* @return the formatted filesize to Bytes, KB, MB or GB depending on the
* given value.
*/
public static String formatFilesize(final long filesize, final Locale locale) {
String result;
final long filesizeNormal = Math.abs(filesize);
if (Math.abs(filesize) < 1024) {
result = MessageFormat.format(m_bundle.getString("GUI_FILEUTIL_FILESIZE_BYTES_1"),
new Object[] {new Long(filesizeNormal) });
} else if (filesizeNormal < 1048576) {
// 1048576 = 1024.0 * 1024.0
result = MessageFormat.format(m_bundle.getString("GUI_FILEUTIL_FILESIZE_KBYTES_1"),
new Object[] {new Double(filesizeNormal / 1024.0) });
} else if (filesizeNormal < 1073741824) {
// 1024.0^3 = 1073741824
result = MessageFormat.format(m_bundle.getString("GUI_FILEUTIL_FILESIZE_MBYTES_1"),
new Object[] {new Double(filesize / 1048576.0) });
} else {
result = MessageFormat.format(m_bundle.getString("GUI_FILEUTIL_FILESIZE_GBYTES_1"),
new Object[] {new Double(filesizeNormal / 1073741824.0) });
}
return result;
}
}
{@link java.util.Map.Entry} consisting of path
* information and file name.
*/
public static Map.Entry
*
* "c:/work/programming/anyfile.jar" --> Map.Entry("c:/work/programming/","anyfile.jar");
* "anyfile.jar" --> Map.Entry(new File(".").getAbsolutePath(),"anyfile.jar");
* "c:/directory1/directory2/" --> Map.Entry("c:/directory1/directory2/","");
* "c:/directory1/directory2" --> Map.Entry("c:/directory1/directory2/",""); // directory2 is a dir!
* "c:/directory1/file2" --> Map.Entry("c:/directory1/","file2"); // file2 is a file!
* "c:/" --> Map.Entry("c:/","");
*
*
*
* Assuming, that '/' is the current file separator character.
* {@link java.util.Map.Entry} consisting of path
* information and file name.
*/
public static Map.Entry
* Map.Entry entry = FileUtil.cutExtension("A.Very.Strange.Name.txt");
* String prefix = (String) entry.getKey(); // prefix is "A.Very.Strange.Name".
* String suffix = (String) entry.getValue(); // suffix is "txt";
*
* entry = FileUtil.cutExtension(".profile");
* String prefix = (String) entry.getKey(); // prefix is ".profile".
* String suffix = (String) entry.getValue(); // suffix is "";
*
* entry = FileUtil.cutExtension("bash");
* String prefix = (String) entry.getKey(); // prefix is "bash".
* String suffix = (String) entry.getValue(); // suffix is "";
*
*
*
*
* "myFile.out" --> "myFile_0.out"
* "myFile_0.out" --> "myFile_1.out"
* "myFile_1.out" --> "myFile_2.out"
* ....
*
*
* {@link File#createTempFile(String, String, File)} .
*