1. Overview
In this tutorial, we’ll give an overview of the File class, which is part of the java.io API. The File class gives us the ability to work with files and directories on the file system.
2. Creating a File Object
The File class has 4 public constructors. Depending on the developer’s needs, different types of instances of the File class can be created.
- File(String pathname) – Creates an instance representing the given pathname
- File(String parent, String child) – Creates an instance that represents the path formed by joining the parent and the child paths
- File(File parent, String child) – Creates an instance with the path formed by joining the parent path represented by another File instance and the child path
- File(URI uri) – Creates an instance that represents the given Uniform Resource Identifier
3. Working with the File Class
The File class has a number of methods that allow us to work with and manipulate files on the file system. We will highlight some of them here. It is important to note that the File class cannot modify or access the contents of the file it represents.
3.1. Creating and Deleting Directories and Files
The File class has instance methods to create and delete directories and files. Directories and files are created using the mkdir and createNewFile methods, respectively.
Directories and files are deleted using the delete method. All these methods return a boolean value that is true when the operation succeeds, and false otherwise:
@Test
public void givenDir_whenMkdir_thenDirIsDeleted() {
File directory = new File("dir");
assertTrue(directory.mkdir());
assertTrue(directory.delete());
}
@Test
public void givenFile_whenCreateNewFile_thenFileIsDeleted() {
File file = new File("file.txt");
try {
assertTrue(file.createNewFile());
} catch (IOException e) {
fail("Could not create " + "file.txt");
}
assertTrue(file.delete());
}
In the above snippet, we also see other helpful methods.
The isDirectory method can be used to test if the file denoted by the provided name is a directory, while the isFile method can be used to test if the file denoted by the provided name is a file. And, we can use the exists method to test whether a directory or file already exists on the system.
3.2. Getting Metadata About File Instances
The File class has a number of methods that return metadata about File instances. Let’s see how to use the getName, getParentFile, and getPath methods:
@Test
public void givenFile_whenCreateNewFile_thenMetadataIsCorrect() {
String sep = File.separator;
File parentDir = makeDir("filesDir");
File child = new File(parentDir, "file.txt");
try {
child.createNewFile();
} catch (IOException e) {
fail("Could not create " + "file.txt");
}
assertEquals("file.txt", child.getName());
assertEquals(parentDir.getName(), child.getParentFile().getName());
assertEquals(parentDir.getPath() + sep + "file.txt", child.getPath());
removeDir(parentDir);
}
Here, we’ve illustrated validating the metadata about the file that was created inside the directory. We’ve also shown how to find the parent of the file and the relative path to that file.
3.3. Setting File and Directory Permissions
The File class has methods that allow you to set permissions on a file or a directory. Here, we’ll look at the setWritable and setReadable methods:
@Test
public void givenReadOnlyFile_whenCreateNewFile_thenCantModFile() {
File parentDir = makeDir("readDir");
File child = new File(parentDir, "file.txt");
try {
child.createNewFile();
} catch (IOException e) {
fail("Could not create " + "file.txt");
}
child.setWritable(false);
boolean writable = true;
try (FileOutputStream fos = new FileOutputStream(child)) {
fos.write("Hello World".getBytes()); // write operation
fos.flush();
} catch (IOException e) {
writable = false;
} finally {
removeDir(parentDir);
}
assertFalse(writable);
}
In the code above, we attempt to write to a file after we explicitly set permissions on it that blocks any writes. We do this with the setWritable method. Attempting to write to a file when writing to the file is not permitted results in a IOException being thrown.
Next, we attempt to read from a file after setting permissions on it that blocks any reads. Reads are blocked using the setReadable method:
@Test
public void givenWriteOnlyFile_whenCreateNewFile_thenCantReadFile() {
File parentDir = makeDir("writeDir");
File child = new File(parentDir, "file.txt");
try {
child.createNewFile();
} catch (IOException e) {
fail("Could not create " + "file.txt");
}
child.setReadable(false);
boolean readable = true;
try (FileInputStream fis = new FileInputStream(child)) {
fis.read(); // read operation
} catch (IOException e) {
readable = false;
} finally {
removeDir(parentDir);
}
assertFalse(readable);
}
Again, the JVM will throw a IOException for attempts to read a file where reads are not permitted.
3.4. Listing Files Inside a Directory
The File class has methods that allow us to list files contained in a directory. Similarly, directories can also be listed. Here we’ll look at the list and list(FilenameFilter) methods:
@Test
public void givenFilesInDir_whenCreateNewFile_thenCanListFiles() {
File parentDir = makeDir("filtersDir");
String[] files = {"file1.csv", "file2.txt"};
for (String file : files) {
try {
new File(parentDir, file).createNewFile();
} catch (IOException e) {
fail("Could not create " + file);
}
}
//normal listing
assertEquals(2, parentDir.list().length);
//filtered listing
FilenameFilter csvFilter = (dir, ext) -> ext.endsWith(".csv");
assertEquals(1, parentDir.list(csvFilter).length);
removeDir(parentDir);
}
We created a directory and added two files to it — one with a csv extension and the other with a txt extension. When listing all files in the directory, we get two files as expected. When we filter the listing by filtering around files with a csv extension, we get only one file returned.
3.5. Renaming Files and Directories
The File class has the functionality of renaming files and directories using the renameTo method:
@Test
public void givenDir_whenMkdir_thenCanRenameDir() {
File source = makeDir("source");
File destination = makeDir("destination");
boolean renamed = source.renameTo(destination);
if (renamed) {
assertFalse(source.isDirectory());
assertTrue(destination.isDirectory());
removeDir(destination);
}
}
In the example above, we create two directories — the source and the destination directories. We then rename the source directory to the destination directory using the renameTo method. The same can be used to rename files instead of directories.
3.6. Getting Disk Space Information
The File class also allows us to get disk space information. Let’s see a demonstration of the getFreeSpace method:
@Test
public void givenDataWritten_whenWrite_thenFreeSpaceReduces() {
String home = System.getProperty("user.home");
String sep = File.separator;
File testDir = makeDir(home + sep + "test");
File sample = new File(testDir, "sample.txt");
long freeSpaceBefore = testDir.getFreeSpace();
try {
writeSampleDataToFile(sample);
} catch (IOException e) {
fail("Could not write to " + "sample.txt");
}
long freeSpaceAfter = testDir.getFreeSpace();
assertTrue(freeSpaceAfter < freeSpaceBefore);
removeDir(testDir);
}
In this example, we created a directory inside the user’s home directory and then created a file in it. We then checked if the free space on the home directory partition had changed after populating this file with some text. Other methods that give information about disk space are getTotalSpace and getUsableSpace.
4. Conclusion
In this tutorial, we’ve shown some of the functionality the File class provides for working with files and directories on the file system. .
As always, the full source code of the example is available over on Github.