Android File Operations Java Samples

// Android Java Text File Read/Write Examples
// Using Android Context and Java IO

import android.content.Context;
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.List;

// 1. Basic Text File Writing
class TextFileWriter {
    private Context context;

    public TextFileWriter(Context context) {
        this.context = context;
    }

    // Write simple text to internal storage
    public void writeText(String filename, String text) {
        try {
            FileOutputStream output = context.openFileOutput(filename, Context.MODE_PRIVATE);
            output.write(text.getBytes(StandardCharsets.UTF_8));
            output.close();
            System.out.println("Text written to: " + filename);
        } catch (Exception e) {
            System.out.println("Error writing file: " + e.getMessage());
        }
    }

    // Write text with specific encoding
    public void writeText(String filename, String text, Charset charset) {
        try {
            FileOutputStream output = context.openFileOutput(filename, Context.MODE_PRIVATE);
            output.write(text.getBytes(charset));
            output.close();
            System.out.println("Text written with " + charset.name() + " to: " + filename);
        } catch (Exception e) {
            System.out.println("Error writing file: " + e.getMessage());
        }
    }

    // Append text to existing file
    public void appendText(String filename, String text) {
        try {
            FileOutputStream output = context.openFileOutput(filename, Context.MODE_APPEND);
            output.write(text.getBytes(StandardCharsets.UTF_8));
            output.close();
            System.out.println("Text appended to: " + filename);
        } catch (Exception e) {
            System.out.println("Error appending: " + e.getMessage());
        }
    }

    // Write text with line endings
    public void writeLines(String filename, List<String> lines) {
        StringBuilder content = new StringBuilder();
        for (int i = 0; i < lines.size(); i++) {
            if (i > 0) content.append("\n");
            content.append(lines.get(i));
        }
        writeText(filename, content.toString());
        System.out.println(lines.size() + " lines written to: " + filename);
    }

    // Write to external storage
    public void writeToExternalFile(File file, String text) {
        try {
            FileOutputStream output = new FileOutputStream(file);
            output.write(text.getBytes(StandardCharsets.UTF_8));
            output.close();
            System.out.println("Text written to external: " + file.getAbsolutePath());
        } catch (Exception e) {
            System.out.println("Error writing to external: " + e.getMessage());
        }
    }

    // Write with BufferedWriter
    public void writeWithBuffer(File file, String text) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter(file));
            writer.write(text);
            writer.close();
            System.out.println("Text written with buffer to: " + file.getAbsolutePath());
        } catch (Exception e) {
            System.out.println("Error writing with buffer: " + e.getMessage());
        }
    }
}

// 2. Basic Text File Reading
class TextFileReader {
    private Context context;

    public TextFileReader(Context context) {
        this.context = context;
    }

    // Read entire file as string
    public String readText(String filename) {
        try {
            FileInputStream input = context.openFileInput(filename);
            BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                if (content.length() > 0) content.append("\n");
                content.append(line);
            }
            reader.close();
            System.out.println("Read " + content.length() + " characters from: " + filename);
            return content.toString();
        } catch (Exception e) {
            System.out.println("Error reading file: " + e.getMessage());
            return null;
        }
    }

    // Read with encoding detection
    public String readTextWithEncoding(String filename) {
        Charset[] encodings = {StandardCharsets.UTF_8, StandardCharsets.ISO_8859_1, StandardCharsets.UTF_16};

        for (Charset encoding : encodings) {
            try {
                FileInputStream input = context.openFileInput(filename);
                BufferedReader reader = new BufferedReader(new InputStreamReader(input, encoding));
                StringBuilder content = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    if (content.length() > 0) content.append("\n");
                    content.append(line);
                }
                reader.close();
                System.out.println("Read file with encoding: " + encoding.name());
                return content.toString();
            } catch (Exception e) {
                // Try next encoding
            }
        }

        System.out.println("Could not read file with any supported encoding");
        return null;
    }

    // Read line by line
    public List<String> readLines(String filename) {
        try {
            FileInputStream input = context.openFileInput(filename);
            BufferedReader reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8));
            List<String> lines = new java.util.ArrayList<>();
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
            reader.close();
            System.out.println("Read " + lines.size() + " lines from: " + filename);
            return lines;
        } catch (Exception e) {
            System.out.println("Error reading lines: " + e.getMessage());
            return null;
        }
    }

    // Read from external storage
    public String readFromExternalFile(File file) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                if (content.length() > 0) content.append("\n");
                content.append(line);
            }
            reader.close();
            return content.toString();
        } catch (Exception e) {
            System.out.println("Error reading from external: " + e.getMessage());
            return null;
        }
    }

    // Read with BufferedReader (for large files)
    public String readWithBuffer(File file) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                if (content.length() > 0) content.append("\n");
                content.append(line);
            }
            reader.close();
            return content.toString();
        } catch (Exception e) {
            System.out.println("Error reading with buffer: " + e.getMessage());
            return null;
        }
    }

    // Read specific range
    public String readRange(File file, long start, int length) {
        try {
            RandomAccessFile raf = new RandomAccessFile(file, "r");
            raf.seek(start);
            byte[] bytes = new byte[length];
            raf.read(bytes);
            raf.close();
            return new String(bytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            System.out.println("Error reading range: " + e.getMessage());
            return null;
        }
    }
}

// 3. File Info Helper
class FileInfoHelper {
    private Context context;

    public FileInfoHelper(Context context) {
        this.context = context;
    }

    public File getFileAttributes(String filename) {
        File file = new File(context.getFilesDir(), filename);
        return file.exists() ? file : null;
    }

    public void printFileInfo(String filename) {
        File file = getFileAttributes(filename);
        if (file == null) {
            System.out.println("No file info available for: " + filename);
            return;
        }

        System.out.println("\n--- File Info: " + filename + " ---");
        System.out.println("Size: " + file.length() + " bytes");
        System.out.println("Modified: " + new Date(file.lastModified()));
        System.out.println("Path: " + file.getAbsolutePath());
        System.out.println("Can read: " + file.canRead());
        System.out.println("Can write: " + file.canWrite());
    }
}

// 4. Advanced Text Operations
class AdvancedTextOperations {
    private Context context;

    public AdvancedTextOperations(Context context) {
        this.context = context;
    }

    // Search for text in file
    public List<String[]> searchInFile(String filename, String searchText) {
        List<String> lines = new TextFileReader(context).readLines(filename);
        List<String[]> results = new java.util.ArrayList<>();

        if (lines != null) {
            for (int i = 0; i < lines.size(); i++) {
                String line = lines.get(i);
                if (line.toLowerCase().contains(searchText.toLowerCase())) {
                    results.add(new String[]{line, String.valueOf(i + 1)});
                }
            }
        }

        return results;
    }

    // Replace text in file
    public boolean replaceInFile(String filename, String searchText, String replaceWith) {
        String content = new TextFileReader(context).readText(filename);
        if (content == null) return false;

        String newContent = content.replace(searchText, replaceWith);
        new TextFileWriter(context).writeText(filename, newContent);
        System.out.println("Replaced occurrences of '" + searchText + "' in: " + filename);
        return true;
    }

    // Count words in file
    public int countWordsInFile(String filename) {
        String content = new TextFileReader(context).readText(filename);
        if (content == null) return 0;

        String[] words = content.split("\\s+");
        int count = 0;
        for (String word : words) {
            if (!word.isEmpty()) count++;
        }
        return count;
    }

    // Read and parse CSV
    public List<List<String>> readCSV(String filename) {
        String content = new TextFileReader(context).readText(filename);
        List<List<String>> data = new java.util.ArrayList<>();

        if (content != null) {
            String[] lines = content.split("\n");
            for (String line : lines) {
                if (!line.isEmpty()) {
                    String[] values = line.split(",");
                    List<String> row = new java.util.ArrayList<>(java.util.Arrays.asList(values));
                    data.add(row);
                }
            }
        }

        return data;
    }

    // Write JSON to file
    public void writeJSON(String filename, String json) {
        new TextFileWriter(context).writeText(filename, json);
        System.out.println("JSON written to: " + filename);
    }

    // Read JSON from file
    public String readJSON(String filename) {
        return new TextFileReader(context).readText(filename);
    }
}

// Main demonstration
class FileOperationsDemo {
    public static void demonstrateTextFileOperations(Context context) {
        System.out.println("=== Android Java Text File Read/Write Examples ===\n");

        String testFile = "test_text_file.txt";
        String testContent = "Hello, World!\n" +
            "This is a test file.\n" +
            "Created with Java on Android.\n" +
            "Line 4\n" +
            "Line 5";

        TextFileWriter writer = new TextFileWriter(context);
        TextFileReader reader = new TextFileReader(context);

        // 1. Basic write
        System.out.println("--- 1. Basic Write ---");
        writer.writeText(testFile, testContent);

        // 2. Basic read
        System.out.println("\n--- 2. Basic Read ---");
        String content = reader.readText(testFile);
        System.out.println("Content:\n" + content);

        // 3. Read lines
        System.out.println("\n--- 3. Read Lines ---");
        List<String> lines = reader.readLines(testFile);
        System.out.println(lines.size() + " lines:");
        for (int i = 0; i < lines.size(); i++) {
            System.out.println("  " + (i + 1) + ": " + lines.get(i));
        }

        // 4. Append text
        System.out.println("\n--- 4. Append Text ---");
        writer.appendText(testFile, "\nAppended line!");
        String updatedContent = reader.readText(testFile);
        System.out.println("Updated content: " + updatedContent);

        // 5. File info
        System.out.println("\n--- 5. File Info ---");
        FileInfoHelper fileInfo = new FileInfoHelper(context);
        fileInfo.printFileInfo(testFile);

        // 6. Word count
        System.out.println("\n--- 6. Word Count ---");
        AdvancedTextOperations advancedOps = new AdvancedTextOperations(context);
        int wordCount = advancedOps.countWordsInFile(testFile);
        System.out.println("Total words: " + wordCount);

        System.out.println("\n=== All Text File Operations Completed ===");
    }
}

// Android Java File Copy/Move Examples
// Using Android Context and Java IO

import android.content.Context;
import java.io.*;
import java.nio.channels.FileChannel;

// 1. Basic File Copy
class FileCopier {
    private Context context;

    public FileCopier(Context context) {
        this.context = context;
    }

    // Simple copy using streams
    public void copyFile(File source, File destination) {
        try {
            FileInputStream input = new FileInputStream(source);
            FileOutputStream output = new FileOutputStream(destination);

            byte[] buffer = new byte[1024];
            int length;
            while ((length = input.read(buffer)) > 0) {
                output.write(buffer, 0, length);
            }

            input.close();
            output.close();

            System.out.println("Copied: " + source.getAbsolutePath() + " -> " + destination.getAbsolutePath());
        } catch (Exception e) {
            System.out.println("Error copying file: " + e.getMessage());
        }
    }

    // Copy with overwrite option
    public void copyFile(File source, File destination, boolean overwrite) {
        if (destination.exists()) {
            if (overwrite) {
                destination.delete();
                System.out.println("Removed existing file: " + destination.getAbsolutePath());
            } else {
                System.out.println("File already exists: " + destination.getAbsolutePath());
                return;
            }
        }

        copyFile(source, destination);
    }

    // Copy to directory
    public void copyFileToDirectory(File source, File directory) {
        if (!directory.exists()) {
            directory.mkdirs();
        }

        File destination = new File(directory, source.getName());
        copyFile(source, destination);
    }

    // Copy with progress callback
    public interface ProgressCallback {
        void onProgress(double progress);
    }

    public void copyFileWithProgress(File source, File destination, ProgressCallback progress) {
        try {
            if (!source.exists()) {
                System.out.println("Source file not found: " + source.getAbsolutePath());
                return;
            }

            long fileSize = source.length();
            FileInputStream input = new FileInputStream(source);
            FileOutputStream output = new FileOutputStream(destination);

            byte[] buffer = new byte[1024 * 1024]; // 1MB buffer
            long bytesCopied = 0;
            int length;

            while ((length = input.read(buffer)) > 0) {
                output.write(buffer, 0, length);
                bytesCopied += length;

                if (progress != null) {
                    double percent = (double) bytesCopied / fileSize;
                    progress.onProgress(percent);
                }
            }

            input.close();
            output.close();

            System.out.println("Copy completed: " + destination.getAbsolutePath());
        } catch (Exception e) {
            System.out.println("Error copying with progress: " + e.getMessage());
        }
    }

    // Copy using FileChannel (NIO)
    public void copyFileNIO(File source, File destination) {
        try {
            FileChannel sourceChannel = new FileInputStream(source).getChannel();
            FileChannel destChannel = new FileOutputStream(destination).getChannel();

            destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());

            sourceChannel.close();
            destChannel.close();

            System.out.println("Copied using NIO: " + source.getAbsolutePath() + " -> " + destination.getAbsolutePath());
        } catch (Exception e) {
            System.out.println("Error copying with NIO: " + e.getMessage());
        }
    }
}

// 2. Basic File Move
class FileMover {
    private Context context;

    public FileMover(Context context) {
        this.context = context;
    }

    // Simple move
    public boolean moveFile(File source, File destination) {
        boolean result = source.renameTo(destination);
        if (result) {
            System.out.println("Moved: " + source.getAbsolutePath() + " -> " + destination.getAbsolutePath());
        } else {
            System.out.println("Failed to move: " + source.getAbsolutePath());
        }
        return result;
    }

    // Move with overwrite
    public boolean moveFile(File source, File destination, boolean overwrite) {
        if (destination.exists()) {
            if (overwrite) {
                destination.delete();
                System.out.println("Removed existing file: " + destination.getAbsolutePath());
            } else {
                System.out.println("File already exists: " + destination.getAbsolutePath());
                return false;
            }
        }

        return moveFile(source, destination);
    }

    // Move to directory
    public boolean moveFileToDirectory(File source, File directory) {
        if (!directory.exists()) {
            directory.mkdirs();
        }

        File destination = new File(directory, source.getName());
        return moveFile(source, destination);
    }

    // Safe move with backup
    public boolean moveFileWithBackup(File source, File destination) {
        // Create backup if destination exists
        if (destination.exists()) {
            File backupFile = new File(destination.getParent(), destination.getName() + ".backup");
            destination.renameTo(backupFile);
            System.out.println("Backup created: " + backupFile.getAbsolutePath());
        }

        return moveFile(source, destination);
    }

    // Move using copy and delete (for cross-device moves)
    public boolean moveFileCopyDelete(File source, File destination) {
        try {
            // Copy first
            new FileCopier(context).copyFile(source, destination);

            // Delete source after successful copy
            source.delete();
            System.out.println("Moved (copy+delete): " + source.getAbsolutePath() + " -> " + destination.getAbsolutePath());
            return true;
        } catch (Exception e) {
            System.out.println("Error moving with copy+delete: " + e.getMessage());
            return false;
        }
    }
}

// 3. Batch Operations
class BatchFileOperations {
    private Context context;

    public BatchFileOperations(Context context) {
        this.context = context;
    }

    // Copy multiple files
    public void copyFiles(List<File> sources, File destinationDirectory) {
        if (!destinationDirectory.exists()) {
            destinationDirectory.mkdirs();
        }

        int successCount = 0;
        int failureCount = 0;

        FileCopier copier = new FileCopier(context);
        for (File source : sources) {
            try {
                File destination = new File(destinationDirectory, source.getName());
                copier.copyFile(source, destination, true);
                successCount++;
            } catch (Exception e) {
                System.out.println("Failed to copy " + source.getName() + ": " + e.getMessage());
                failureCount++;
            }
        }

        System.out.println("Batch copy completed: " + successCount + " succeeded, " + failureCount + " failed");
    }

    // Move multiple files
    public void moveFiles(List<File> sources, File destinationDirectory) {
        if (!destinationDirectory.exists()) {
            destinationDirectory.mkdirs();
        }

        int successCount = 0;
        int failureCount = 0;

        FileMover mover = new FileMover(context);
        for (File source : sources) {
            try {
                File destination = new File(destinationDirectory, source.getName());
                mover.moveFile(source, destination, true);
                successCount++;
            } catch (Exception e) {
                System.out.println("Failed to move " + source.getName() + ": " + e.getMessage());
                failureCount++;
            }
        }

        System.out.println("Batch move completed: " + successCount + " succeeded, " + failureCount + " failed");
    }

    // Copy directory recursively
    public void copyDirectory(File sourceDir, File destinationDir) {
        if (!sourceDir.isDirectory()) {
            System.out.println("Not a directory: " + sourceDir.getAbsolutePath());
            return;
        }

        if (!destinationDir.exists()) {
            destinationDir.mkdirs();
        }

        File[] files = sourceDir.listFiles();
        if (files != null) {
            for (File file : files) {
                File destination = new File(destinationDir, file.getName());
                if (file.isDirectory()) {
                    copyDirectory(file, destination);
                } else {
                    new FileCopier(context).copyFile(file, destination);
                }
            }
        }

        System.out.println("Directory copied: " + sourceDir.getAbsolutePath() + " -> " + destinationDir.getAbsolutePath());
    }

    // Move directory
    public boolean moveDirectory(File sourceDir, File destinationDir) {
        if (!sourceDir.isDirectory()) {
            System.out.println("Not a directory: " + sourceDir.getAbsolutePath());
            return false;
        }

        boolean result = sourceDir.renameTo(destinationDir);
        if (result) {
            System.out.println("Directory moved: " + sourceDir.getAbsolutePath() + " -> " + destinationDir.getAbsolutePath());
        } else {
            // Try recursive move
            copyDirectory(sourceDir, destinationDir);
            deleteDirectory(sourceDir);
        }

        return result;
    }

    private void deleteDirectory(File dir) {
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    deleteDirectory(file);
                } else {
                    file.delete();
                }
            }
        }
        dir.delete();
    }
}

// 4. Smart File Operations
class SmartFileOperations {
    private Context context;

    public SmartFileOperations(Context context) {
        this.context = context;
    }

    // Copy with duplicate handling
    public void smartCopy(File source, File destination) {
        if (destination.exists()) {
            // Add number suffix
            String baseName = destination.getName().replaceAll("\\.[^.]*$", "");
            String extension = "";
            int dotIndex = destination.getName().lastIndexOf('.');
            if (dotIndex > 0) {
                extension = destination.getName().substring(dotIndex);
                baseName = destination.getName().substring(0, dotIndex);
            }

            int counter = 1;
            File newPath = destination;

            while (newPath.exists()) {
                String newBaseName = baseName + "_" + counter;
                newPath = new File(destination.getParent(), newBaseName + extension);
                counter++;
            }

            System.out.println("Destination exists, using: " + newPath.getAbsolutePath());
            new FileCopier(context).copyFile(source, newPath);
        } else {
            new FileCopier(context).copyFile(source, destination);
        }
    }

    // Verified copy
    public boolean verifiedCopy(File source, File destination) {
        long sourceSize = source.length();

        new FileCopier(context).copyFile(source, destination, true);

        // Verify by comparing file sizes
        long destSize = destination.length();

        if (sourceSize == destSize) {
            System.out.println("Verified copy: " + sourceSize + " bytes");
            return true;
        } else {
            System.out.println("Verification failed: size mismatch");
            return false;
        }
    }
}

// Main demonstration
class FileCopyMoveDemo {
    public static void demonstrateFileCopyMove(Context context) {
        System.out.println("=== Android Java File Copy/Move Examples ===\n");

        File tempDir = new File(context.getCacheDir(), "file_operations_test");
        tempDir.mkdirs();

        File sourceFile = new File(context.getCacheDir(), "source_test.txt");
        File destFile1 = new File(context.getCacheDir(), "dest_test1.txt");
        File destFile2 = new File(context.getCacheDir(), "dest_test2.txt");

        try {
            // Create test file
            FileWriter writer = new FileWriter(sourceFile);
            writer.write("Test content for copy/move");
            writer.close();

            FileCopier copier = new FileCopier(context);

            // 1. Simple copy
            System.out.println("--- 1. Simple Copy ---");
            copier.copyFile(sourceFile, destFile1);

            // 2. Copy with progress
            System.out.println("\n--- 2. Copy with Progress ---");
            copier.copyFileWithProgress(sourceFile, destFile2, new FileCopier.ProgressCallback() {
                @Override
                public void onProgress(double progress) {
                    System.out.println("Progress: " + (int)(progress * 100) + "%");
                }
            });

            // 3. Simple move
            System.out.println("\n--- 3. Simple Move ---");
            File moveSource = new File(context.getCacheDir(), "move_source.txt");
            File moveDest = new File(context.getCacheDir(), "move_dest.txt");

            FileWriter moveWriter = new FileWriter(moveSource);
            moveWriter.write("File to move");
            moveWriter.close();

            FileMover mover = new FileMover(context);
            mover.moveFile(moveSource, moveDest);

            // 4. Smart copy
            System.out.println("\n--- 4. Smart Copy ---");
            File smartSource = new File(context.getCacheDir(), "smart_source.txt");
            File smartDest = new File(context.getCacheDir(), "smart_dest.txt");

            FileWriter smartWriter = new FileWriter(smartSource);
            smartWriter.write("Smart copy test");
            smartWriter.close();

            SmartFileOperations smartOps = new SmartFileOperations(context);
            smartOps.smartCopy(smartSource, smartDest);
            smartOps.smartCopy(smartSource, smartDest); // Will create duplicate

            // 5. Verified copy
            System.out.println("\n--- 5. Verified Copy ---");
            File verifySource = new File(context.getCacheDir(), "verify_source.txt");
            File verifyDest = new File(context.getCacheDir(), "verify_dest.txt");

            FileWriter verifyWriter = new FileWriter(verifySource);
            verifyWriter.write("Verification test");
            verifyWriter.close();

            smartOps.verifiedCopy(verifySource, verifyDest);

            // Cleanup
            tempDir.delete();
            System.out.println("\nCleanup completed");

        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }

        System.out.println("\n=== All File Copy/Move Examples Completed ===");
    }
}

// Android Java Directory Traversal Examples
// Using Android Context and Java IO

import android.content.Context;
import java.io.*;
import java.util.*;

// 1. Basic Directory Listing
class DirectoryLister {
    private Context context;

    public DirectoryLister(Context context) {
        this.context = context;
    }

    // List all items in directory
    public List<String> listDirectory(File directory) {
        if (!directory.exists() || !directory.isDirectory()) {
            System.out.println("Not a directory: " + directory.getAbsolutePath());
            return null;
        }

        File[] files = directory.listFiles();
        if (files == null) return null;

        List<String> fileNames = new ArrayList<>();
        for (File file : files) {
            fileNames.add(file.getName());
        }

        return fileNames;
    }

    // List with details
    public static class FileItem {
        public String name;
        public String path;
        public boolean isDirectory;
        public long size;
        public Date modifiedDate;

        public FileItem(String name, String path, boolean isDirectory, long size, Date modifiedDate) {
            this.name = name;
            this.path = path;
            this.isDirectory = isDirectory;
            this.size = size;
            this.modifiedDate = modifiedDate;
        }
    }

    public List<FileItem> listDirectoryWithDetails(File directory) {
        if (!directory.exists() || !directory.isDirectory()) {
            return null;
        }

        File[] files = directory.listFiles();
        if (files == null) return null;

        List<FileItem> items = new ArrayList<>();
        for (File file : files) {
            FileItem item = new FileItem(
                file.getName(),
                file.getAbsolutePath(),
                file.isDirectory(),
                file.isFile() ? file.length() : 0,
                new Date(file.lastModified())
            );
            items.add(item);
        }

        return items;
    }

    // List only files
    public List<File> listFiles(File directory) {
        File[] files = directory.listFiles();
        if (files == null) return null;

        List<File> fileList = new ArrayList<>();
        for (File file : files) {
            if (file.isFile()) {
                fileList.add(file);
            }
        }

        return fileList;
    }

    // List only subdirectories
    public List<File> listSubdirectories(File directory) {
        File[] files = directory.listFiles();
        if (files == null) return null;

        List<File> dirList = new ArrayList<>();
        for (File file : files) {
            if (file.isDirectory()) {
                dirList.add(file);
            }
        }

        return dirList;
    }
}

// 2. Recursive Directory Traversal
class DirectoryTraverser {
    private Context context;

    public DirectoryTraverser(Context context) {
        this.context = context;
    }

    // Recursively find all files
    public List<File> findAllFiles(File directory) {
        List<File> files = new ArrayList<>();

        if (!directory.exists() || !directory.isDirectory()) {
            return files;
        }

        File[] items = directory.listFiles();
        if (items == null) return files;

        for (File item : items) {
            if (item.isDirectory()) {
                files.addAll(findAllFiles(item));
            } else {
                files.add(item);
            }
        }

        return files;
    }

    // Recursive traversal with callback
    public interface TraversalCallback {
        void onFile(File file, int depth);
    }

    public void traverseDirectory(File directory, TraversalCallback callback) {
        traverseDirectory(directory, 0, callback);
    }

    private void traverseDirectory(File directory, int depth, TraversalCallback callback) {
        if (!directory.exists() || !directory.isDirectory()) {
            return;
        }

        File[] items = directory.listFiles();
        if (items == null) return;

        for (File item : items) {
            callback.onFile(item, depth);

            if (item.isDirectory()) {
                traverseDirectory(item, depth + 1, callback);
            }
        }
    }

    // Get directory tree
    public static class DirectoryNode {
        public String name;
        public String path;
        public boolean isDirectory;
        public int depth;
        public List<DirectoryNode> children = new ArrayList<>();

        public DirectoryNode(String name, String path, boolean isDirectory, int depth) {
            this.name = name;
            this.path = path;
            this.isDirectory = isDirectory;
            this.depth = depth;
        }

        public void printTree() {
            String indent = "  ".repeat(depth);
            String prefix = isDirectory ? "📁" : "📄";
            System.out.println(prefix + " " + indent + name);
            for (DirectoryNode child : children) {
                child.printTree();
            }
        }
    }

    public DirectoryNode getDirectoryTree(File directory, int maxDepth) {
        DirectoryNode root = new DirectoryNode(
            directory.getName(),
            directory.getAbsolutePath(),
            true,
            0
        );
        buildTree(root, maxDepth);
        return root;
    }

    private void buildTree(DirectoryNode node, int maxDepth) {
        if (node.depth >= maxDepth) return;

        File directory = new File(node.path);
        if (!directory.exists() || !directory.isDirectory()) {
            return;
        }

        File[] files = directory.listFiles();
        if (files == null) return;

        // Sort by name
        Arrays.sort(files, Comparator.comparing(File::getName));

        for (File file : files) {
            DirectoryNode childNode = new DirectoryNode(
                file.getName(),
                file.getAbsolutePath(),
                file.isDirectory(),
                node.depth + 1
            );
            node.children.add(childNode);

            if (file.isDirectory()) {
                buildTree(childNode, maxDepth);
            }
        }
    }
}

// 3. File Filtering
class FileFilter {
    private Context context;

    public FileFilter(Context context) {
        this.context = context;
    }

    // Filter by extension
    public List<File> filterByExtension(File directory, List<String> extensions) {
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> files = traverser.findAllFiles(directory);

        List<File> filtered = new ArrayList<>();
        for (File file : files) {
            String extension = getFileExtension(file);
            if (extensions.contains(extension.toLowerCase())) {
                filtered.add(file);
            }
        }

        return filtered;
    }

    // Filter by name pattern
    public List<File> filterByNamePattern(File directory, String pattern) {
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> files = traverser.findAllFiles(directory);

        List<File> filtered = new ArrayList<>();
        for (File file : files) {
            if (file.getName().matches(pattern)) {
                filtered.add(file);
            }
        }

        return filtered;
    }

    // Filter by size
    public List<File> filterBySize(File directory, long minSize, long maxSize) {
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> files = traverser.findAllFiles(directory);

        List<File> filtered = new ArrayList<>();
        for (File file : files) {
            long size = file.length();
            if (size >= minSize && size <= maxSize) {
                filtered.add(file);
            }
        }

        return filtered;
    }

    private String getFileExtension(File file) {
        String name = file.getName();
        int dotIndex = name.lastIndexOf('.');
        return dotIndex > 0 ? name.substring(dotIndex + 1) : "";
    }
}

// 4. Directory Statistics
class DirectoryStatistics {
    private Context context;

    public DirectoryStatistics(Context context) {
        this.context = context;
    }

    public static class Stats {
        public int totalFiles = 0;
        public int totalDirectories = 0;
        public long totalSize = 0;
        public String largestFilePath;
        public long largestFileSize = 0;
        public Map<String, Integer> extensionCounts = new HashMap<>();

        public void printStats() {
            System.out.println("\n=== Directory Statistics ===");
            System.out.println("Total files: " + totalFiles);
            System.out.println("Total directories: " + totalDirectories);
            System.out.println("Total size: " + formatBytes(totalSize));

            if (largestFileSize > 0) {
                System.out.println("Largest file: " + new File(largestFilePath).getName());
                System.out.println("  Size: " + formatBytes(largestFileSize));
            }

            System.out.println("\nExtension counts:");
            List<Map.Entry<String, Integer>> sorted = new ArrayList<>(extensionCounts.entrySet());
            Collections.sort(sorted, (a, b) -> b.getValue().compareTo(a.getValue()));

            for (Map.Entry<String, Integer> entry : sorted) {
                System.out.println("  ." + entry.getKey() + ": " + entry.getValue());
            }
        }

        private String formatBytes(long bytes) {
            double kb = bytes / 1024.0;
            double mb = kb / 1024;
            double gb = mb / 1024;

            if (gb >= 1) {
                return String.format("%.2f GB", gb);
            } else if (mb >= 1) {
                return String.format("%.2f MB", mb);
            } else if (kb >= 1) {
                return String.format("%.2f KB", kb);
            } else {
                return bytes + " bytes";
            }
        }
    }

    public Stats calculateStatistics(File directory) {
        Stats stats = new Stats();
        DirectoryTraverser traverser = new DirectoryTraverser(context);

        traverser.traverseDirectory(directory, (file, depth) -> {
            if (file.isDirectory()) {
                stats.totalDirectories++;
            } else {
                stats.totalFiles++;
                long size = file.length();
                stats.totalSize += size;

                // Track largest file
                if (size > stats.largestFileSize) {
                    stats.largestFileSize = size;
                    stats.largestFilePath = file.getAbsolutePath();
                }

                // Count extensions
                String extension = getFileExtension(file);
                if (extension.isEmpty()) {
                    extension = "(no extension)";
                }
                extension = extension.toLowerCase();
                stats.extensionCounts.put(extension, stats.extensionCounts.getOrDefault(extension, 0) + 1);
            }
        });

        return stats;
    }

    private String getFileExtension(File file) {
        String name = file.getName();
        int dotIndex = name.lastIndexOf('.');
        return dotIndex > 0 ? name.substring(dotIndex + 1) : "";
    }
}

// 5. File Searcher
class FileSearcher {
    private Context context;

    public FileSearcher(Context context) {
        this.context = context;
    }

    // Search files by name
    public List<File> searchByName(File directory, String name) {
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> files = traverser.findAllFiles(directory);

        List<File> results = new ArrayList<>();
        for (File file : files) {
            if (file.getName().toLowerCase().contains(name.toLowerCase())) {
                results.add(file);
            }
        }

        return results;
    }

    // Search files containing text
    public List<File> searchByContent(File directory, String searchText) {
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> files = traverser.findAllFiles(directory);

        List<File> results = new ArrayList<>();
        for (File file : files) {
            try {
                String content = readFile(file);
                if (content != null && content.toLowerCase().contains(searchText.toLowerCase())) {
                    results.add(file);
                }
            } catch (Exception e) {
                // Skip files that can't be read
            }
        }

        return results;
    }

    private String readFile(File file) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            StringBuilder content = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                if (content.length() > 0) content.append("\n");
                content.append(line);
            }
            reader.close();
            return content.toString();
        } catch (Exception e) {
            return null;
        }
    }
}

// Main demonstration
class DirectoryTraversalDemo {
    public static void demonstrateDirectoryTraversal(Context context) {
        System.out.println("=== Android Java Directory Traversal Examples ===\n");

        File testDir = new File(context.getCacheDir(), "directory_traversal_test");
        testDir.mkdirs();

        // Create some test files
        createTestFiles(testDir);

        DirectoryLister lister = new DirectoryLister(context);

        // 1. List directory
        System.out.println("--- 1. List Directory ---");
        List<String> items = lister.listDirectory(testDir);
        System.out.println("Items in " + testDir.getName() + ":");
        if (items != null) {
            for (String item : items) {
                System.out.println("  - " + item);
            }
        }

        // 2. List with details
        System.out.println("\n--- 2. List with Details ---");
        List<DirectoryLister.FileItem> detailedItems = lister.listDirectoryWithDetails(testDir);
        System.out.println("Files in " + testDir.getName() + ":");
        if (detailedItems != null) {
            for (DirectoryLister.FileItem item : detailedItems) {
                String type = item.isDirectory ? "DIR " : "FILE";
                System.out.println("  [" + type + "] " + item.name + " - " + item.size + " bytes");
            }
        }

        // 3. Recursive traversal
        System.out.println("\n--- 3. Recursive Traversal ---");
        DirectoryTraverser traverser = new DirectoryTraverser(context);
        List<File> allFiles = traverser.findAllFiles(testDir);
        System.out.println("All files:");
        for (File file : allFiles) {
            System.out.println("  - " + file.getAbsolutePath());
        }

        // 4. Directory tree
        System.out.println("\n--- 4. Directory Tree ---");
        DirectoryTraverser.DirectoryNode tree = traverser.getDirectoryTree(testDir, 2);
        tree.printTree();

        // 5. Filter by extension
        System.out.println("\n--- 5. Filter by Extension ---");
        FileFilter fileFilter = new FileFilter(context);
        List<String> txtExtensions = new ArrayList<>();
        txtExtensions.add("txt");
        List<File> txtFiles = fileFilter.filterByExtension(testDir, txtExtensions);
        System.out.println("Text files:");
        for (File file : txtFiles) {
            System.out.println("  - " + file.getName());
        }

        // 6. Directory statistics
        System.out.println("\n--- 6. Directory Statistics ---");
        DirectoryStatistics stats = new DirectoryStatistics(context);
        DirectoryStatistics.Stats directoryStats = stats.calculateStatistics(testDir);
        directoryStats.printStats();

        // 7. Search by name
        System.out.println("\n--- 7. Search by Name ---");
        FileSearcher searcher = new FileSearcher(context);
        List<File> searchResults = searcher.searchByName(testDir, "file");
        System.out.println("Files containing 'file':");
        for (File file : searchResults) {
            System.out.println("  - " + file.getName());
        }

        // Cleanup
        testDir.delete();
        System.out.println("\nCleanup completed");

        System.out.println("\n=== All Directory Traversal Examples Completed ===");
    }

    private static void createTestFiles(File testDir) {
        try {
            new File(testDir, "file1.txt").createNewFile();
            new File(testDir, "file2.md").createNewFile();

            File subDir = new File(testDir, "subdir");
            subDir.mkdirs();
            new File(subDir, "subfile1.txt").createNewFile();
        } catch (Exception e) {
            // Ignore
        }
    }
}

// Android Java File Validation Examples
// Using Android Context and Java IO

import android.content.Context;
import android.webkit.MimeTypeMap;
import java.io.*;
import java.security.MessageDigest;
import java.util.Date;

// 1. Basic File Existence Check
class FileChecker {
    private Context context;

    public FileChecker(Context context) {
        this.context = context;
    }

    // Check if file exists
    public boolean fileExists(File file) {
        return file.exists();
    }

    // Check if path is a file (not directory)
    public boolean isFile(File file) {
        return file.isFile();
    }

    // Check if path is a directory
    public boolean isDirectory(File file) {
        return file.isDirectory();
    }

    // Check if file is readable
    public boolean isReadable(File file) {
        return file.canRead();
    }

    // Check if file is writable
    public boolean isWritable(File file) {
        return file.canWrite();
    }

    // Comprehensive file check
    public static class FileStatus {
        public enum FileStatusType {
            NOT_FOUND, FILE, DIRECTORY
        }

        public FileStatusType status;
        public boolean isReadable;
        public boolean isWritable;
        public boolean isExecutable;

        public FileStatus(FileStatusType status, boolean isReadable, boolean isWritable, boolean isExecutable) {
            this.status = status;
            this.isReadable = isReadable;
            this.isWritable = isWritable;
            this.isExecutable = isExecutable;
        }
    }

    public FileStatus checkFile(File file) {
        if (!file.exists()) {
            return new FileStatus(FileStatus.FileStatusType.NOT_FOUND, false, false, false);
        }

        FileStatus.FileStatusType type = file.isDirectory() ?
            FileStatus.FileStatusType.DIRECTORY : FileStatus.FileStatusType.FILE;

        return new FileStatus(type, file.canRead(), file.canWrite(), file.canExecute());
    }
}

// 2. File Information
class FileInfo {
    private Context context;

    public FileInfo(Context context) {
        this.context = context;
    }

    // Get file size
    public Long getSize(File file) {
        return file.exists() ? file.length() : null;
    }

    // Get modification date
    public Date getModificationDate(File file) {
        return file.exists() ? new Date(file.lastModified()) : null;
    }

    // Get file extension
    public String getExtension(File file) {
        String name = file.getName();
        int dotIndex = name.lastIndexOf('.');
        return dotIndex > 0 ? name.substring(dotIndex + 1) : "";
    }

    // Get file name without extension
    public String getNameWithoutExtension(File file) {
        String name = file.getName();
        int dotIndex = name.lastIndexOf('.');
        return dotIndex > 0 ? name.substring(0, dotIndex) : name;
    }

    // Get MIME type
    public String getMIMEType(File file) {
        String extension = getExtension(file).toLowerCase();
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

    // Get detailed file info
    public static class DetailedFileInfo {
        public String path;
        public long size;
        public Date modificationDate;
        public boolean isHidden;
        public boolean canRead;
        public boolean canWrite;
        public boolean canExecute;

        public DetailedFileInfo(String path, long size, Date modificationDate, boolean isHidden,
                               boolean canRead, boolean canWrite, boolean canExecute) {
            this.path = path;
            this.size = size;
            this.modificationDate = modificationDate;
            this.isHidden = isHidden;
            this.canRead = canRead;
            this.canWrite = canWrite;
            this.canExecute = canExecute;
        }

        public void printInfo() {
            System.out.println("\n--- File Information ---");
            System.out.println("Path: " + path);
            System.out.println("Size: " + formatSize(size));
            if (modificationDate != null) {
                System.out.println("Modified: " + formatDate(modificationDate));
            }
            System.out.println("Hidden: " + isHidden);
            System.out.println("Readable: " + canRead);
            System.out.println("Writable: " + canWrite);
            System.out.println("Executable: " + canExecute);
        }

        private String formatSize(long bytes) {
            double kb = bytes / 1024.0;
            double mb = kb / 1024;
            double gb = mb / 1024;

            if (gb >= 1) {
                return String.format("%.2f GB", gb);
            } else if (mb >= 1) {
                return String.format("%.2f MB", mb);
            } else if (kb >= 1) {
                return String.format("%.2f KB", kb);
            } else {
                return bytes + " bytes";
            }
        }

        private String formatDate(Date date) {
            java.text.SimpleDateFormat formatter = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return formatter.format(date);
        }
    }

    public DetailedFileInfo getDetailedInfo(File file) {
        if (!file.exists()) return null;

        return new DetailedFileInfo(
            file.getAbsolutePath(),
            file.length(),
            new Date(file.lastModified()),
            file.isHidden(),
            file.canRead(),
            file.canWrite(),
            file.canExecute()
        );
    }
}

// 3. File Type Validation
class FileTypeValidator {
    private Context context;

    public FileTypeValidator(Context context) {
        this.context = context;
    }

    // Validate by extension
    public boolean isValidExtension(File file, List<String> validExtensions) {
        String extension = new FileInfo(context).getExtension(file).toLowerCase();
        return validExtensions.contains(extension);
    }

    // Validate image file
    public boolean isImageFile(File file) {
        List<String> imageExtensions = new ArrayList<>();
        imageExtensions.add("jpg");
        imageExtensions.add("jpeg");
        imageExtensions.add("png");
        imageExtensions.add("gif");
        imageExtensions.add("bmp");
        imageExtensions.add("webp");
        return isValidExtension(file, imageExtensions);
    }

    // Validate text file
    public boolean isTextFile(File file) {
        List<String> textExtensions = new ArrayList<>();
        textExtensions.add("txt");
        textExtensions.add("md");
        textExtensions.add("html");
        textExtensions.add("css");
        textExtensions.add("js");
        textExtensions.add("json");
        textExtensions.add("xml");
        textExtensions.add("csv");
        return isValidExtension(file, textExtensions);
    }

    // Check if file is empty
    public boolean isEmpty(File file) {
        return file.exists() && file.length() == 0;
    }

    // Validate file size constraints
    public boolean isSizeValid(File file, long minSize, long maxSize) {
        long size = file.length();
        return size >= minSize && size <= maxSize;
    }
}

// 4. File Comparison
class FileComparator {
    private Context context;

    public FileComparator(Context context) {
        this.context = context;
    }

    public enum ComparisonResult {
        LESS_THAN, EQUAL, GREATER_THAN
    }

    // Compare files by size
    public ComparisonResult compareSize(File file1, File file2) {
        long size1 = file1.length();
        long size2 = file2.length();

        if (size1 < size2) return ComparisonResult.LESS_THAN;
        if (size1 > size2) return ComparisonResult.GREATER_THAN;
        return ComparisonResult.EQUAL;
    }

    // Compare files by content
    public boolean compareContent(File file1, File file2) {
        try {
            byte[] content1 = readFileBytes(file1);
            byte[] content2 = readFileBytes(file2);

            if (content1.length != content2.length) {
                return false;
            }

            for (int i = 0; i < content1.length; i++) {
                if (content1[i] != content2[i]) {
                    return false;
                }
            }

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private byte[] readFileBytes(File file) throws IOException {
        FileInputStream input = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        input.read(bytes);
        input.close();
        return bytes;
    }

    // Check if files are identical (size and content)
    public boolean areIdentical(File file1, File file2) {
        return compareSize(file1, file2) == ComparisonResult.EQUAL && compareContent(file1, file2);
    }

    // Calculate file checksum (SHA256)
    public String calculateChecksum(File file) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            FileInputStream input = new FileInputStream(file);

            byte[] buffer = new byte[8192];
            int bytesRead;

            while ((bytesRead = input.read(buffer)) != -1) {
                digest.update(buffer, 0, bytesRead);
            }

            input.close();

            byte[] hash = digest.digest();
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }

            return hexString.toString();
        } catch (Exception e) {
            return null;
        }
    }

    // Compare using checksum
    public boolean compareChecksum(File file1, File file2) {
        String hash1 = calculateChecksum(file1);
        String hash2 = calculateChecksum(file2);

        return hash1 != null && hash2 != null && hash1.equals(hash2);
    }
}

// 5. Path Validation
class PathValidator {
    private Context context;

    public PathValidator(Context context) {
        this.context = context;
    }

    // Validate path format
    public boolean isValidPath(File file) {
        try {
            return file.getCanonicalPath().length() > 0;
        } catch (Exception e) {
            return false;
        }
    }

    // Validate file name
    public boolean isValidFileName(String name) {
        if (name == null || name.isEmpty()) {
            return false;
        }

        // Check for invalid characters
        String invalidChars = "/\\:*?"<>|";
        for (char c : invalidChars.toCharArray()) {
            if (name.indexOf(c) != -1) {
                return false;
            }
        }

        return true;
    }

    // Sanitize file name
    public String sanitizeFileName(String name) {
        String invalidChars = "/\\:*?"<>|";
        StringBuilder result = new StringBuilder();

        for (char c : name.toCharArray()) {
            if (invalidChars.indexOf(c) != -1) {
                result.append('_');
            } else {
                result.append(c);
            }
        }

        return result.toString();
    }
}

// 6. File Integrity Checker
class FileIntegrityChecker {
    private Context context;

    public FileIntegrityChecker(Context context) {
        this.context = context;
    }

    // Verify file hasn't been corrupted using stored hash
    public boolean verifyIntegrity(File file, String expectedHash) {
        String actualHash = new FileComparator(context).calculateChecksum(file);
        return actualHash != null && actualHash.equalsIgnoreCase(expectedHash);
    }

    // Generate hash file for integrity checking
    public String generateHashFile(File file) {
        return new FileComparator(context).calculateChecksum(file);
    }

    // Quick check (just size)
    public boolean quickCheck(File file, long expectedSize) {
        return file.exists() && file.length() == expectedSize;
    }
}

// Main demonstration
class FileValidationDemo {
    public static void demonstrateFileValidation(Context context) {
        System.out.println("=== Android Java File Validation Examples ===\n");

        File testFile = new File(context.getCacheDir(), "validation_test.txt");
        File testDir = new File(context.getCacheDir(), "validation_test_dir");

        // Create test file
        try {
            FileWriter writer = new FileWriter(testFile);
            writer.write("Test content for validation");
            writer.close();

            testDir.mkdirs();

            FileChecker checker = new FileChecker(context);

            // 1. File existence checks
            System.out.println("--- 1. File Existence Checks ---");
            System.out.println("File exists: " + checker.fileExists(testFile));
            System.out.println("Is file: " + checker.isFile(testFile));
            System.out.println("Is directory: " + checker.isDirectory(testDir));
            System.out.println("Is readable: " + checker.isReadable(testFile));
            System.out.println("Is writable: " + checker.isWritable(testFile));

            // 2. Comprehensive file check
            System.out.println("\n--- 2. Comprehensive File Check ---");
            FileChecker.FileStatus status = checker.checkFile(testFile);
            System.out.println("Status: " + status.status);
            System.out.println("Readable: " + status.isReadable);
            System.out.println("Writable: " + status.isWritable);
            System.out.println("Executable: " + status.isExecutable);

            // 3. File information
            System.out.println("\n--- 3. File Information ---");
            FileInfo fileInfo = new FileInfo(context);
            Long size = fileInfo.getSize(testFile);
            System.out.println("Size: " + size + " bytes");

            Date modDate = fileInfo.getModificationDate(testFile);
            System.out.println("Modified: " + modDate);

            System.out.println("Extension: " + fileInfo.getExtension(testFile));
            System.out.println("Name without ext: " + fileInfo.getNameWithoutExtension(testFile));

            // 4. Detailed info
            System.out.println("\n--- 4. Detailed File Info ---");
            FileInfo.DetailedFileInfo info = fileInfo.getDetailedInfo(testFile);
            if (info != null) {
                info.printInfo();
            }

            // 5. File type validation
            System.out.println("\n--- 5. File Type Validation ---");
            FileTypeValidator validator = new FileTypeValidator(context);
            System.out.println("Is text file: " + validator.isTextFile(testFile));
            System.out.println("Is image file: " + validator.isImageFile(testFile));
            System.out.println("Is empty: " + validator.isEmpty(testFile));
            System.out.println("Size valid (1-1000 bytes): " + validator.isSizeValid(testFile, 1, 1000));

            // 6. File comparison
            System.out.println("\n--- 6. File Comparison ---");
            File testFile2 = new File(context.getCacheDir(), "validation_test2.txt");
            FileWriter writer2 = new FileWriter(testFile2);
            writer2.write("Different content");
            writer2.close();

            FileComparator comparator = new FileComparator(context);
            FileComparator.ComparisonResult sizeCompare = comparator.compareSize(testFile, testFile2);
            System.out.println("Size comparison: " + sizeCompare);

            boolean contentEqual = comparator.compareContent(testFile, testFile);
            System.out.println("Content equal: " + contentEqual);

            // 7. Checksum
            System.out.println("\n--- 7. Checksum ---");
            String checksum = comparator.calculateChecksum(testFile);
            System.out.println("SHA256: " + checksum);

            FileIntegrityChecker integrityChecker = new FileIntegrityChecker(context);
            if (checksum != null) {
                boolean valid = integrityChecker.verifyIntegrity(testFile, checksum);
                System.out.println("Integrity check: " + (valid ? "PASSED" : "FAILED"));
            }

            // 8. Path validation
            System.out.println("\n--- 8. Path Validation ---");
            PathValidator pathValidator = new PathValidator(context);
            System.out.println("Is valid path: " + pathValidator.isValidPath(testFile));
            System.out.println("Valid filename 'test.txt': " + pathValidator.isValidFileName("test.txt"));
            System.out.println("Valid filename 'test?.txt': " + pathValidator.isValidFileName("test?.txt"));
            System.out.println("Sanitized name: " + pathValidator.sanitizeFileName("test?.txt"));

            // Cleanup
            testFile.delete();
            testFile2.delete();
            testDir.delete();
            System.out.println("\nCleanup completed");

        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }

        System.out.println("\n=== All File Validation Examples Completed ===");
    }
}