Java 8 Read Text File and Change Contents

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

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

On the far left of the diagram are the utility methods readAllBytes, readAllLines, and the write methods, designed for unproblematic, common cases. To the right of those are the methods used to iterate over a stream or lines of text, such as newBufferedReader, newBufferedWriter, then newInputStream and newOutputStream. These methods are interoperable with the java.io package. To the right of those are the methods for dealing with ByteChannels, SeekableByteChannels, and ByteBuffers, such as the newByteChannel method. Finally, on the far correct are the methods that apply FileChannel for avant-garde applications needing file locking or memory-mapped I/O.

---

Annotation: The methods for creating a new file enable you to specify an optional prepare of initial attributes for the file. For example, on a file system that supports the POSIX fix of standards (such as UNIX), you can specify a file owner, group owner, or file permissions at the time the file is created. The Managing Metadata page explains file attributes, and how to access and set them.

---

This page has the following topics:

• The OpenOptions Parameter
• Usually Used Methods for Small Files
• Buffered I/O Methods for Text Files
• Methods for Unbuffered Streams and Interoperable with coffee.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 behavior is for the method when none is specified.

The following StandardOpenOptions enums are supported:

• WRITE – Opens the file for write access.
• 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 nil 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 closed. This pick is useful for temporary files.
• Sparse – Hints that a newly created file will be sparse. This advanced option is honored on some file systems, such equally NTFS, where large files with data "gaps" can be stored in a more efficient manner where those empty gaps practise non consume 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.

---

Ordinarily Used Methods for Pocket-size Files

Reading All Bytes or Lines from a File

If you take a small-ish file and you would like to read its unabridged contents in one pass, you tin use the readAllBytes(Path) or readAllLines(Path, Charset) method. These methods take intendance of most of the work for you, such every bit opening and closing the stream, only are not intended for handling big files. The following code shows how to use the readAllBytes method:

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

Writing All Bytes or Lines to a File

You can utilize 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 post-obit 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 package supports channel I/O, which moves data in buffers, bypassing some of the layers that can bottleneck stream I/O.

Reading a File past 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 "Usa-ASCII."

Charset charset = Charset.forName("United states-ASCII"); try (BufferedReader reader = Files.newBufferedReader(file, charset)) {     Cord line = zilch;     while ((line = reader.readLine()) != zip) {         System.out.println(line);     } } catch (IOException 10) {     System.err.format("IOException: %s%n", x); }          

Writing a File by Using Buffered Stream I/O

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

The post-obit code snippet shows how to create a file encoded in "The states-ASCII" using this method:

Charset charset = Charset.forName("Us-ASCII"); Cord s = ...; try (BufferedWriter writer = Files.newBufferedWriter(file, charset)) {     author.write(s, 0, southward.length()); } catch (IOException x) {     Organisation.err.format("IOException: %s%due north", x); }          

---

Methods for Unbuffered Streams and Interoperable with coffee.io APIs

Reading a File by Using Stream I/O

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

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

Creating and Writing a File past Using Stream I/O

You tin can create a file, append to a file, or write to a file past 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 options are specified, and the file does non exist, a new file is created. If the file exists, it is truncated. This choice is equivalent to invoking the method with the CREATE and TRUNCATE_EXISTING options.

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

import static coffee.nio.file.StandardOpenOption.*; import java.nio.file.*; import coffee.io.*;  public class LogFileTest {    public static void main(String[] args) {      // Convert the cord to a     // byte assortment.     Cord southward = "How-do-you-do World! ";     byte information[] = s.getBytes();     Path p = Paths.go("./logfile.txt");      try (OutputStream out = new BufferedOutputStream(       Files.newOutputStream(p, CREATE, Suspend))) {       out.write(information, 0, data.length);     } catch (IOException 10) {       Organization.err.println(x);     }   } }          

---

Methods for Channels and ByteBuffers

Reading and Writing Files by Using Channel I/O

While stream I/O reads a graphic symbol at a time, channel I/O reads a buffer at a time. The ByteChannel interface provides basic read and write functionality. A SeekableByteChannel is a ByteChannel that has the capability 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 motility to different points in the file and then read from or write to that location makes random access of a file possible. Run across Random Access Files for more than information.

There are two methods for reading and writing channel I/O.

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

---

Note: The newByteChannel methods return an instance of a SeekableByteChannel. With a default file organisation, you can cast this seekable byte aqueduct to a FileChannel providing admission to more avant-garde features such mapping a region of the file directly into retention for faster access, locking a region of the file so other processes cannot admission information technology, or reading and writing bytes from an absolute position without affecting the channel'due south current position.

---

Both newByteChannel methods enable you lot to specify a listing of OpenOption options. The same open options used by the newOutputStream methods are supported, in addition to one more selection: READ is required considering the SeekableByteChannel supports both reading and writing.

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

The following 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     try (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         // you skip this step, you lot might encounter foreign or illegible         // characters.         String encoding = System.getProperty("file.encoding");         while (sbc.read(buf) > 0) {             buf.flip();             System.out.print(Charset.forName(encoding).decode(buf));             buf.clear();         }     }     }          

The following example, written for UNIX and other POSIX file systems, creates a log file with a specific set of file permissions. This code creates a log file or appends to the log file if information technology already exists. The log file is created with read/write permissions for possessor and read merely permissions for group.

import static java.nio.file.StandardOpenOption.*; import coffee.nio.*; import java.nio.channels.*; import coffee.nio.file.*; import java.nio.file.attribute.*; import java.io.*; import java.util.*;  public class LogFilePermissionsTest {    public static void main(Cord[] args) {        // Create the fix of options for appending to the file.     Set<OpenOption> options = new HashSet<OpenOption>();     options.add together(APPEND);     options.add(CREATE);      // Create the custom permissions aspect.     Set<PosixFilePermission> perms =       PosixFilePermissions.fromString("rw-r-----");     FileAttribute<Ready<PosixFilePermission>> attr =       PosixFilePermissions.asFileAttribute(perms);      // Catechumen the string to a ByteBuffer.     Cord s = "Hello Earth! ";     byte data[] = southward.getBytes();     ByteBuffer bb = ByteBuffer.wrap(information);          Path file = Paths.get("./permissions.log");      attempt (SeekableByteChannel sbc =       Files.newByteChannel(file, options, attr)) {       sbc.write(bb);     } catch (IOException 10) {       System.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 example, if, at the time of creation, you want a file to have a particular ready of file permissions, use the createFile method to do so. If yous 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 existence of the file and creates that file with the specified attributes, which makes the procedure more secure against malicious code.

The following code snippet creates a file with default attributes:

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

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

You can also create a new file past using the newOutputStream methods, every bit described in Creating and Writing a File using Stream I/O. If you open a new output stream and close it immediately, an empty file is created.

Creating Temporary Files

Yous tin can create a temporary file using ane of the post-obit createTempFile methods:

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

The outset method allows the lawmaking 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 you to specify a suffix for the filename and the outset method allows yous to likewise specify a prefix. The following code snippet gives an example of the second method:

effort {     Path tempFile = Files.createTempFile(null, ".myapp");     System.out.format("The temporary file" +         " has been created: %s%n", tempFile) ; } catch (IOException 10) {     Organization.err.format("IOException: %southward%n", x); }          

The event of running this file would be something like the following:

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

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

escarcegalostower.blogspot.com

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

Share this post