10 File Handling in Java Interview Questions and Answers

File handling in Java is a crucial skill for developers, enabling them to read, write, and manipulate files efficiently. Mastery of file handling is essential for tasks such as data storage, configuration management, and logging. Java provides a robust set of classes and methods in the java.io and java.nio packages, making it versatile for various file operations.

This article offers a curated selection of interview questions focused on file handling in Java. By working through these questions and their detailed answers, you will gain a deeper understanding of file manipulation techniques and be better prepared to demonstrate your expertise in technical interviews.

File Handling in Java Interview Questions and Answers

1. Write a Java program to read a text file line by line and print its contents to the console.

To read a text file line by line in Java, use the BufferedReader class for efficient reading of characters, arrays, and lines. The FileReader class reads the file itself. Here’s an example:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReadExample {
    public static void main(String[] args) {
        String filePath = "example.txt";
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Write a Java program to serialize an object to a file and then deserialize it back to an object.

Serialization in Java converts an object into a byte stream for file writing or network transmission. Deserialization reverses this process. The class must implement the Serializable interface. Use ObjectOutputStream to write and ObjectInputStream to read the object.

Example:

import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class SerializeDeserializeExample {
    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);

        // Serialize the object
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // Deserialize the object
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person deserializedPerson = (Person) ois.readObject();
            System.out.println("Deserialized Person: " + deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

3. Write a Java program to access and modify file metadata, such as the last modified date.

In Java, file metadata can be accessed and modified using the java.nio.file package. The Files class offers methods to read and set file attributes, including the last modified date.

Example:

import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.Date;

public class FileMetadataExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("example.txt");

        try {
            // Accessing the last modified time
            FileTime lastModifiedTime = Files.getLastModifiedTime(filePath);
            System.out.println("Last Modified Time: " + lastModifiedTime);

            // Modifying the last modified time
            FileTime newTime = FileTime.fromMillis(new Date().getTime());
            Files.setLastModifiedTime(filePath, newTime);
            System.out.println("Updated Last Modified Time: " + Files.getLastModifiedTime(filePath));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. Write a Java program to create a memory-mapped file and read/write data to it.

Memory-mapped files in Java map a file region directly into memory, allowing efficient file I/O operations. This is useful for large files, enabling access as if they were part of the main memory. Use the java.nio package, specifically FileChannel and MappedByteBuffer.

Example:

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MemoryMappedFileExample {
    public static void main(String[] args) throws Exception {
        // Create a RandomAccessFile
        RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
        FileChannel channel = file.getChannel();

        // Map a region of the file into memory
        MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);

        // Write data to the memory-mapped file
        buffer.put("Hello, Memory-Mapped File!".getBytes());

        // Read data from the memory-mapped file
        buffer.position(0);
        for (int i = 0; i < "Hello, Memory-Mapped File!".length(); i++) {
            System.out.print((char) buffer.get());
        }

        // Close the file and channel
        channel.close();
        file.close();
    }
}

5. Write a Java program to demonstrate file locking using FileChannel.

File locking in Java restricts file access to one thread or process at a time, preventing data corruption. Use the FileChannel class to acquire and release locks, represented by the FileLock class.

Example:

import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileLockExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.WRITE)) {
            FileLock lock = fileChannel.lock();

            try {
                System.out.println("File is locked.");
                // Perform file operations here
            } finally {
                lock.release();
                System.out.println("File lock released.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6. Write a Java program to list all files in a directory using DirectoryStream.

To list all files in a directory using DirectoryStream, utilize the java.nio.file package. The DirectoryStream interface allows iteration over directory entries.

Example:

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ListFiles {
    public static void main(String[] args) {
        Path dir = Paths.get("path/to/directory");

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
            for (Path entry : stream) {
                System.out.println(entry.getFileName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7. Write a Java program to monitor a directory for changes using the WatchService API.

The WatchService API monitors a directory for changes like creation, deletion, and modification of files. It is part of the java.nio.file package and allows non-blocking file system change monitoring.

Example:

import java.nio.file.*;
import static java.nio.file.StandardWatchEventKinds.*;

public class DirectoryWatcher {
    public static void main(String[] args) throws Exception {
        WatchService watchService = FileSystems.getDefault().newWatchService();
        Path path = Paths.get("path/to/directory");
        path.register(watchService, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

        System.out.println("Watching directory: " + path);

        while (true) {
            WatchKey key = watchService.take();
            for (WatchEvent<?> event : key.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();
                Path fileName = (Path) event.context();
                System.out.println(kind.name() + ": " + fileName);
            }
            boolean valid = key.reset();
            if (!valid) {
                break;
            }
        }
    }
}

8. Write a Java program to filter files in a directory based on a custom file filter.

To filter files in a directory based on a custom file filter, use the FileFilter interface from the java.io package. This allows defining a filter for selecting files that meet specific criteria.

Example:

import java.io.File;
import java.io.FileFilter;

public class CustomFileFilter implements FileFilter {
    private String extension;

    public CustomFileFilter(String extension) {
        this.extension = extension;
    }

    @Override
    public boolean accept(File file) {
        return file.isFile() && file.getName().endsWith(extension);
    }

    public static void main(String[] args) {
        File directory = new File("path/to/directory");
        FileFilter filter = new CustomFileFilter(".txt");

        File[] filteredFiles = directory.listFiles(filter);
        for (File file : filteredFiles) {
            System.out.println(file.getName());
        }
    }
}

9. Write a Java program to read and write binary data using DataInputStream and DataOutputStream.

DataInputStream and DataOutputStream are used to read and write primitive data types in a portable way. These streams handle binary data, useful for file I/O operations.

Example:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BinaryFileHandler {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
            dos.writeInt(123);
            dos.writeDouble(45.67);
            dos.writeBoolean(true);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int intValue = dis.readInt();
            double doubleValue = dis.readDouble();
            boolean booleanValue = dis.readBoolean();
            System.out.println("Read values: " + intValue + ", " + doubleValue + ", " + booleanValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

10. Explain how to work with file paths in a cross-platform manner using Path and Paths classes.

Handling file paths in a cross-platform manner is important due to different path separators used by operating systems. The Path and Paths classes in the java.nio.file package abstract these differences.

Example:

import java.nio.file.Path;
import java.nio.file.Paths;

public class FilePathExample {
    public static void main(String[] args) {
        Path path = Paths.get("src", "main", "resources", "file.txt");
        System.out.println("Path: " + path.toString());
    }
}

In this example, Paths.get creates a Path instance using the appropriate separator for the operating system.