Read Multiple Integers in One Line Java
Reading files in Java is the crusade for a lot of confusion. There are multiple ways of accomplishing the same task and information technology'south frequently not articulate which file reading method is best to apply. Something that'south quick and dirty for a pocket-size example file might non exist the best method to employ when you need to read a very large file. Something that worked in an before Java version, might not be the preferred method anymore.
This article aims to be the definitive guide for reading files in Java vii, 8 and 9. I'm going to comprehend all the ways you lot can read files in Java. Too often, you'll read an article that tells you one manner to read a file, only to discover subsequently there are other ways to do that. I'm actually going to cover 15 dissimilar ways to read a file in Coffee. I'g going to cover reading files in multiple ways with the core Java libraries besides as two third political party libraries.
Only that's not all – what good is knowing how to do something in multiple ways if you don't know which mode is best for your state of affairs?
I likewise put each of these methods to a real performance test and document the results. That way, you lot will have some hard data to know the performance metrics of each method.
Methodology
JDK Versions
Coffee code samples don't live in isolation, especially when information technology comes to Java I/O, every bit the API keeps evolving. All code for this article has been tested on:
- Coffee SE seven (jdk1.7.0_80)
- Java SE viii (jdk1.8.0_162)
- Java SE ix (jdk-9.0.4)
When at that place is an incompatibility, information technology will be stated in that section. Otherwise, the lawmaking works unaltered for different Java versions. The principal incompatibility is the use of lambda expressions which was introduced in Coffee 8.
Coffee File Reading Libraries
There are multiple means of reading from files in Java. This commodity aims to be a comprehensive drove of all the different methods. I will comprehend:
- java.io.FileReader.read()
- java.io.BufferedReader.readLine()
- coffee.io.FileInputStream.read()
- coffee.io.BufferedInputStream.read()
- java.nio.file.Files.readAllBytes()
- java.nio.file.Files.readAllLines()
- coffee.nio.file.Files.lines()
- java.util.Scanner.nextLine()
- org.apache.commons.io.FileUtils.readLines() – Apache Commons
- com.google.mutual.io.Files.readLines() – Google Guava
Closing File Resources
Prior to JDK7, when opening a file in Java, all file resources would demand to be manually closed using a try-take hold of-finally block. JDK7 introduced the effort-with-resource statement, which simplifies the procedure of endmost streams. You no longer need to write explicit code to close streams because the JVM will automatically close the stream for you, whether an exception occurred or not. All examples used in this article use the endeavor-with-resources statement for importing, loading, parsing and closing files.
File Location
All examples will read test files from C:\temp.
Encoding
Grapheme encoding is non explicitly saved with text files so Java makes assumptions most the encoding when reading files. Usually, the assumption is right but sometimes you desire to be explicit when instructing your programs to read from files. When encoding isn't correct, you'll see funny characters announced when reading files.
All examples for reading text files employ two encoding variations:
Default system encoding where no encoding is specified and explicitly setting the encoding to UTF-8.
Download Code
All code files are available from Github.
Code Quality and Lawmaking Encapsulation
There is a difference betwixt writing lawmaking for your personal or work project and writing code to explain and teach concepts.
If I was writing this lawmaking for my ain project, I would use proper object-oriented principles like encapsulation, brainchild, polymorphism, etc. But I wanted to brand each example stand solitary and hands understood, which meant that some of the code has been copied from one instance to the next. I did this on purpose considering I didn't want the reader to accept to figure out all the encapsulation and object structures I and so cleverly created. That would have away from the examples.
For the same reason, I chose NOT to write these example with a unit of measurement testing framework like JUnit or TestNG because that's not the purpose of this article. That would add another library for the reader to empathise that has nil to exercise with reading files in Java. That's why all the instance are written inline inside the main method, without extra methods or classes.
My principal purpose is to make the examples as easy to empathize as possible and I believe that having extra unit testing and encapsulation code will not help with this. That doesn't mean that's how I would encourage you to write your ain personal code. Information technology's just the way I chose to write the examples in this commodity to make them easier to understand.
Exception Handling
All examples declare any checked exceptions in the throwing method proclamation.
The purpose of this commodity is to show all the different means to read from files in Java – information technology's not meant to evidence how to handle exceptions, which will be very specific to your situation.
So instead of creating unhelpful try catch blocks that just print exception stack traces and clutter upwards the code, all instance will declare any checked exception in the calling method. This will brand the code cleaner and easier to understand without sacrificing whatsoever functionality.
Time to come Updates
As Java file reading evolves, I will be updating this article with whatever required changes.
File Reading Methods
I organized the file reading methods into three groups:
- Archetype I/O classes that have been part of Java since before JDK 1.7. This includes the coffee.io and java.util packages.
- New Java I/O classes that have been part of Java since JDK1.7. This covers the java.nio.file.Files form.
- Third party I/O classes from the Apache Commons and Google Guava projects.
Classic I/O – Reading Text
1a) FileReader – Default Encoding
FileReader reads in one character at a time, without any buffering. Information technology's meant for reading text files. It uses the default character encoding on your organization, so I have provided examples for both the default instance, as well as specifying the encoding explicitly.
1
2
3
4
five
vi
seven
8
9
ten
11
12
13
14
15
16
17
18
19
import coffee.io.FileReader ;
import java.io.IOException ;public class ReadFile_FileReader_Read {
public static void main( Cord [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;try ( FileReader fileReader = new FileReader (fileName) ) {
int singleCharInt;
char singleChar;
while ( (singleCharInt = fileReader.read ( ) ) != - 1 ) {
singleChar = ( char ) singleCharInt;//display i character at a fourth dimension
Organization.out.impress (singleChar) ;
}
}
}
}
1b) FileReader – Explicit Encoding (InputStreamReader)
Information technology's actually not possible to set the encoding explicitly on a FileReader so you take to use the parent class, InputStreamReader and wrap it around a FileInputStream:
ane
2
3
4
5
vi
seven
viii
9
ten
11
12
13
14
15
16
17
eighteen
nineteen
20
21
22
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;public class ReadFile_FileReader_Read_Encoding {
public static void chief( String [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
FileInputStream fileInputStream = new FileInputStream (fileName) ;//specify UTF-8 encoding explicitly
try ( InputStreamReader inputStreamReader =
new InputStreamReader (fileInputStream, "UTF-8" ) ) {int singleCharInt;
char singleChar;
while ( (singleCharInt = inputStreamReader.read ( ) ) != - 1 ) {
singleChar = ( char ) singleCharInt;
System.out.print (singleChar) ; //display i character at a fourth dimension
}
}
}
}
2a) BufferedReader – Default Encoding
BufferedReader reads an entire line at a fourth dimension, instead of one character at a time like FileReader. It's meant for reading text files.
one
2
iii
iv
five
6
7
viii
9
10
11
12
13
14
xv
sixteen
17
import java.io.BufferedReader ;
import java.io.FileReader ;
import coffee.io.IOException ;public class ReadFile_BufferedReader_ReadLine {
public static void principal( String [ ] args) throws IOException {
Cord fileName = "c:\\temp\\sample-10KB.txt" ;
FileReader fileReader = new FileReader (fileName) ;attempt ( BufferedReader bufferedReader = new BufferedReader (fileReader) ) {
String line;
while ( (line = bufferedReader.readLine ( ) ) != null ) {
System.out.println (line) ;
}
}
}
}
2b) BufferedReader – Explicit Encoding
In a similar way to how we set encoding explicitly for FileReader, we need to create FileInputStream, wrap it inside InputStreamReader with an explicit encoding and pass that to BufferedReader:
1
2
three
iv
5
6
vii
8
9
10
xi
12
13
14
fifteen
sixteen
17
18
nineteen
twenty
21
22
import java.io.BufferedReader ;
import java.io.FileInputStream ;
import java.io.IOException ;
import java.io.InputStreamReader ;public grade ReadFile_BufferedReader_ReadLine_Encoding {
public static void main( String [ ] args) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;FileInputStream fileInputStream = new FileInputStream (fileName) ;
//specify UTF-8 encoding explicitly
InputStreamReader inputStreamReader = new InputStreamReader (fileInputStream, "UTF-8" ) ;attempt ( BufferedReader bufferedReader = new BufferedReader (inputStreamReader) ) {
String line;
while ( (line = bufferedReader.readLine ( ) ) != null ) {
System.out.println (line) ;
}
}
}
}
Classic I/O – Reading Bytes
one) FileInputStream
FileInputStream reads in 1 byte at a time, without any buffering. While it's meant for reading binary files such as images or audio files, it can notwithstanding be used to read text file. Information technology's similar to reading with FileReader in that you're reading ane character at a time as an integer and yous demand to cast that int to a char to encounter the ASCII value.
Past default, it uses the default character encoding on your system, then I accept provided examples for both the default case, as well as specifying the encoding explicitly.
one
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sixteen
17
18
19
twenty
21
import coffee.io.File ;
import coffee.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.IOException ;public course ReadFile_FileInputStream_Read {
public static void primary( String [ ] pArgs) throws FileNotFoundException, IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;endeavour ( FileInputStream fileInputStream = new FileInputStream (file) ) {
int singleCharInt;
char singleChar;while ( (singleCharInt = fileInputStream.read ( ) ) != - i ) {
singleChar = ( char ) singleCharInt;
Arrangement.out.print (singleChar) ;
}
}
}
}
2) BufferedInputStream
BufferedInputStream reads a set of bytes all at once into an internal byte assortment buffer. The buffer size can be set explicitly or use the default, which is what we'll demonstrate in our case. The default buffer size appears to exist 8KB just I take non explicitly verified this. All performance tests used the default buffer size so it will automatically re-size the buffer when it needs to.
1
ii
3
4
five
6
vii
8
9
10
xi
12
13
14
15
xvi
17
eighteen
19
twenty
21
22
import java.io.BufferedInputStream ;
import java.io.File ;
import java.io.FileInputStream ;
import java.io.FileNotFoundException ;
import java.io.IOException ;public class ReadFile_BufferedInputStream_Read {
public static void main( String [ ] pArgs) throws FileNotFoundException, IOException {
Cord fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;
FileInputStream fileInputStream = new FileInputStream (file) ;try ( BufferedInputStream bufferedInputStream = new BufferedInputStream (fileInputStream) ) {
int singleCharInt;
char singleChar;
while ( (singleCharInt = bufferedInputStream.read ( ) ) != - ane ) {
singleChar = ( char ) singleCharInt;
System.out.print (singleChar) ;
}
}
}
}
New I/O – Reading Text
1a) Files.readAllLines() – Default Encoding
The Files course is part of the new Java I/O classes introduced in jdk1.7. It simply has static utility methods for working with files and directories.
The readAllLines() method that uses the default grapheme encoding was introduced in jdk1.8 so this example will not piece of work in Java 7.
one
ii
three
4
5
6
7
viii
9
10
11
12
13
fourteen
fifteen
sixteen
17
import coffee.io.File ;
import java.io.IOException ;
import java.nio.file.Files ;
import java.util.Listing ;public class ReadFile_Files_ReadAllLines {
public static void main( Cord [ ] pArgs) throws IOException {
Cord fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;List fileLinesList = Files.readAllLines (file.toPath ( ) ) ;
for ( Cord line : fileLinesList) {
System.out.println (line) ;
}
}
}
1b) Files.readAllLines() – Explicit Encoding
ane
two
3
4
five
6
seven
8
nine
ten
11
12
xiii
14
15
16
17
18
19
import java.io.File ;
import java.io.IOException ;
import java.nio.charset.StandardCharsets ;
import java.nio.file.Files ;
import java.util.List ;public class ReadFile_Files_ReadAllLines_Encoding {
public static void main( Cord [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;//use UTF-8 encoding
Listing fileLinesList = Files.readAllLines (file.toPath ( ), StandardCharsets.UTF_8 ) ;for ( String line : fileLinesList) {
Organization.out.println (line) ;
}
}
}
2a) Files.lines() – Default Encoding
This code was tested to work in Coffee 8 and 9. Java 7 didn't run because of the lack of support for lambda expressions.
1
two
3
4
5
6
seven
viii
9
10
11
12
thirteen
fourteen
15
16
17
import java.io.File ;
import java.io.IOException ;
import java.nio.file.Files ;
import java.util.stream.Stream ;public grade ReadFile_Files_Lines {
public static void chief( Cord [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;try (Stream linesStream = Files.lines (file.toPath ( ) ) ) {
linesStream.forEach (line -> {
System.out.println (line) ;
} ) ;
}
}
}
2b) Files.lines() – Explicit Encoding
But like in the previous case, this code was tested and works in Java viii and 9 but non in Java 7.
i
2
iii
4
v
6
7
8
9
ten
11
12
thirteen
14
15
16
17
18
import java.io.File ;
import java.io.IOException ;
import java.nio.charset.StandardCharsets ;
import java.nio.file.Files ;
import coffee.util.stream.Stream ;public course ReadFile_Files_Lines_Encoding {
public static void main( String [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;try (Stream linesStream = Files.lines (file.toPath ( ), StandardCharsets.UTF_8 ) ) {
linesStream.forEach (line -> {
Arrangement.out.println (line) ;
} ) ;
}
}
}
3a) Scanner – Default Encoding
The Scanner class was introduced in jdk1.7 and tin can be used to read from files or from the console (user input).
i
2
three
4
5
six
seven
8
9
10
11
12
13
14
15
xvi
17
18
19
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;public class ReadFile_Scanner_NextLine {
public static void main( String [ ] pArgs) throws FileNotFoundException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;attempt (Scanner scanner = new Scanner(file) ) {
String line;
boolean hasNextLine = false ;
while (hasNextLine = scanner.hasNextLine ( ) ) {
line = scanner.nextLine ( ) ;
Organisation.out.println (line) ;
}
}
}
}
3b) Scanner – Explicit Encoding
1
2
3
four
v
half dozen
vii
8
9
10
11
12
13
14
xv
16
17
xviii
19
twenty
import java.io.File ;
import java.io.FileNotFoundException ;
import java.util.Scanner ;public class ReadFile_Scanner_NextLine_Encoding {
public static void principal( String [ ] pArgs) throws FileNotFoundException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;//use UTF-8 encoding
try (Scanner scanner = new Scanner(file, "UTF-8" ) ) {
Cord line;
boolean hasNextLine = simulated ;
while (hasNextLine = scanner.hasNextLine ( ) ) {
line = scanner.nextLine ( ) ;
Organisation.out.println (line) ;
}
}
}
}
New I/O – Reading Bytes
Files.readAllBytes()
Even though the documentation for this method states that "it is not intended for reading in large files" I found this to exist the absolute best performing file reading method, even on files as large as 1GB.
ane
2
3
4
5
6
vii
8
9
x
11
12
13
14
xv
xvi
17
import coffee.io.File ;
import java.io.IOException ;
import coffee.nio.file.Files ;public class ReadFile_Files_ReadAllBytes {
public static void main( Cord [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;byte [ ] fileBytes = Files.readAllBytes (file.toPath ( ) ) ;
char singleChar;
for ( byte b : fileBytes) {
singleChar = ( char ) b;
Organization.out.print (singleChar) ;
}
}
}
3rd Political party I/O – Reading Text
Commons – FileUtils.readLines()
Apache Commons IO is an open source Coffee library that comes with utility classes for reading and writing text and binary files. I listed it in this commodity because it tin be used instead of the built in Java libraries. The class we're using is FileUtils.
For this article, version 2.6 was used which is compatible with JDK 1.seven+
Annotation that you lot need to explicitly specify the encoding and that method for using the default encoding has been deprecated.
1
2
iii
4
5
half-dozen
7
8
9
10
xi
12
13
fourteen
15
sixteen
17
18
import java.io.File ;
import java.io.IOException ;
import coffee.util.List ;import org.apache.commons.io.FileUtils ;
public form ReadFile_Commons_FileUtils_ReadLines {
public static void primary( String [ ] pArgs) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;List fileLinesList = FileUtils.readLines (file, "UTF-8" ) ;
for ( Cord line : fileLinesList) {
System.out.println (line) ;
}
}
}
Guava – Files.readLines()
Google Guava is an open up source library that comes with utility classes for common tasks like collections handling, enshroud management, IO operations, string processing.
I listed it in this article because it can be used instead of the built in Java libraries and I wanted to compare its performance with the Coffee congenital in libraries.
For this article, version 23.0 was used.
I'm not going to examine all the different means to read files with Guava, since this article is not meant for that. For a more detailed expect at all the different ways to read and write files with Guava, have a expect at Baeldung's in depth article.
When reading a file, Guava requires that the grapheme encoding be set explicitly, just like Apache Commons.
Compatibility annotation: This code was tested successfully on Java 8 and 9. I couldn't get it to work on Coffee vii and kept getting "Unsupported major.minor version 52.0" fault. Guava has a separate API doc for Java vii which uses a slightly dissimilar version of the Files.readLine() method. I thought I could become it to work simply I kept getting that error.
1
2
3
4
5
half dozen
7
8
9
x
11
12
13
14
15
xvi
17
18
19
import java.io.File ;
import java.io.IOException ;
import java.util.List ;import com.google.common.base.Charsets ;
import com.google.common.io.Files ;public class ReadFile_Guava_Files_ReadLines {
public static void main( String [ ] args) throws IOException {
String fileName = "c:\\temp\\sample-10KB.txt" ;
File file = new File (fileName) ;List fileLinesList = Files.readLines (file, Charsets.UTF_8 ) ;
for ( Cord line : fileLinesList) {
System.out.println (line) ;
}
}
}
Operation Testing
Since there are and then many ways to read from a file in Coffee, a natural question is "What file reading method is the best for my state of affairs?" So I decided to exam each of these methods against each other using sample data files of different sizes and timing the results.
Each lawmaking sample from this article displays the contents of the file to a string and and then to the console (Organization.out). However, during the performance tests the System.out line was commented out since information technology would seriously slow down the performance of each method.
Each performance test measures the fourth dimension it takes to read in the file – line past line, character by grapheme, or byte past byte without displaying anything to the panel. I ran each test 5-10 times and took the boilerplate so every bit non to permit whatever outliers influence each test. I besides ran the default encoding version of each file reading method – i.e. I didn't specify the encoding explicitly.
Dev Setup
The dev environment used for these tests:
- Intel Core i7-3615 QM @two.3 GHz, 8GB RAM
- Windows 8 x64
- Eclipse IDE for Java Developers, Oxygen.2 Release (four.7.2)
- Coffee SE 9 (jdk-9.0.four)
Data Files
GitHub doesn't permit pushing files larger than 100 MB, and so I couldn't notice a practical manner to shop my large test files to allow others to replicate my tests. And so instead of storing them, I'm providing the tools I used to generate them and then you tin create test files that are similar in size to mine. Obviously they won't be the same, but you lot'll generate files that are similar in size as I used in my functioning tests.
Random String Generator was used to generate sample text and and so I merely re-create-pasted to create larger versions of the file. When the file started getting as well big to manage inside a text editor, I had to apply the command line to merge multiple text files into a larger text file:
copy *.txt sample-1GB.txt
I created the following 7 data file sizes to exam each file reading method beyond a range of file sizes:
- 1KB
- 10KB
- 100KB
- 1MB
- 10MB
- 100MB
- 1GB
Functioning Summary
In that location were some surprises and some expected results from the performance tests.
As expected, the worst performers were the methods that read in a file character by character or byte past byte. Only what surprised me was that the native Coffee IO libraries outperformed both third party libraries – Apache Eatables IO and Google Guava.
What's more – both Google Guava and Apache Commons IO threw a coffee.lang.OutOfMemoryError when trying to read in the 1 GB test file. This also happened with the Files.readAllLines(Path) method but the remaining 7 methods were able to read in all test files, including the 1GB examination file.
The following table summarizes the average fourth dimension (in milliseconds) each file reading method took to complete. I highlighted the top three methods in dark-green, the boilerplate performing methods in yellowish and the worst performing methods in red:
The following nautical chart summarizes the to a higher place table but with the following changes:
I removed coffee.io.FileInputStream.read() from the chart because its performance was then bad information technology would skew the unabridged chart and you lot wouldn't see the other lines properly
I summarized the data from 1KB to 1MB because after that, the chart would become also skewed with so many under performers and also some methods threw a java.lang.OutOfMemoryError at 1GB
The Winners
The new Java I/O libraries (coffee.nio) had the best overall winner (java.nio.Files.readAllBytes()) but information technology was followed closely behind by BufferedReader.readLine() which was also a proven top performer beyond the board. The other excellent performer was java.nio.Files.lines(Path) which had slightly worse numbers for smaller test files merely really excelled with the larger examination files.
The absolute fastest file reader beyond all data tests was java.nio.Files.readAllBytes(Path). It was consistently the fastest and even reading a 1GB file just took about 1 second.
The post-obit chart compares operation for a 100KB test file:
Y'all can see that the everyman times were for Files.readAllBytes(), BufferedInputStream.read() and BufferedReader.readLine().
The following nautical chart compares performance for reading a 10MB file. I didn't bother including the bar for FileInputStream.Read() because the performance was so bad it would skew the entire nautical chart and yous couldn't tell how the other methods performed relative to each other:
Files.readAllBytes() really outperforms all other methods and BufferedReader.readLine() is a distant second.
The Losers
Equally expected, the absolute worst performer was java.io.FileInputStream.read() which was orders of magnitude slower than its rivals for most tests. FileReader.read() was too a poor performer for the same reason – reading files byte by byte (or character by character) instead of with buffers drastically degrades functioning.
Both the Apache Commons IO FileUtils.readLines() and Guava Files.readLines() crashed with an OutOfMemoryError when trying to read the 1GB test file and they were nearly average in operation for the remaining examination files.
coffee.nio.Files.readAllLines() as well crashed when trying to read the 1GB test file but it performed quite well for smaller file sizes.
Operation Rankings
Here's a ranked listing of how well each file reading method did, in terms of speed and handling of large files, as well as compatibility with dissimilar Java versions.
| Rank | File Reading Method |
|---|---|
| 1 | coffee.nio.file.Files.readAllBytes() |
| 2 | coffee.io.BufferedFileReader.readLine() |
| 3 | java.nio.file.Files.lines() |
| four | java.io.BufferedInputStream.read() |
| five | java.util.Scanner.nextLine() |
| 6 | java.nio.file.Files.readAllLines() |
| 7 | org.apache.commons.io.FileUtils.readLines() |
| viii | com.google.mutual.io.Files.readLines() |
| ix | java.io.FileReader.read() |
| ten | java.io.FileInputStream.Read() |
Determination
I tried to present a comprehensive set of methods for reading files in Coffee, both text and binary. Nosotros looked at 15 different ways of reading files in Java and nosotros ran performance tests to see which methods are the fastest.
The new Coffee IO library (java.nio) proved to be a bang-up performer but so was the archetype BufferedReader.
Source: https://funnelgarden.com/java_read_file/
Post a Comment for "Read Multiple Integers in One Line Java"