Skip to content Skip to sidebar Skip to footer
Página inicial / Read Text File Java Command Line Argument

Read Text File Java Command Line Argument

Postar um comentário

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

Line drawing with file I/O methods arranged from least complex (on the left) to most complex (on the right).
File I/O Methods Arranged from Less Complex to More Circuitous

On the far left of the diagram are the utility methods readAllBytes, readAllLines, and the write methods, designed for simple, common cases. To the correct 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 coffee.io packet. To the right of those are the methods for dealing with ByteChannels, SeekableByteChannels, and ByteBuffers, such as the newByteChannel method. Finally, on the far right are the methods that employ FileChannel for advanced applications needing file locking or memory-mapped I/O.

Notation: The methods for creating a new file enable you to specify an optional set of initial attributes for the file. For instance, on a file arrangement that supports the POSIX fix of standards (such as UNIX), you lot can specify a file owner, group owner, or file permissions at the fourth dimension the file is created. The Managing Metadata folio explains file attributes, and how to admission and set them.

This folio has the following topics:

  • The OpenOptions Parameter
  • Commonly Used Methods for Minor 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 department 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 access.
  • APPEND – Appends the new data to the stop of the file. This option is used with the WRITE or CREATE options.
  • TRUNCATE_EXISTING – Truncates the file to zero bytes. This option 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 information technology exists or creates a new file if it 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 volition be sparse. This advanced pick is honored on some file systems, such every bit NTFS, where large files with data "gaps" tin be stored in a more efficient manner where those empty gaps practise not swallow 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.

Normally Used Methods for Pocket-sized Files

Reading All Bytes or Lines from a File

If you accept a small-ish file and you would like to read its entire contents in one laissez passer, you can use the readAllBytes(Path) or readAllLines(Path, Charset) method. These methods take care of most of the piece of work for you, such equally opening and closing the stream, but 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 lot 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 code snippet shows how to use 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 clogging 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 tin can be used to read text from a file in an efficient fashion.

The following lawmaking snippet shows how to utilize the newBufferedReader method to read from a file. The file is encoded in "US-ASCII."

Charset charset = Charset.forName("US-ASCII"); try (BufferedReader reader = Files.newBufferedReader(file, charset)) {     Cord line = nada;     while ((line = reader.readLine()) != nix) {         Organisation.out.println(line);     } } catch (IOException ten) {     Organisation.err.format("IOException: %s%n", x); }

Writing a File by Using Buffered Stream I/O

You can utilize 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"); String s = ...; endeavor (BufferedWriter writer = Files.newBufferedWriter(file, charset)) {     writer.write(due south, 0, southward.length()); } catch (IOException x) {     Arrangement.err.format("IOException: %due south%n", x); }

Methods for Unbuffered Streams and Interoperable with java.io APIs

Reading a File by Using Stream I/O

To open 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 = ...; attempt (InputStream in = Files.newInputStream(file);     BufferedReader reader =       new BufferedReader(new InputStreamReader(in))) {     Cord line = cypher;     while ((line = reader.readLine()) != cypher) {         System.out.println(line);     } } catch (IOException x) {     System.err.println(x); }

Creating and Writing a File past Using Stream I/O

You lot 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 up options are specified, and the file does non 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 class LogFileTest {    public static void main(Cord[] args) {      // Catechumen the cord to a     // byte array.     Cord s = "Howdy Earth! ";     byte information[] = s.getBytes();     Path p = Paths.get("./logfile.txt");      try (OutputStream out = new BufferedOutputStream(       Files.newOutputStream(p, CREATE, Suspend))) {       out.write(data, 0, information.length);     } catch (IOException x) {       Organization.err.println(x);     }   } }

Methods for Channels and ByteBuffers

Reading and Writing Files past Using Aqueduct I/O

While stream I/O reads a character at a time, aqueduct 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 change that position. A SeekableByteChannel besides supports truncating the file associated with the channel and querying the file for its size.

The capability to move to different points in the file and so read from or write to that location makes random access of a file possible. Meet Random Access Files for more than 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 render an instance of a SeekableByteChannel. With a default file system, you lot can cast this seekable byte channel to a FileChannel providing access to more than avant-garde features such mapping a region of the file directly into retention for faster admission, locking a region of the file so 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 same open up options used by the newOutputStream methods are supported, in add-on to one more option: READ is required considering the SeekableByteChannel supports both reading and writing.

Specifying READ opens the channel for reading. Specifying WRITE or APPEND opens the channel for writing. If none of these options are specified, so 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     try (SeekableByteChannel sbc = Files.newByteChannel(path)) {         terminal int BUFFER_CAPACITY = 10;         ByteBuffer buf = ByteBuffer.classify(BUFFER_CAPACITY);          // Read the bytes with the proper encoding for this platform. If         // you skip this step, y'all might see strange or illegible         // characters.         String encoding = System.getProperty("file.encoding");         while (sbc.read(buf) > 0) {             buf.flip();             System.out.impress(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 simply permissions for group.

import static java.nio.file.StandardOpenOption.*; import coffee.nio.*; import java.nio.channels.*; import java.nio.file.*; import java.nio.file.attribute.*; import java.io.*; import java.util.*;  public class LogFilePermissionsTest {    public static void main(String[] args) {        // Create the set up of options for appending to the file.     Set up<OpenOption> options = new HashSet<OpenOption>();     options.add(APPEND);     options.add(CREATE);      // Create the custom permissions aspect.     Set<PosixFilePermission> perms =       PosixFilePermissions.fromString("rw-r-----");     FileAttribute<Set<PosixFilePermission>> attr =       PosixFilePermissions.asFileAttribute(perms);      // Convert the string to a ByteBuffer.     Cord s = "Hello World! ";     byte data[] = southward.getBytes();     ByteBuffer bb = ByteBuffer.wrap(information);          Path file = Paths.go("./permissions.log");      effort (SeekableByteChannel sbc =       Files.newByteChannel(file, options, attr)) {       sbc.write(bb);     } catch (IOException x) {       Organisation.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 example, if, at the time of creation, yous want a file to have a particular set of file permissions, use the createFile method to do so. If you practise not specify whatever 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 lawmaking snippet creates a file with default attributes:

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

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

You 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 close it immediately, an empty file is created.

Creating Temporary Files

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

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

The start method allows the lawmaking 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 first method allows yous to also specify a prefix. The following lawmaking snippet gives an example of the second method:

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

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.

woodalver1998.blogspot.com

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

Postar um comentário for "Read Text File Java Command Line Argument"