Read From File Print in New File Assembly

This page discusses the details of reading, writing, creating, and opening files. In that location are a wide array of file I/O methods to choose from. To assist brand sense of the API, the following diagram arranges the file I/O methods by complexity.

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 elementary, mutual cases. To the right of those are the methods used to iterate over a stream or lines of text, such equally newBufferedReader, newBufferedWriter, then newInputStream and newOutputStream. These methods are interoperable with the coffee.io bundle. 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 use FileChannel for avant-garde applications needing file locking or retentiveness-mapped I/O.

---

Note: The methods for creating a new file enable you to specify an optional ready of initial attributes for the file. For case, on a file system that supports the POSIX set of standards (such as UNIX), you tin can specify a file owner, grouping possessor, or file permissions at the time the file is created. The Managing Metadata folio explains file attributes, and how to admission and set them.

---

This page has the post-obit topics:

• The OpenOptions Parameter
• Normally Used Methods for Minor 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 data to the end of the file. This option is used with the WRITE or CREATE options.
• TRUNCATE_EXISTING – Truncates the file to cypher bytes. This choice is used with the WRITE option.
• 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 option is useful for temporary files.
• SPARSE – Hints that a newly created file will exist sparse. This advanced option is honored on some file systems, such as NTFS, where big files with data "gaps" can be stored in a more efficient fashion where those empty gaps do non consume disk space.
• 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.

---

Unremarkably Used Methods for Small Files

Reading All Bytes or Lines from a File

If you take a small-ish file and you lot would like to read its entire contents in one pass, you tin can use the readAllBytes(Path) or readAllLines(Path, Charset) method. These methods take intendance of near of the work for you, such as opening and closing the stream, but are not intended for treatment large files. The following code shows how to utilise the readAllBytes method:

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

Writing All Bytes or Lines to a File

Yous tin 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 post-obit lawmaking snippet shows how to employ a write method.

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

---

Buffered I/O Methods for Text Files

The java.nio.file parcel supports channel I/O, which moves information in buffers, bypassing some of the layers that can clogging 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 utilise the newBufferedReader method to read from a file. The file is encoded in "US-ASCII."

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

Writing a File past Using Buffered Stream I/O

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

The following lawmaking snippet shows how to create a file encoded in "United states of america-ASCII" using this method:

Charset charset = Charset.forName("United states-ASCII"); Cord s = ...; effort (BufferedWriter writer = Files.newBufferedWriter(file, charset)) {     author.write(s, 0, s.length()); } catch (IOException ten) {     Organisation.err.format("IOException: %s%n", x); }          

---

Methods for Unbuffered Streams and Interoperable with coffee.io APIs

Reading a File by Using Stream I/O

To open a file for reading, y'all tin employ the newInputStream(Path, OpenOption...) method. This method returns an unbuffered input stream for reading bytes from the file.

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

Creating and Writing a File by Using Stream I/O

You tin create a file, suspend 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 not exist, a new file is created. If the file exists, it is truncated. This option is equivalent to invoking the method with the CREATE and TRUNCATE_EXISTING options.

The post-obit example opens a log file. If the file does not exist, information technology is created. If the file exists, it is opened for appending.

import static java.nio.file.StandardOpenOption.*; import java.nio.file.*; import java.io.*;  public course LogFileTest {    public static void chief(String[] args) {      // Convert the string to a     // byte array.     String s = "How-do-you-do World! ";     byte data[] = s.getBytes();     Path p = Paths.become("./logfile.txt");      try (OutputStream out = new BufferedOutputStream(       Files.newOutputStream(p, CREATE, Suspend))) {       out.write(information, 0, data.length);     } take hold of (IOException ten) {       Arrangement.err.println(x);     }   } }          

---

Methods for Channels and ByteBuffers

Reading and Writing Files by Using Channel I/O

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

The capability to move to different points in the file and then read from or write to that location makes random admission of a file possible. Run into Random Access Files for more information.

There are ii methods for reading and writing channel 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 system, you tin cast this seekable byte aqueduct to a FileChannel providing admission to more advanced features such mapping a region of the file directly into memory for faster admission, locking a region of the file so other processes cannot admission information technology, or reading and writing bytes from an accented position without affecting the channel's current position.

---

Both newByteChannel methods enable you to specify a list of OpenOption options. The same open options used by the newOutputStream methods are supported, in improver to ane more option: READ is required because the SeekableByteChannel supports both reading and writing.

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

The following code snippet reads a file and prints information technology 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 = ten;         ByteBuffer buf = ByteBuffer.classify(BUFFER_CAPACITY);          // Read the bytes with the proper encoding for this platform. If         // you skip this footstep, you might run into 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 post-obit example, written for UNIX and other POSIX file systems, creates a log file with a specific set of file permissions. This lawmaking 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 java.nio.channels.*; import java.nio.file.*; import java.nio.file.attribute.*; import coffee.io.*; import java.util.*;  public course LogFilePermissionsTest {    public static void main(String[] args) {        // Create the ready of options for appending to the file.     Set<OpenOption> options = new HashSet<OpenOption>();     options.add(Suspend);     options.add(CREATE);      // Create the custom permissions attribute.     Set<PosixFilePermission> perms =       PosixFilePermissions.fromString("rw-r-----");     FileAttribute<Fix<PosixFilePermission>> attr =       PosixFilePermissions.asFileAttribute(perms);      // Convert the string to a ByteBuffer.     String s = "Hello World! ";     byte data[] = southward.getBytes();     ByteBuffer bb = ByteBuffer.wrap(information);          Path file = Paths.go("./permissions.log");      attempt (SeekableByteChannel sbc =       Files.newByteChannel(file, options, attr)) {       sbc.write(bb);     } grab (IOException 10) {       System.out.println("Exception thrown: " + x);     }   } }          

---

Methods for Creating Regular and Temporary Files

Creating Files

Yous can create an empty file with an initial set of attributes by using the createFile(Path, FileAttribute<?>) method. For instance, if, at the fourth dimension of cosmos, you want a file to have a particular set up of file permissions, use the createFile method to practice and so. If y'all do not specify any attributes, the file is created with default attributes. If the file already exists, createFile throws an exception.

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

The following code snippet creates a file with default attributes:

Path file = ...; endeavour {     // Create the empty file with default permissions, etc.     Files.createFile(file); } catch (FileAlreadyExistsException 10) {     System.err.format("file named %s" +         " already exists%n", file); } catch (IOException x) {     // Some other sort of failure, such as permissions.     System.err.format("createFile mistake: %due south%north", x); }          

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

Y'all 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 open a new output stream and shut it immediately, an empty file is created.

Creating Temporary Files

You can create a temporary file using one of the following createTempFile methods:

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

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

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

The result 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.

schermerhornsaffive.blogspot.com

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

Share this post