File Handling

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file = new File("example.txt");

        if (file.exists()) {
            System.out.println("File Name: " + file.getName());
            System.out.println("Absolute Path: " + file.getAbsolutePath());
            System.out.println("Writable: " + file.canWrite());
            System.out.println("Readable: " + file.canRead());
            System.out.println("File Size in bytes: " + file.length());
        } else {
            System.out.println("The file does not exist.");
        }
    }
}

#include <iostream>
#include <filesystem>
using namespace std;
namespace fs = std::filesystem;

int main() {
    fs::path p("example.txt");

    if (fs::exists(p)) {
        cout << "File Name: " << p.filename().string() << "\n";
        cout << "Absolute Path: " << fs::absolute(p).string() << "\n";
        cout << "File Size in bytes: " << fs::file_size(p) << "\n";
    } else {
        cout << "The file does not exist.\n";
    }
    return 0;
}

from pathlib import Path

def main():
    p = Path("example.txt")

    if p.exists():
        print("File Name:", p.name)
        print("Absolute Path:", str(p.resolve()))
        print("File Size in bytes:", p.stat().st_size)
    else:
        print("The file does not exist.")

if __name__ == "__main__":
    main()

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            writer.write("Hello, world!\n");
            writer.write("This is a sample file.");
            System.out.println("File written successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    ofstream writer("output.txt");

    if (!writer.is_open()) {
        cout << "Failed to open output.txt\n";
        return 0;
    }

    writer << "Hello, world!\n";
    writer << "This is a sample file.\n";
    writer.close();

    cout << "File written successfully.\n";
    return 0;
}

def main():
    try:
        with open("output.txt", "w") as writer:
            writer.write("Hello, world!\n")
            writer.write("This is a sample file.\n")
        print("File written successfully.")
    except Exception:
        print("Failed to write the file.")

if __name__ == "__main__":
    main()

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

public class Main {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            int i = 1;
            while ((line = reader.readLine()) != null) {
                System.out.println("Line " + i + ": " + line);
                i++;
            }
        } catch (IOException e) {
            System.out.println("Error reading file.");
        }
    }
}

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
    ifstream reader("example.txt");

    if (!reader.is_open()) {
        cout << "Failed to open example.txt\n";
        return 0;
    }

    string line;
    int i = 1;
    while (getline(reader, line)) {
        cout << "Line " << i << ": " << line << "\n";
        i++;
    }
    reader.close();
    return 0;
}

def main():
    try:
        with open("example.txt", "r") as reader:
            i = 1
            for line in reader:
                print(f"Line {i}: {line.strip()}")
                i += 1
    except FileNotFoundError:
        print("The file does not exist.")

if __name__ == "__main__":
    main()

import java.io.*;

class Logger {
    private String path;

    public Logger(String path) throws IOException {
        this.path = path;
        File file = new File(path);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    public void log(String message) {
        // FileWriter with true parameter enables append mode
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(path, true))) {
            bw.write(message);
            bw.newLine();
        } catch (Exception e) {
            System.out.println("Failed to log: " + message);
        }
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Logger logger = new Logger("application.log");
        logger.log("Application started...");
        logger.log("User logged in.");
        logger.log("Application closed.");
    }
}

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class Logger {
private:
    string path;
public:
    Logger(const string& path) : path(path) {
        ofstream tmp(path, ios::app);
        tmp.close();
    }

    void log(const string& message) {
        // ios::app enables append mode
        ofstream out(path, ios::app);
        if (!out.is_open()) return;

        out << message << "\n";
        out.close();
    }
};

int main() {
    Logger logger("application.log");
    logger.log("Application started...");
    logger.log("User logged in.");
    logger.log("Application closed.");
    return 0;
}

class Logger:
    def __init__(self, path):
        self.path = path
        # Ensure file exists
        with open(self.path, "a"):
            pass

    def log(self, message):
        try:
            # Mode 'a' enables append mode
            with open(self.path, "a") as writer:
                writer.write(message + "\n")
        except Exception:
            print("Failed to log:", message)

def main():
    logger = Logger("application.log")
    logger.log("Application started...")
    logger.log("User logged in.")
    logger.log("Application closed...")

if __name__ == "__main__":
    main()