www.baeldung.com Open in urlscan Pro
2606:4700:3108::ac42:2b08  Public Scan

Form analysis
1 forms found in the DOM

POST https://www.getdrip.com/forms/49175868/submissions

<form method="post" action="https://www.getdrip.com/forms/49175868/submissions"><input type="hidden" value="https://www.getdrip.com/forms/49175868/submissions">
  <div>
    <div style="padding-top: 20px;">
      <input class="input-email" name="fields[email]" id="drip-email" type="email" placeholder="Your Email" value="" label="Email Address">
    </div>
    <div><input name="website" id="website" type="text" placeholder="website" value="" label="Website" style="display:none"></div>
    <div style="padding-top: 20px;"><button type="submit">FOLLOW THE JAVA CATEGORY</button></div>
  </div>
</form>

Text Content

WE VALUE YOUR PRIVACY

We and our partners store and/or access information on a device, such as cookies
and process personal data, such as unique identifiers and standard information
sent by a device for personalised ads and content, ad and content measurement,
and audience insights, as well as to develop and improve products. With your
permission we and our partners may use precise geolocation data and
identification through device scanning. You may click to consent to our and our
partners’ processing as described above. Alternatively you may access more
detailed information and change your preferences before consenting or to refuse
consenting. Please note that some processing of your personal data may not
require your consent, but you have a right to object to such processing. Your
preferences will apply to this website only. You can change your preferences at
any time by returning to this site or visit our privacy policy.
MORE OPTIONSAGREE

 * 
 * 
 * Start Here
 * Courses ▼▲
   
   
    * REST WITH SPRING
      
      The canonical reference for building a production grade API with Spring
   
   
    * LEARN SPRING SECURITY ▼▲
      
      THE unique Spring Security education if you’re working with Java today
      
      
       * LEARN SPRING SECURITY CORE
         
         Focus on the Core of Spring Security 5
      
      
       * LEARN SPRING SECURITY OAUTH
         
         Focus on the new OAuth2 stack in Spring Security 5
   
   
    * LEARN SPRING
      
      From no experience to actually building stuff
   
   
    * LEARN SPRING DATA JPA
      
      The full guide to persistence with Spring Data JPA

 * Guides ▼▲
   
   
    * PERSISTENCE
      
      The Persistence with Spring guides
   
   
    * REST
      
      The guides on building REST APIs with Spring
   
   
    * SECURITY
      
      The Spring Security guides

 * About ▼▲
   
   
    * FULL ARCHIVE
      
      The high level overview of all the articles on the site.
   
   
    * BAELDUNG EBOOKS
      
      Discover all of our eBooks
   
   
    * ABOUT BAELDUNG
      
      About Baeldung.

 * 
 * 




HOW TO READ A FILE IN JAVA



Last updated: March 2, 2023

Written by: baeldung
 * Java+

 * Java IO

Course – LS (cat=Java)


GET STARTED WITH SPRING 5 AND SPRING BOOT 2, THROUGH THE LEARN SPRING COURSE:


> CHECK OUT THE COURSE




1. OVERVIEW



In this tutorial, we'll explore different ways to read from a File in Java.

First, we'll learn how to load a file from the classpath, a URL, or from a JAR
file using standard Java classes.

Second, we'll see how to read the content with BufferedReader, Scanner,
StreamTokenizer, DataInputStream, SequenceInputStream, and FileChannel. We will
also discuss how to read a UTF-8 encoded file.

Finally, we’ll explore the new techniques to load and read a file in Java 7 and
Java 8.

This article is part of the “Java – Back to Basic” series on Baeldung.




FURTHER READING:


JAVA - CREATE A FILE

How to create a File in Java using JDK 6, JDK 7 with NIO or Commons IO.
Read more →


JAVA - WRITE TO FILE

The many ways to write data to File using Java.
Read more →


2. SETUP




2.1. INPUT FILE



In most examples throughout this article, we'll read a text file with filename
fileTest.txt that contains one line:

Hello, world!Copy

For a few examples, we'll use a different file; in these cases, we'll mention
the file and its contents explicitly.


2.2. HELPER METHOD



We'll use a set of test examples with core Java classes only, and in the tests,
we'll use assertions with Hamcrest matchers.

Tests will share a common readFromInputStream method that transforms an
InputStream to String for easier asserting of results:

private String readFromInputStream(InputStream inputStream)
  throws IOException {
    StringBuilder resultStringBuilder = new StringBuilder();
    try (BufferedReader br
      = new BufferedReader(new InputStreamReader(inputStream))) {
        String line;
        while ((line = br.readLine()) != null) {
            resultStringBuilder.append(line).append("\n");
        }
    }
  return resultStringBuilder.toString();
}Copy

Note that there are other ways of achieving this same result. We can consult
this article for some alternatives.




3. READING A FILE FROM THE CLASSPATH




3.1. USING STANDARD JAVA



This section explains how to read a file that is available on a classpath. We'll
read the “fileTest.txt” available under src/main/resources:

@Test
public void givenFileNameAsAbsolutePath_whenUsingClasspath_thenFileData() {
    String expectedData = "Hello, world!";
    
    Class clazz = FileOperationsTest.class;
    InputStream inputStream = clazz.getResourceAsStream("/fileTest.txt");
    String data = readFromInputStream(inputStream);

    Assert.assertThat(data, containsString(expectedData));
}Copy

In the above code snippet, we used the current class to load a file using
getResourceAsStream method and passed the absolute path of the file to load.

The same method is available on a ClassLoader instance as well:

ClassLoader classLoader = getClass().getClassLoader();
InputStream inputStream = classLoader.getResourceAsStream("fileTest.txt");
String data = readFromInputStream(inputStream);Copy

We obtain the classLoader of the current class using
getClass().getClassLoader().

The main difference is that when using the getResourceAsStream on a ClassLoader
instance, the path is treated as absolute starting from the root of the
classpath.



When used against a Class instance, the path could be relative to the package,
or an absolute path, which is hinted by the leading slash.

Of course, note that in practice, open streams should always be closed, such as
the InputStream in our example:

InputStream inputStream = null;
try {
    File file = new File(classLoader.getResource("fileTest.txt").getFile());
    inputStream = new FileInputStream(file);
    
    //...
}     
finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}Copy


3.2. USING THE COMMONS-IO LIBRARY



Another common option is using the FileUtils class of the commons-io package:

@Test
public void givenFileName_whenUsingFileUtils_thenFileData() {
    String expectedData = "Hello, world!";
        
    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource("fileTest.txt").getFile());
    String data = FileUtils.readFileToString(file, "UTF-8");
        
    assertEquals(expectedData, data.trim());
}Copy

Here we pass the File object to the method readFileToString() of FileUtils
class. This utility class manages to load the content without the necessity of
writing any boilerplate code to create an InputStream instance and read data.

The same library also offers the IOUtils class:

@Test
public void givenFileName_whenUsingIOUtils_thenFileData() {
    String expectedData = "Hello, world!";
        
    FileInputStream fis = new FileInputStream("src/test/resources/fileTest.txt");
    String data = IOUtils.toString(fis, "UTF-8");
        
    assertEquals(expectedData, data.trim());
}Copy

Here we pass the FileInputStream object to the method toString() of IOUtils
class. This utility class acts in the same way as the previous one in order to
create an InputStream instance and read data.


4. READING WITH BUFFEREDREADER



Now let's focus on different ways to parse the content of a file.

We'll start with a simple way to read from a file using BufferedReader:



@Test
public void whenReadWithBufferedReader_thenCorrect()
  throws IOException {
     String expected_value = "Hello, world!";
     String file ="src/test/resources/fileTest.txt";
     
     BufferedReader reader = new BufferedReader(new FileReader(file));
     String currentLine = reader.readLine();
     reader.close();

    assertEquals(expected_value, currentLine);
}Copy

Note that readLine() will return null when the end of the file is reached.


5. READING FROM A FILE USING JAVA NIO



In JDK7, the NIO package was significantly updated.

Let’s look at an example using the Files class and the readAllLines method. The
readAllLines method accepts a Path.

Path class can be considered an upgrade of the java.io.File with some additional
operations in place.


5.1. READING A SMALL FILE



The following code shows how to read a small file using the new Files class:

@Test
public void whenReadSmallFileJava7_thenCorrect()
  throws IOException {
    String expected_value = "Hello, world!";

    Path path = Paths.get("src/test/resources/fileTest.txt");

    String read = Files.readAllLines(path).get(0);
    assertEquals(expected_value, read);
}Copy

Note that we can use the readAllBytes() method as well if we need binary data.


5.2. READING A LARGE FILE



If we want to read a large file with Files class, we can use the BufferedReader.

The following code reads the file using the new Files class and BufferedReader:



@Test
public void whenReadLargeFileJava7_thenCorrect()
  throws IOException {
    String expected_value = "Hello, world!";

    Path path = Paths.get("src/test/resources/fileTest.txt");

    BufferedReader reader = Files.newBufferedReader(path);
    String line = reader.readLine();
    assertEquals(expected_value, line);
}Copy


5.3. READING A FILE USING FILES.LINES()



JDK8 offers the lines() method inside the Files class. It returns a Stream of
String elements.

Let’s look at an example of how to read data into bytes and decode it using
UTF-8 charset.

The following code reads the file using the new Files.lines():

@Test
public void givenFilePath_whenUsingFilesLines_thenFileData() {
    String expectedData = "Hello, world!";
         
    Path path = Paths.get(getClass().getClassLoader()
      .getResource("fileTest.txt").toURI());
         
    Stream<String> lines = Files.lines(path);
    String data = lines.collect(Collectors.joining("\n"));
    lines.close();
         
    Assert.assertEquals(expectedData, data.trim());
}Copy

Using Stream with IO channels like file operations, we need to close the stream
explicitly using the close() method.

As we can see, the Files API offers another easy way to read the file contents
into a String.

In the next sections, we'll look at other less common methods of reading a file
that may be appropriate in some situations.


6. READING WITH SCANNER



Next let's use a Scanner to read from the File. Here we'll use whitespace as the
delimiter:

@Test
public void whenReadWithScanner_thenCorrect()
  throws IOException {
    String file = "src/test/resources/fileTest.txt";
    Scanner scanner = new Scanner(new File(file));
    scanner.useDelimiter(" ");

    assertTrue(scanner.hasNext());
    assertEquals("Hello,", scanner.next());
    assertEquals("world!", scanner.next());

    scanner.close();
}Copy

Note that the default delimiter is the whitespace, but multiple delimiters can
be used with a Scanner.



The Scanner class is useful when reading content from the console, or when the
content contains primitive values, with a known delimiter (eg: a list of
integers separated by space).


7. READING WITH STREAMTOKENIZER



Now let's read a text file into tokens using a StreamTokenizer.

The tokenizer works by first figuring out what the next token is, String or
number. We do that by looking at the tokenizer.ttype field.

Then we'll read the actual token based on this type:

 * tokenizer.nval – if the type was a number
 * tokenizer.sval – if the type was a String

In this example, we'll use a different input file which simply contains:

Hello 1Copy

The following code reads from the file both the String and the number:

@Test
public void whenReadWithStreamTokenizer_thenCorrectTokens()
  throws IOException {
    String file = "src/test/resources/fileTestTokenizer.txt";
   FileReader reader = new FileReader(file);
    StreamTokenizer tokenizer = new StreamTokenizer(reader);

    // token 1
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_WORD, tokenizer.ttype);
    assertEquals("Hello", tokenizer.sval);

    // token 2    
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_NUMBER, tokenizer.ttype);
    assertEquals(1, tokenizer.nval, 0.0000001);

    // token 3
    tokenizer.nextToken();
    assertEquals(StreamTokenizer.TT_EOF, tokenizer.ttype);
    reader.close();
}Copy

Note how the end of file token is used at the end.

This approach is useful for parsing an input stream into tokens.




8. READING WITH DATAINPUTSTREAM



We can use DataInputStream to read binary or primitive data types from a file.

The following test reads the file using a DataInputStream:

@Test
public void whenReadWithDataInputStream_thenCorrect() throws IOException {
    String expectedValue = "Hello, world!";
    String file ="src/test/resources/fileTest.txt";
    String result = null;

    DataInputStream reader = new DataInputStream(new FileInputStream(file));
    int nBytesToRead = reader.available();
    if(nBytesToRead > 0) {
        byte[] bytes = new byte[nBytesToRead];
        reader.read(bytes);
        result = new String(bytes);
    }

    assertEquals(expectedValue, result);
}Copy


9. READING WITH FILECHANNEL



If we are reading a large file, FileChannel can be faster than standard IO.

The following code reads data bytes from the file using FileChannel and
RandomAccessFile:

@Test
public void whenReadWithFileChannel_thenCorrect()
  throws IOException {
    String expected_value = "Hello, world!";
    String file = "src/test/resources/fileTest.txt";
    RandomAccessFile reader = new RandomAccessFile(file, "r");
    FileChannel channel = reader.getChannel();

    int bufferSize = 1024;
    if (bufferSize > channel.size()) {
        bufferSize = (int) channel.size();
    }
    ByteBuffer buff = ByteBuffer.allocate(bufferSize);
    channel.read(buff);
    buff.flip();
    
    assertEquals(expected_value, new String(buff.array()));
    channel.close();
    reader.close();
}Copy


10. READING A UTF-8 ENCODED FILE



Now let's see how to read a UTF-8 encoded file using BufferedReader. In this
example, we'll read a file that contains Chinese characters:

@Test
public void whenReadUTFEncodedFile_thenCorrect()
  throws IOException {
    String expected_value = "青空";
    String file = "src/test/resources/fileTestUtf8.txt";
    BufferedReader reader = new BufferedReader
      (new InputStreamReader(new FileInputStream(file), "UTF-8"));
    String currentLine = reader.readLine();
    reader.close();

    assertEquals(expected_value, currentLine);
}Copy


11. READING CONTENT FROM URL



To read content from a URL, we will use “/” URL in our example:

@Test
public void givenURLName_whenUsingURL_thenFileData() {
    String expectedData = "Baeldung";

    URL urlObject = new URL("/");
    URLConnection urlConnection = urlObject.openConnection();
    InputStream inputStream = urlConnection.getInputStream();
    String data = readFromInputStream(inputStream);

    Assert.assertThat(data, containsString(expectedData));
}Copy

There are also alternative ways of connecting to a URL. Here we used the URL and
URLConnection class available in the standard SDK.


12. READING A FILE FROM A JAR



To read a file which is located inside a JAR file, we will need a JAR with a
file inside it. For our example, we will read “LICENSE.txt” from the
“hamcrest-library-1.3.jar” file:



@Test
public void givenFileName_whenUsingJarFile_thenFileData() {
    String expectedData = "BSD License";

    Class clazz = Matchers.class;
    InputStream inputStream = clazz.getResourceAsStream("/LICENSE.txt");
    String data = readFromInputStream(inputStream);

    Assert.assertThat(data, containsString(expectedData));
}Copy

Here we want to load LICENSE.txt that resides in Hamcrest library, so we will
use the Matcher's class that helps to get a resource. The same file can be
loaded using the classloader too.


13. CONCLUSION



As we can see, there are many possibilities for loading a file and reading data
from it using plain Java.

We can load a file from various locations like classpath, URL, or jar files.

Then we can use BufferedReader to read line by line, Scanner to read using
different delimiters, StreamTokenizer to read a file into tokens,
DataInputStream to read binary data and primitive data types, SequenceInput
Stream to link multiple files into one stream, FileChannel to read faster from
large files, etc.

We can find the source code for this article in the following GitHub repo.

Course – LS (cat=Java)


GET STARTED WITH SPRING 5 AND SPRING BOOT 2, THROUGH THE LEARN SPRING COURSE:

>> CHECK OUT THE COURSE
res – REST with Spring (eBook) (everywhere)
Learning to build your API
with Spring?
Download the E-book
Comments are closed on this article!

res – REST with Spring (eBook) (cat=Java)
Building a REST API with Spring 5?
Download the E-book





COURSES

 * All Courses
 * All Bulk Courses
 * All Bulk Team Courses
 * The Courses Platform

SERIES

 * Java “Back to Basics” Tutorial
 * Jackson JSON Tutorial
 * Apache HttpClient Tutorial
 * REST with Spring Tutorial
 * Spring Persistence Tutorial
 * Security with Spring
 * Spring Reactive Tutorials

ABOUT

 * About Baeldung
 * The Full Archive
 * Editors
 * Jobs
 * Our Partners
 * Partner with Baeldung

 * Terms of Service
 * Privacy Policy
 * Company Info
 * Contact



Follow the Java Category


Follow the Java category to get regular info about the new articles and
tutorials we publish here.
FOLLOW THE JAVA CATEGORY