Introduction

Reversing the lines of a file means preserving each line exactly while changing only their order. The best solution depends on your environment and file size: command-line tools are fastest for quick shell work, while a small program is better when the logic belongs inside an application.

Use a Native Command When One Exists

On many Unix-like systems, the simplest tool is tac, which prints a file from the last line to the first.

tac input.txt > output.txt

That command is ideal for logs, exports, and one-off data inspection. It preserves line content and reverses by original position, not by alphabetical sort order.

If tac is unavailable, you can still solve the problem in a portable scripting language. The important idea is to reverse the sequence of lines, not to sort them. Sorting would change the data order based on text comparison, which is a different operation entirely.

Reverse the Lines in Python

For application code or cross-platform scripting, Python is straightforward:

1from pathlib import Path
2
3source = Path("input.txt")
4target = Path("output.txt")
5
6lines = source.read_text(encoding="utf-8").splitlines(keepends=True)
7target.write_text("".join(reversed(lines)), encoding="utf-8")

splitlines(keepends=True) is doing an important job here. It preserves newline characters, so the output keeps the same line endings instead of collapsing everything into one long string.

If you want to overwrite the original file in place, write to a temporary file first and replace the original only after the write succeeds. That avoids corrupting the source file if the process fails halfway through.

A Java Version for Existing JVM Code

If the task belongs inside a Java application, you can read the lines into a list, reverse it, and write them back out.

1import java.io.IOException;
2import java.nio.file.Files;
3import java.nio.file.Path;
4import java.util.Collections;
5import java.util.List;
6
7public class ReverseLines {
8    public static void main(String[] args) throws IOException {
9        Path input = Path.of("input.txt");
10        Path output = Path.of("output.txt");
11
12        List<String> lines = Files.readAllLines(input);
13        Collections.reverse(lines);
14        Files.write(output, lines);
15    }
16}

This approach is readable and perfectly reasonable for small or medium files. The tradeoff is memory use: it reads the entire file into memory at once.

Consider File Size Before Choosing an Approach

Many examples online assume the file is small enough to fit comfortably in memory. That is fine for configuration files or ordinary reports, but it becomes risky for very large logs or dumps.

For big files, a purpose-built tool is often preferable because it can use optimized buffering. If you do need to implement your own large-file reversal, the problem becomes more involved because you have to scan the file in chunks from the end while reconstructing lines correctly.

In practice, that complexity is usually unnecessary unless reversing huge files is part of a production workflow. For day-to-day work, choose the simplest correct option first.

Common Pitfalls

• Sorting lines instead of reversing their original order.
• Forgetting to preserve newline characters when rebuilding the output.
• Overwriting the source file directly without a safe temporary file.
• Reading a very large file fully into memory without checking size.
• Assuming every platform has tac installed.

Summary

• Use tac for the fastest shell-based solution when it is available.
• In Python or Java, reverse the line sequence rather than sorting it.
• Preserve newline characters so the output structure stays intact.
• Prefer a temporary output file when replacing the original.
• Check file size before using an in-memory approach.