Java Only Reading First Line of File

This page discusses the details of reading, writing, creating, and opening files. There are a broad array of file I/O methods to choose from. To aid make sense of the API, the following diagram arranges the file I/O methods by complication.

File I/O Methods Arranged from Less Circuitous to More Circuitous

On the far left of the diagram are the utility methods readAllBytes, readAllLines, and the write methods, designed for simple, mutual cases. To the right of those are the methods used to iterate over a stream or lines of text, such equally newBufferedReader, newBufferedWriter, and so newInputStream and newOutputStream. These methods are interoperable with the java.io parcel. To the right of those are the methods for dealing with ByteChannels, SeekableByteChannels, and ByteBuffers, such equally the newByteChannel method. Finally, on the far right are the methods that use FileChannel for advanced applications needing file locking or retentiveness-mapped I/O.

---

Notation: The methods for creating a new file enable y'all to specify an optional set of initial attributes for the file. For example, on a file arrangement that supports the POSIX set of standards (such equally UNIX), you can specify a file owner, group owner, or file permissions at the time the file is created. The Managing Metadata folio explains file attributes, and how to access and set them.

---

This page has the following topics:

• The OpenOptions Parameter
• Commonly Used Methods for Modest Files
• Buffered I/O Methods for Text Files
• Methods for Unbuffered Streams and Interoperable with java.io APIs
• Methods for Channels and ByteBuffers
• Methods for Creating Regular and Temporary Files

---

The OpenOptions Parameter

Several of the methods in this section take an optional OpenOptions parameter. This parameter is optional and the API tells you what the default beliefs is for the method when none is specified.

The post-obit StandardOpenOptions enums are supported:

• WRITE – Opens the file for write admission.
• APPEND – Appends the new information to the end of the file. This option is used with the WRITE or CREATE options.
• TRUNCATE_EXISTING – Truncates the file to cipher bytes. This option is used with the WRITE choice.
• CREATE_NEW – Creates a new file and throws an exception if the file already exists.
• CREATE – Opens the file if it exists or creates a new file if information technology does not.
• DELETE_ON_CLOSE – Deletes the file when the stream is airtight. This option is useful for temporary files.
• SPARSE – Hints that a newly created file will be thin. This advanced selection is honored on some file systems, such as NTFS, where large files with data "gaps" can be stored in a more than efficient fashion where those empty gaps exercise not eat disk infinite.
• SYNC – Keeps the file (both content and metadata) synchronized with the underlying storage device.
• DSYNC – Keeps the file content synchronized with the underlying storage device.

---

Commonly Used Methods for Small Files

Reading All Bytes or Lines from a File

If you take a small-ish file and yous would like to read its entire contents in one pass, you can employ the readAllBytes(Path) or readAllLines(Path, Charset) method. These methods accept care of most of the work for yous, such as opening and closing the stream, simply are not intended for handling large files. The post-obit code shows how to use the readAllBytes method:

Path file = ...; byte[] fileArray; fileArray = Files.readAllBytes(file);          

Writing All Bytes or Lines to a File

Yous can use one of the write methods to write bytes, or lines, to a file.

• write(Path, byte[], OpenOption...)
• write(Path, Iterable< extends CharSequence>, Charset, OpenOption...)

The following lawmaking snippet shows how to utilise a write method.

Path file = ...; byte[] buf = ...; Files.write(file, buf);          

---

Buffered I/O Methods for Text Files

The coffee.nio.file packet supports channel I/O, which moves data in buffers, bypassing some of the layers that can bottleneck stream I/O.

Reading a File by Using Buffered Stream I/O

The newBufferedReader(Path, Charset) method opens a file for reading, returning a BufferedReader that can be used to read text from a file in an efficient manner.

The following code snippet shows how to use the newBufferedReader method to read from a file. The file is encoded in "United states-ASCII."

Charset charset = Charset.forName("Us-ASCII"); endeavour (BufferedReader reader = Files.newBufferedReader(file, charset)) {     String line = null;     while ((line = reader.readLine()) != null) {         System.out.println(line);     } } catch (IOException ten) {     System.err.format("IOException: %southward%north", x); }          

Writing a File by Using Buffered Stream I/O

You can use the newBufferedWriter(Path, Charset, OpenOption...) method to write to a file using a BufferedWriter.

The following code snippet shows how to create a file encoded in "US-ASCII" using this method:

Charset charset = Charset.forName("US-ASCII"); Cord s = ...; try (BufferedWriter writer = Files.newBufferedWriter(file, charset)) {     writer.write(due south, 0, s.length()); } grab (IOException 10) {     System.err.format("IOException: %s%n", x); }          

---

Methods for Unbuffered Streams and Interoperable with java.io APIs

Reading a File by Using Stream I/O

To open up a file for reading, you can use the newInputStream(Path, OpenOption...) method. This method returns an unbuffered input stream for reading bytes from the file.

Path file = ...; effort (InputStream in = Files.newInputStream(file);     BufferedReader reader =       new BufferedReader(new InputStreamReader(in))) {     String line = cypher;     while ((line = reader.readLine()) != null) {         System.out.println(line);     } } catch (IOException x) {     Arrangement.err.println(ten); }          

Creating and Writing a File by Using Stream I/O

Yous can create a file, suspend to a file, or write to a file by using the newOutputStream(Path, OpenOption...) method. This method opens or creates a file for writing bytes and returns an unbuffered output stream.

The method takes an optional OpenOption parameter. If no open up options are specified, and the file does not exist, a new file is created. If the file exists, information technology is truncated. This pick is equivalent to invoking the method with the CREATE and TRUNCATE_EXISTING options.

The following instance opens a log file. If the file does not be, it is created. If the file exists, it is opened for appending.

import static java.nio.file.StandardOpenOption.*; import coffee.nio.file.*; import java.io.*;  public class LogFileTest {    public static void principal(Cord[] args) {      // Catechumen the string to a     // byte array.     String s = "Hullo World! ";     byte information[] = s.getBytes();     Path p = Paths.get("./logfile.txt");      effort (OutputStream out = new BufferedOutputStream(       Files.newOutputStream(p, CREATE, APPEND))) {       out.write(data, 0, data.length);     } catch (IOException ten) {       System.err.println(x);     }   } }          

---

Methods for Channels and ByteBuffers

Reading and Writing Files by Using Channel I/O

While stream I/O reads a grapheme at a time, channel I/O reads a buffer at a time. The ByteChannel interface provides bones read and write functionality. A SeekableByteChannel is a ByteChannel that has the adequacy to maintain a position in the channel and to modify that position. A SeekableByteChannel also supports truncating the file associated with the channel and querying the file for its size.

The capability to motion to different points in the file and then read from or write to that location makes random access of a file possible. See Random Access Files for more data.

At that place are two methods for reading and writing aqueduct I/O.

• newByteChannel(Path, OpenOption...)
• newByteChannel(Path, Set<? extends OpenOption>, FileAttribute<?>...)

---

Note: The newByteChannel methods return an instance of a SeekableByteChannel. With a default file arrangement, y'all can bandage this seekable byte aqueduct to a FileChannel providing access to more avant-garde features such mapping a region of the file directly into memory for faster access, locking a region of the file then other processes cannot access it, or reading and writing bytes from an absolute position without affecting the aqueduct'south current position.

---

Both newByteChannel methods enable you to specify a list of OpenOption options. The aforementioned open options used past the newOutputStream methods are supported, in add-on to i more option: READ is required because the SeekableByteChannel supports both reading and writing.

Specifying READ opens the aqueduct for reading. Specifying WRITE or Suspend opens the channel for writing. If none of these options are specified, then the channel is opened for reading.

The post-obit code snippet reads a file and prints it to standard output:

public static void readFile(Path path) throws IOException {      // Files.newByteChannel() defaults to StandardOpenOption.READ     endeavor (SeekableByteChannel sbc = Files.newByteChannel(path)) {         final int BUFFER_CAPACITY = 10;         ByteBuffer buf = ByteBuffer.allocate(BUFFER_CAPACITY);          // Read the bytes with the proper encoding for this platform. If         // y'all skip this stride, you might run into foreign or illegible         // characters.         String encoding = Organisation.getProperty("file.encoding");         while (sbc.read(buf) > 0) {             buf.flip();             System.out.print(Charset.forName(encoding).decode(buf));             buf.clear();         }     }     }          

The post-obit instance, written for UNIX and other POSIX file systems, creates a log file with a specific prepare of file permissions. This code creates a log file or appends to the log file if it already exists. The log file is created with read/write permissions for owner and read only permissions for group.

import static coffee.nio.file.StandardOpenOption.*; import java.nio.*; import coffee.nio.channels.*; import coffee.nio.file.*; import java.nio.file.attribute.*; import java.io.*; import java.util.*;  public class LogFilePermissionsTest {    public static void principal(String[] args) {        // Create the set of options for appending to the file.     Set<OpenOption> options = new HashSet<OpenOption>();     options.add together(Suspend);     options.add(CREATE);      // Create the custom permissions attribute.     Set<PosixFilePermission> perms =       PosixFilePermissions.fromString("rw-r-----");     FileAttribute<Set<PosixFilePermission>> attr =       PosixFilePermissions.asFileAttribute(perms);      // Convert the cord to a ByteBuffer.     String southward = "Hello Globe! ";     byte data[] = southward.getBytes();     ByteBuffer bb = ByteBuffer.wrap(data);          Path file = Paths.get("./permissions.log");      try (SeekableByteChannel sbc =       Files.newByteChannel(file, options, attr)) {       sbc.write(bb);     } catch (IOException x) {       Organization.out.println("Exception thrown: " + x);     }   } }          

---

Methods for Creating Regular and Temporary Files

Creating Files

You can create an empty file with an initial set of attributes by using the createFile(Path, FileAttribute<?>) method. For case, if, at the fourth dimension of creation, you want a file to have a detail set of file permissions, use the createFile method to do so. If you lot do non specify any attributes, the file is created with default attributes. If the file already exists, createFile throws an exception.

In a single atomic operation, the createFile method checks for the being of the file and creates that file with the specified attributes, which makes the process more secure against malicious code.

The post-obit lawmaking snippet creates a file with default attributes:

Path file = ...; try {     // Create the empty file with default permissions, etc.     Files.createFile(file); } catch (FileAlreadyExistsException x) {     System.err.format("file named %south" +         " already exists%north", file); } catch (IOException x) {     // Some other sort of failure, such every bit permissions.     System.err.format("createFile error: %southward%n", x); }          

POSIX File Permissions has an case that uses createFile(Path, FileAttribute<?>) to create a file with pre-set permissions.

You lot can also create a new file by using the newOutputStream methods, as described in Creating and Writing a File using Stream I/O. If you lot open up a new output stream and close information technology immediately, an empty file is created.

Creating Temporary Files

You tin create a temporary file using ane of the following createTempFile methods:

• createTempFile(Path, String, String, FileAttribute<?>)
• createTempFile(String, String, FileAttribute<?>)

The offset method allows the code to specify a directory for the temporary file and the second method creates a new file in the default temporary-file directory. Both methods let y'all to specify a suffix for the filename and the first method allows y'all to also specify a prefix. The following lawmaking snippet gives an example of the 2d method:

try {     Path tempFile = Files.createTempFile(null, ".myapp");     System.out.format("The temporary file" +         " has been created: %s%n", tempFile) ; } take hold of (IOException x) {     System.err.format("IOException: %s%n", ten); }          

The result of running this file would be something like the post-obit:

The temporary file has been created: /tmp/509668702974537184.myapp          

The specific format of the temporary file name is platform specific.

jamescampenish.blogspot.com

Source: https://docs.oracle.com/javase/tutorial/essential/io/file.html

Share this post