How to Read a File in Java, with Examples

In Java 11 and later, the simplest way to read a text file is Files.readString(Path.of("notes.txt")), which gives you the whole file as one String, or Files.readAllLines(Path.of("notes.txt")), which gives you a List<String> with one element per line. Every example on this page runs right here on a small sample file, so you can press Run and step through it. After the short way come the classic ways, BufferedReader and Scanner, then what to do when the file is missing and a table of which way to use.

Buy milk
Walk the dog
Call Maya

Path.of turns the file name into a Path, Java's object for where a file is, and Files is a class of static methods that work on paths. readString keeps the line breaks inside the text, so System.out.print, with no ln, still prints three lines. readAllLines cuts the text at the line breaks and leaves them out, so lines prints as [Buy milk, Walk the dog, Call Maya]. Both methods open the file, read all of it and close it again before they return.

The throws IOException on main is there because reading a file can fail; the section on a missing file explains it. readString arrived in Java 11. On Java 8, new String(Files.readAllBytes(path), StandardCharsets.UTF_8) does the same job.

Read a file line by line with BufferedReader#

A BufferedReader reads a file one line at a time, so only a small part of the file is in memory at once, however big the file is. It is the classic way to read a text file and works on every Java version. You build it around a FileReader, the object that opens the file:

Buy milk
Walk the dog
Call Maya

Each call to readLine() returns the next line without its line break, and returns null once the file has no lines left. The condition (line = reader.readLine()) != null reads a line, stores it in line and checks it in one go, so the loop body runs once per line and the loop stops at the end of the file. Step through it and watch line take each value, then null.

The reader is declared in the parentheses after try. That form is called try-with-resources, and it closes the file when the block ends, even if an exception ends it early. Files.newBufferedReader(Path.of("notes.txt")) gives you the same kind of reader from a Path.

Every call to readLine() moves on to the next line, and that makes one mistake very common. Decide what this loop prints before you run it:

It prints Walk the dog and then null. The condition reads Buy milk and throws it away, and the body prints the line after it. On the second pass the condition uses up Call Maya, so the body finds the end of the file and prints null. Read each line once, into a variable, as the loop above does.

Line by line as a stream: Files.lines#

Files.lines(path) also reads one line at a time, and hands the lines over as a Stream<String>, a sequence you can filter and count with stream methods. This program prints the lines of a server log that start with ERROR:

INFO  server started
INFO  user ada logged in
ERROR disk almost full
INFO  user ada logged out
ERROR disk full

It prints ERROR disk almost full and ERROR disk full. Unlike readAllLines, Files.lines keeps the file open while you work through the stream and leaves closing it to you, so open it in try-with-resources, as here. Streams explains filter and forEach.

Read a file using Scanner#

A Scanner, the class many people first use for keyboard input, reads files too: give it a File in place of System.in. hasNextLine() asks whether another line is waiting, and nextLine() reads it:

Buy milk
Walk the dog
Call Maya

It prints the three notes in capital letters. A Scanner on a file holds the file open like a reader, so it goes in try-with-resources too, and new Scanner(new File(...)) throws a FileNotFoundException when the file is missing. Where a Scanner saves the most work is a file of numbers, which the next section reads.

Turn each line into fields and numbers#

A line read from a file is always a String, even when it holds a number. To use its parts, cut it with split and convert the pieces. Each line of scores.csv holds a name and a score with a comma between them:

Ada,91
Grace,88
Alan,79

For the line Ada,91, split(",") gives the array ["Ada", "91"], and Integer.parseInt turns the text "91" into the number 91. Step through it and watch parts in the memory view on each pass. The scores add up to 258, and the cast to double keeps the fraction, so the last line is Average: 86.0.

A Scanner can do the converting for you. nextInt() reads the next whole number, skipping any spaces and line breaks in front of it, and hasNextInt() checks that one is coming:

12 7 30
5 18

It prints 5 numbers, total 72. The numbers sit on two lines, and nextInt() does not mind, because a Scanner splits its input at any whitespace.

Where does Java look for the file?#

A name with no folder in it, like notes.txt, is a relative path. Java looks for it in the working directory, the folder the program was started from. Run java Main.javain a terminal and that is the folder you are in. In IntelliJ IDEA and VS Code it is the project's top folder by default, so the file goes there, next to src, not inside it.

When Java cannot find a file you can see, ask it where it is looking. toAbsolutePath() puts the working directory in front of the name. Run this one on your own computer, since its answer depends on where you start it:

Started in the folder /Users/ada/hello on a Mac, it prints /Users/ada/hello/notes.txt. On Windows, started in C:\Users\ada\hello, it prints C:\Users\ada\hello\notes.txt. That is the exact place Java tried.

For a file inside a folder, give Path.ofeach part. It joins them with your system's separator, / on macOS and Linux and \ on Windows, so the same code works on both:

Buy milk
Walk the dog
Call Maya

Here the first line is Reading data/notes.txt; on Windows it shows data\notes.txt. An absolute path, such as /Users/ada/notes.txt, starts from the top of the disk and works from any working directory, but only on a computer that has that exact folder.

What happens if the file does not exist?#

Reading a missing file throws an exception, and which one depends on how you read. The Files methods throw NoSuchFileException. FileReader and a Scanner over a File throw FileNotFoundException. Both are kinds of IOException, so a catch (IOException e) block handles either. This program asks for notez.txt, a typo, three ways, and prints each exception it catches:

Buy milk
Walk the dog
Call Maya

Printing an exception shows its full class name and its message. The part in brackets comes from the operating system, so on Windows it reads (The system cannot find the file specified). A real program would print a friendly sentence in the catch block, or ask for another name, and carry on. Without a catch, the exception stops the program. With throws IOException on main instead, the readString line would end it with Exception in thread "main" java.nio.file.NoSuchFileException: notez.txt and a stack trace.

Files.exists(path)tells you whether the file is there before you read it, which suits a choice such as “create the settings file on the first run”. Keep the catch as well: the file can disappear between the check and the read.

Do you need to close the file?#

Only when you hold an open reader. Creating a FileReader, a Scanner over a file or the stream from Files.lines opens the file, and it stays open until you close it, using up one of the limited number of files the operating system lets a program have open. readString, readAllLines and the other one-call Files methods open and close the file inside the call, so they leave nothing to close.

Key idea

Open every reader, Scanner and Files.lines stream in the parentheses of a try, and Java closes it when the block ends, however the block ends.

A close() call at the bottom of the method works too, until an exception skips it. Reading files builds the reader, the loop and the closing up step by step.

Character encoding: reading UTF-8#

A file stores bytes, and a character encoding is the rule that turns those bytes into letters. The Files methods read UTF-8 unless you pass another encoding. Since Java 18 (JEP 400), UTF-8 is also the default for FileReader and Scanneron every operating system. Before that they used the computer's own default, which on many Windows machines was not UTF-8, so older code names the encoding: new FileReader("notes.txt", StandardCharsets.UTF_8), a constructor added in Java 11.

A file saved in another encoding needs that encoding passed in, such as Files.readString(path, Charset.forName("windows-1252")). With the wrong encoding the ways fail differently: readString and readAllLines throw a MalformedInputException, FileReader puts the replacement character � in place of each character it cannot decode, and a Scanner stops as if the file had ended, without an error (its ioException() method returns the problem).

Which way should you use?#

For most files, start with Files.readAllLines: it is one line of code and leaves nothing to close. Switch to BufferedReader or Files.lines when a file is too big to load at once, and to Scanner when the file is mostly numbers. Path and Files covers the Files methods in depth. To save your results to disk, see how to write to a file in Java.