Java fast I/O: large inputs and outputs

Fast I/O in Java comes down to two habits for large tests. Read the input through a BufferedReader cut into tokens by a StringTokenizer, or through a small reader of your own that turns bytes into numbers, instead of a Scanner. Send the output through one PrintWriter or StringBuilder that is flushed once at the end, instead of calling System.out.println for every line, because System.out hands each line to the operating system the moment you print it. Interactive problems are the exception to the second habit: there you flush after every question, or the judge never sees it. With a few thousand numbers any of these choices is fast enough; from about 10^5 numbers on, the difference starts to show against a time limit of one or two seconds.

Where the time goes

A program spends its input and output time in four places: decoding bytes into text, cutting the text into tokens, turning tokens into numbers, and handing finished text to the operating system. The usual readers and writers differ in how much of that work they do per number:

• Scanner checks every token against regular expressions before converting it, which makes it the slowest of the readers.
• BufferedReader with StringTokenizer reads whole lines, makes a String of every token and converts it with Integer.parseInt.
• StreamTokenizer recognises numbers by itself, with no String per token, but stores every number as a double.
• A byte reader reads blocks of bytes and builds each number from its digits, with no String and no double.
• System.out.println passes each line to the operating system at once, so a million lines make a million separate writes.
• PrintWriter and StringBuilder collect the text in memory and write it out in large blocks, the last one at the flush.

The writers make the largest difference, so here it is measured. WriteBench.java prints the same million lines in one of four ways and reports, on standard error, the CPU time of the whole JVM and the time on the clock:

import java.io.PrintWriter;
import java.lang.management.ManagementFactory;

// Prints n lines, the numbers 0 to n-1 times 7, in one of four ways, and reports the cost on standard error,
// so that standard output can go to a file. Usage: java WriteBench.java println|writer|builder|printf n > out.txt
public class WriteBench {
    public static void main(String[] args) {
        String how = args[0];
        int n = Integer.parseInt(args[1]);
        var os = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
        long cpuStart = os.getProcessCpuTime();
        long start = System.nanoTime();
        switch (how) {
            case "println" -> {
                for (int i = 0; i < n; i++) System.out.println(i * 7L);
            }
            case "writer" -> {
                PrintWriter out = new PrintWriter(System.out);
                for (int i = 0; i < n; i++) out.println(i * 7L);
                out.flush();
            }
            case "builder" -> {
                StringBuilder text = new StringBuilder();
                for (int i = 0; i < n; i++) text.append(i * 7L).append('\n');
                System.out.print(text);
                System.out.flush();
            }
            case "printf" -> {
                PrintWriter out = new PrintWriter(System.out);
                for (int i = 0; i < n; i++) out.printf("%d%n", i * 7L);
                out.flush();
            }
            default -> throw new IllegalArgumentException("unknown writer: " + how);
        }
        long wallMs = (System.nanoTime() - start) / 1_000_000;
        long cpuMs = (os.getProcessCpuTime() - cpuStart) / 1_000_000;
        System.err.println(how + ": " + n + " lines, CPU " + cpuMs + " ms, wall " + wallMs + " ms");
    }
}

from session import run

# A million lines printed twice, once with System.out.println and once through a PrintWriter flushed at the end,
# each into its own file; then the two files are compared byte by byte.
run("""
javac -d classes WriteBench.java
java -cp classes WriteBench println 1000000 > println.txt
java -cp classes WriteBench writer 1000000 > writer.txt
cmp println.txt writer.txt && echo "the two files are identical"
""")

# JDK in use: openjdk version "25.0.4.1" LTS
$ javac -d classes WriteBench.java
$ java -cp classes WriteBench println 1000000 > println.txt
println: 1000000 lines, CPU 4519 ms, wall 10454 ms
$ java -cp classes WriteBench writer 1000000 > writer.txt
writer: 1000000 lines, CPU 170 ms, wall 132 ms
$ cmp println.txt writer.txt && echo "the two files are identical"
the two files are identical

The two files are identical, byte for byte, yet System.out.println needed more than 20 times the CPU time of the PrintWriter: about 4 to 5 seconds against under a fifth of a second on this track’s build machine, an Apple M5 Pro. With a one-second limit, the same algorithm would be accepted with the second program and fail with the first.

Four readers on one million numbers, measured Pro: opens with a Pro, Premium or Ultimate pass