Notes on File Handling in Java
Input and Output in Java
• The java.io package contains classes that perform input and output.
• In Java, I/O classes are differentiated according to the type of data being read or written.
• Types of data that are dealt in Java are mainly:
o Byte-oriented Data
o Numeric Data
o Character Data
• Byte oriented and numeric data is written with output streams and read with input streams.
• Character data, that is text, is written with writers and read with readers.
• Whether you use streams or readers and writers depends on the type of data you're dealing with.
• All text data, especially non-ASCII text, should be passed through a reader or writer.
• The two main stream classes are java.io.InputStream and java.io.OutputStream.
• The two main reader and writer classes are java.io.Reader and java.io.Writer
• Above four specified classes are abstract base classes for many different subclasses with more specialized abilities.
What is a Stream?
• A stream is a sequence of data of undetermined length. It's called a stream because it's like a stream of water that continues to flow. There's no definite end to it.
• In Java a stream is composed of discrete bytes.
• The bytes may represent chars or other kinds of data.
• They may come faster than you can handle them, or your thread may block while waiting for the next one to arrive.
• The key to processing the stream is a while loop that processes each piece of data, until you encounter the end-of-stream character or some other exceptional condition occurs.
• In Unix you type end-of-stream with Control-D. On Windows, you type end-of-stream with Control-Z.
• Java 2 defines two types of Streams:
o Byte Streams
o Character Streams
The Byte Stream Classes
• Most stream classes are part of the java.io package.
• The two main classes for handling byte streams of data are
o java.io.InputStream
o java.io.OutputStream.
• These are abstract base classes for many different subclasses with more specialized abilities, including:
|Input Streams |Output Streams |
|BufferedInputStream |BufferedOutputStream |
|ByteArrayInputStream |ByteArrayOutputStream |
|DataInputStream |DataOutputStream |
|FileInputStream |FileOutputStream |
|FilterInputStream |FilterOutputStream |
|ObjectInputStream |ObjectOutputStream |
|PipedInputStream |PipedOutputStream |
|PushBackInputStream |PrintStream |
|InputStream |OutputStream |
The InputStream Class
• java.io.InputStream is an abstract class that contains the basic methods for reading raw bytes of data from a stream.
• Although InputStream is an abstract class, many methods in the class library are only specified to return an InputStream, so you'll often have to deal directly with only the methods declared in this class.
• The major methods defined inside this class are as follows:
o public abstract int read() throws IOException
o public int read(byte[] data) throws IOException
o public int read(byte[] data, int offset, int length) throws IOException
o public long skip(long n) throws IOException
o public int available() throws IOException
o public void close() throws IOException
o public void mark(int readLimit)
o public void reset() throws IOException
o public boolean markSupported()
• Notice that almost all these methods can throw an IOException.
• This is true of pretty much anything to do with input and output.
• The only exception is the PrintStream class which eats all exceptions.
Reading bytes of data
The basic read() method of the InputStream class reads a single unsigned byte of data and returns the int value of the unsigned byte. This is a number between 0 and 255. If the end of stream is encountered, it returns -1 instead; and you can use this as a flag to watch for the end of stream.
public abstract int read() throws IOException
Here's a simple program that echoes back what the user types at the command line.
import java.io.*;
public class Echo {
public static void main(String[] args) {
try {
echo(System.in);
}
catch (IOException ex) {
System.err.println(ex);
}
}
public static void echo(InputStream in) throws IOException {
while (true) {
int i = in.read(); // -1 is returned to indicate the end of stream
if (i == -1) break;
// without the cast a numeric string like "65" would be printed instead of the character "A"
char c = (char) i;
System.out.print(c);
}
System.out.println();
}
}
Reading many bytes of data
• The basic read() method reads a byte at a time. This is less than perfectly efficient.
• The following two overloaded variants read multiple bytes into an array of bytes.
o public int read(byte[] data) throws IOException
The above methodsreads enough bytes to fill array data
o public int read(byte[] data, int offset, int length) throws IOException
The above method reads length bytes from the input stream and stores them into the array data starting at position offset.
• These methods then return the number of bytes actually read.
• If the end of stream is encountered, -1 is returned.
Counting the available bytes
• The available() method tests how many bytes are ready to be read from the stream without blocking.
public int available() throws IOException
Skipping bytes
• The skip() method reads a specified number of bytes and throws them away.
public int skip(long n) throws IOException
Marking and resetting
• It's often useful to be able to read a few bytes, and then back up and reread them.
• Three methods support this:
o public void mark(int readLimit)
o public void reset() throws IOException
o public boolean markSupported()
The boolean markSupported() method returns true if this stream supports marking and false if it doesn't.
Assuming the stream does support marking, the mark() method places a bookmark in the stream which you can return to later using the reset() method. There can be only one mark in the stream at any given time. Marking a second location erases the first mark. If marking is not supported, these methods throw IOExceptions.
Closing Streams
• When you're done with a stream, you should close it to release any resources associated with the stream.
• Once the stream is closed attempts to read from it, will throw IOExceptions.
• You close a stream with the close() method:
public void close() throws IOException
The OutputStream Class
• The java.io.OutputStream class sends raw bytes of data to a target such as the console or a network server.
• However, many methods in the class library are only specified to return OutputStream rather than the more specific subclass.
• The methods defined within the OutputStream class are as follows:
o public abstract void write(int b) throws IOException
o public void write(byte[] data) throws IOException
o public void write(byte[] data, int offset, int length) throws IOException
o public void flush() throws IOException
o public void close() throws IOException
• The write() methods send raw bytes of data to whomever is listening to this stream.
• Sometimes output streams are buffered by the operating system for performance.
• In other words, rather than writing each byte as it's written, the bytes are accumulated in a buffer ranging from several bytes to several thousand bytes.
• Then, when the buffer fills up, all the data is written at once. The flush() method forces the data to be written whether or not the buffer is full.
• This is not the same as the buffering performed by a BufferedOutputStream. That buffering is handled by the Java runtime.
• This buffering is at the native OS level. However, a call to flush() should empty both buffers.
• The close() method closes the stream and releases any resources associated with the stream. After the stream is closed, attempts to write to it throw IOExceptions.
• Sample Program illustrating the methods of OutputStream class:
import java.io.*;
public class HelloOutputStream {
public static void main(String[] args) {
String s = "Hello World\r\n";
// Convert s to a byte array
byte[] b = new byte[s.length()];
s.getBytes(0, s.length()-1, b, 0);
try {
System.out.write(b);
System.out.flush();
}
catch (IOException ex) {
System.err.println(ex);
}
}
}
Input from Files
• The java.io.FileInputStream class represents an InputStream that reads bytes from a file.
• It has the following public methods:
o public FileInputStream(String name) throws FileNotFoundException
o public FileInputStream(File file) throws FileNotFoundException
o public FileInputStream(FileDescriptor fd)
o public int read() throws IOException
o public int read(byte[] data) throws IOException
o public int read(byte[] data, int offset, int length) throws IOException
o public long skip(long n) throws IOException
o public int available() throws IOException
o public void close() throws IOException
o public final FileDescriptor getFD() throws IOException
• Except for the constructors and getFD(), these methods merely override the methods of the same name in java.io.InputStream.
• You use them exactly like you use those methods, only you'll end up reading data from a file.
Examples of Input from Files
import java.io.*;
public class Type {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
try {
FileInputStream fis = new FileInputStream(args[i]);
byte[] b = new byte[1024];
while (true) {
int result = fis.read(b);
if (result == -1) break;
String s = new String(b, 0, result);
System.out.print(s);
} // end while
} // end try
catch (FileNotFoundException ex) {
System.err.println("Could not find file " + args[i]);
}
catch (IOException ex) {
System.err.println(ex);
}
System.out.println();
} // end for
} // end main
}
Writing data to Files
• The java.io.FileOutputStream class represents an OutputStream that writes bytes to a file.
• It has the following public methods:
o public FileOutputStream(String name) throws IOException
o public FileOutputStream(String name, boolean append) throws IOException
o public FileOutputStream(File file) throws IOException
o public FileOutputStream(FileDescriptor fd)
o public void write(int b) throws IOException
o public void write(byte[] data) throws IOException
o public void write(byte[] data, int offset, int length) throws IOException
o public void close() throws IOException
o public final FileDescriptor getFD() throws IOException
Example of Output to Files
import java.io.*;
public class MultiType {
public final static int BUFFER_SIZE = 4096;
public static void main(String[] args) {
FileOutputStream[] fos = new FileOutputStream[args.length];
for (int i = 0; i < args.length; i++) {
try {
fos[i] = new FileOutputStream(args[i]);
}
catch (IOException ex) {
System.err.println(e);
}
} // end for
try {
byte[] buffer = new byte[BUFFER_SIZE];
while (true) {
int result = System.in.read(buffer);
if (result == -1) break;
for (int i = 0; i < args.length; i++) {
try {
fos[i].write(buffer, 0, result);
}
catch (IOException ex) {
System.err.println(ex.getMessage());
}
} // end for
} // end while
} // end try
catch (IOException ex) {
System.err.println(e);
}
} // end main
}
Appending data to files
• It's often useful to be able to append data to an existing file rather than overwriting it.
• To do this just pass the boolean value true as the second argument to the FileOutputStream() constructor. For example,
o FileOutputStream fos = new FileOutputStream("16.html", true);
import java.io.*;
public class Append {
public static final int BUFFER_SIZE = 1024;
public static void main(String[] args) {
FileOutputStream[] fos = new FileOutputStream[args.length];
for (int i = 0; i < args.length; i++) {
try {
fos[i] = new FileOutputStream(args[i], true);
}
catch (IOException ex) {
System.err.println(e);
}
} // end for
byte[] buffer = new byte[BUFFER_SIZE];
try {
while (true) {
int result = System.in.read(buffer);
if (result == -1) break;
for (int i = 0; i < args.length; i++) {
try {
fos[i].write(buffer, 0, result);
}
catch (IOException ex) {
System.err.println(ex);
}
} // end for
} // end while
} // end try
catch (IOException ex) {
System.err.println(ex);
}
for (int i = 0; i < args.length; i++) {
try {
fos[i].close();
}
catch (IOException ex) {
System.err.println(ex);
}
} // end for
} // end main
}
Filter Streams
• concrete subclasses of InputStream and OutputStream somehow modify data read from an underlying stream
• rarely use these classes directly, but their subclasses are extremely important
• connect filter streams to an underlying stream that supplies the actual bytes of data by passing the original stream to the filter stream's constructor
Filter Stream Classes
BufferedInputStream and BufferedOutputStream
• These classes buffer reads and writes by reading data first into a buffer (an internal array of bytes)
• Thus an application can read bytes from the stream without necessarily calling the underlying native method
• The data is read from or written into the buffer in blocks; subsequent accesses go straight to the buffer
DataInputStream and DataOutputStream
• These classes read and write primitive Java data types and strings in a machine-independent way
PrintStream
• PrintStream allows very simple printing of both primitive values, objects, and string literals
• It uses the platform's default character encoding to convert characters into bytes
• This class traps all IOExceptions.
• This class is primarily intended for debugging. System.out and System.err are instances of PrintStream.
PushbackInputStream
• This input stream has a one byte pushback buffer so a program can unread the last character read
• The next time data is read from the stream, the "unread" character is re-read
ObjectInputStream and ObjectOutputStream
• Subclasses of DataInputStream and DataOutputStream that can also serialize and deserialize Java objects to and from raw bytes
• Used by remote method invocation (RMI) and JavaBeans.
Buffered Streams
• The java.io.BufferedInputStream and java.io.BufferedOutputStream classes buffer reads and writes by first storing the data in a buffer (an internal array of bytes)
• Then the program reads bytes from the stream without calling the underlying native method until the buffer is empty.
• The data is read from or written into the buffer in blocks; subsequent accesses go straight to the buffer.
• The only real difference to the programmer between a regular stream and a buffered stream are the constructors:
o public BufferedInputStream(InputStream in)
o public BufferedInputStream(InputStream in, int size)
o public BufferedOutputStream(OutputStream out)
o public BufferedOutputStream(OutputStream out, int size)
• The size argument is the number of bytes in the buffer
• If a size isn't specified, a 512 byte buffer is used.
Data Stream Classes
• The java.io.DataInputStream and java.io.DataOutputStream classes read and write primitive Java data types and Strings in a machine-independent way
• Generally you use a DataInputStream to read data written by a DataOutputStream.
• DataOutputStream declares these methods:
o public DataOutputStream(OutputStream out)
o public void write(int b) throws IOException
o public void write(byte[] data, int offset, int length) throws IOException
o public final void writeBoolean(boolean b) throws IOException
o public final void writeByte(int b) throws IOException
o public final void writeShort(int s) throws IOException
o public final void writeChar(int c) throws IOException
o public final void writeInt(int i) throws IOException
o public final void writeFloat(float f) throws IOException
o public final void writeDouble(double d) throws IOException
o public final void writeBytes(String s) throws IOException
o public final void writeChars(String s) throws IOException
o public final void writeUTF(String s) throws IOException
o public final int size()
o public void flush() throws IOException
• The size() method returns the number of bytes written to this data output stream.
• DataInputStream has these methods:
o public DataInputStream(InputStream in)
o public final int read(byte[] input) throws IOException
o public final int read(byte[] input, int offset, int length) throws IOException
o public final void readFully(byte[] input) throws IOException
o public final void readFully(byte[] input, int offset, int length) throws IOException
o public final int skipBytes(int n) throws IOException
o public final boolean readBoolean() throws IOException
o public final byte readByte() throws IOException
o public final int readUnsignedByte() throws IOException
o public final short readShort() throws IOException
o public final int readUnsignedShort() throws IOException
o public final char readChar() throws IOException
o public final int readInt() throws IOException
o public final long readLong() throws IOException
o public final float readFloat() throws IOException
o public final double readDouble() throws IOException
o public final String readUTF() throws IOException
o public static final String readUTF(DataInput in) throws IOException
PushbackInputStream
• The PushbackInputStream class provides a pushback buffer so a program can "unread" bytes onto the stream
• These may be bytes the program has read from the stream or they may be bytes that come from somewhere else
• The next time data is read from the stream, the "unread" bytes are read.
o public void unread(int b) throws IOException
o public void unread(byte[] data, int offset, int length) throws IOException
o public void unread(byte[] data) throws IOException
• By default the buffer is only one byte long, and trying to unread more than that throws an IOException.
• However you can change the default buffer size with the second constructor below:
o public PushbackInputStream(InputStream in)
o public PushbackInputStream(InputStream in, int size)
The File Class
• The java.io.File class represents a file name on the host system.
• It attempts to abstract system-dependent file name features like the path separator character.
• There are two ways to reference a file, relative and absolute.
• Absolute addressing gives a complete path to a file, starting with the disk and working its way down.
• How this is represented varies from operating system to operating system.
• Here are some examples:
o Unix: "/home/users/elharo/file1"
o DOS: "C:\home\users\elharo\file1"
o Mac OS 9: "Macintosh HD:home:users:elharo:file1"
• java.io.File can hold a directory name equally as well as a filename.
• File Constructors
o public File(String path)
o public File(String path, String name)
o public File(File dir, String name)
• File Methods
o public String getName()
o public String getPath()
o public String getAbsolutePath()
o public String getParent()
o public boolean exists() throws SecurityException
o public boolean canWrite() throws SecurityException
o public boolean canRead() throws SecurityException
o public boolean isFile() throws SecurityException
o public boolean isDirectory() throws SecurityException
o public boolean isAbsolute()
o public long lastModified() throws SecurityException
o public long length() throws SecurityException
o public boolean mkdir()
o public boolean mkdirs() throws SecurityException
o public boolean renameTo(File destination) throws SecurityException
o public boolean delete() throws SecurityException
Examples of the File Methods
import java.io.*;
public class FileInfo {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
File f = new File(args[i]);
if (f.exists()) {
System.out.println("getName: " + f.getName());
System.out.println("getPath: " + f.getPath());
System.out.println("getAbsolutePath: " + f.getAbsolutePath());
System.out.println("getParent: " + f.getParent());
if (f.canWrite()) {
System.out.println(f.getName() + " is writable.");
}
if (f.canRead()) {
System.out.println(f.getName() + " is readable.");
}
if (f.isFile()) {
System.out.println(f.getName() + " is a file.");
}
else if (f.isDirectory()) {
System.out.println(f.getName() + " is a directory.");
}
else {
System.out.println("What is this?");
}
if (f.isAbsolute()) {
System.out.println(f.getName() + " is an absolute path.");
}
else {
System.out.println(
f.getName() + " is not an absolute path.");
}
try {
System.out.println("Last Modified" + f.lastModified());
System.out.println(f.getName() + " is " + f.length() + " bytes.");
}
catch (IOException ex) {
}
}
else {
System.out.println("Can't find the file " + args[i]);
}
}
}
}
File Dialogs
• The java.awt.FileDialog class is a subclass of java.awt.Dialog used for choosing a file to open or save.
• This class uses the host platform's standard open and save file dialogs. You won't add components to a FileDialog, or handle user interaction.
• You'll just retrieve the result which will be the name and directory of a file.
• There are three steps to using a FileDialog:
1. Create the FileDialog
2. Make the FileDialog visible.
3. Get the directory name and file name of the chosen file
• You create a FileDialog with the constructor
• public FileDialog(Frame parent, String title, int mode)
• The Frame is the parent of this file dialog
• mode is one of the two mnemonic constants FileDialog.LOAD or FileDialog.SAVE
• A typical use of this might look like
FileDialog fd = new FileDialog(new Frame(), "Please choose the file to open:", FileDialog.LOAD);
fd.setVisible(true);
FileDialog fd = new FileDialog(new Frame(),
"Please choose a file:", FileDialog.LOAD);
fd.show();
if (fd.getFile() != null) {
File f = new File(fd.getDirectory(), fd.getFile());
}
• If the user cancels the save, both getDirectory() and getFile() return null. Be sure to check for this!
Controlling File Dialogs
• fd.setDirectory("/usr/tmp");
• setFilenameFilter(FilenameFilter fnf).
Random Access Files
• Random access files can be read from or written to or both from a particular byte position in the file.
• The position in the file is indicated by a file pointer.
• There are two constructors in this class:
o public RandomAccessFile(String name, String mode) throws IOException
o public RandomAccessFile(File file, String mode) throws IOException
• The getFilePointer(), length(), and seek() methods allow you to determine and modify the point in the file at which reads and writes occur.
• Attempts to seek (position the file pointer) past the end of the file just move the file pointer to the end of the file.
• Attempts to write from the end of the file extend the file.
• Attempts to read from the end of the file throw EOFExceptions.
o public long getFilePointer() throws IOException
o public void seek(long pos) throws IOException
o public long length() throws IOException
• Reads and writes use methods that work identically to the methods of the DataInputStream and DataOutputStream classes, except that you can set the position at which the read or write occurs between calls to the read and write methods.
Readers and Writers
• The java.io.Reader and java.io.Writer classes are abstract superclasses for classes that read and write character based data.
• The subclasses are notable for handling the conversion between different character sets.
• Readers and writers are based on characters, which can have varying widths depending on the character set being used. For example,
o ASCII and ISO Latin-1 use one byte characters.
o Unicode uses two byte characters.
o UTF-8 uses characters of varying width between one and three bytes.
• Readers and writers know how to handle all these character sets and many more seamlessly.
The java.io.Reader class
• The methods of the java.io.Reader class are deliberately similar to the methods of the java.io.InputStream class.
• However rather than working with bytes, they work with chars.
• Methods
o public int read() throws IOException
o public int read(char[] text) throws IOException
o public abstract int read(char[] text, int offset, int length) throws IOException
o public long skip(long n) throws IOException
o public boolean markSupported()
o public void mark(int readAheadLimit) throws IOException
o public void reset() throws IOException
o public abstract void close() throws IOException
o public boolean ready() throws IOException
• The ready() method returns true if the Reader is ready to be read from, false if it isn't. Generally this means the underlying stream has available data.
The java.io.Writer class
• The methods of the java.io.Writer class are deliberately similar to the methods of the java.io.OutputStream class.
• However rather than working with bytes, they work with chars.
• Methods
o public void write(int c) throws IOException
o public void write(char[] text) throws IOException
o public abstract void write(char[] text, int offset, int length) throws IOException
o public void write(String s) throws IOException
o public void write(String s, int offset, int length) throws IOException
o public abstract void flush() throws IOException
o public abstract void close() throws IOException
The InputStreamReader Class
• The java.io.InputStreamReader class serves as a bridge between byte streams and character streams
• It reads bytes from the input stream and translates them into characters according to a specified character encoding.
• The encoding can be set in the constructor, or you can accept the platform's default encoding.
o public InputStreamReader(InputStream in)
o public InputStreamReader(InputStream in, String encoding) throws UnsupportedEncodingException
• For example, to attach an InputStreamReader to System.in with the default encoding:
o InputStreamReader isr = new InputStreamReader(System.in);
• On the other hand if you wanted to read a file that had been encoded using UTF-8, you might do this:
o FileInputStream fis = new FileInputStream("file.utf8.txt");
o InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
• Methods
o public String getEncoding(): The getEncoding() method returns a string containing the name of the encoding used by this reader.
o public int read() throws IOException
o public int read(char[] text, int offset, int length) throws IOException
o public boolean ready() throws IOException
o public void close() throws IOException
The OutputStreamWriter Class
• The java.io.OutputStreamWriter class connects byte streams and character streams
• It writes bytes onto the underlying output stream after translating characters according to a specified character encoding.
• The encoding can be set in the constructor, or you can accept the platform's default encoding.
o public OutputStreamWriter(OutputStream out, String enc) throws UnsupportedEncodingException
o public OutputStreamWriter(OutputStream out)
• For example, to attach an OutputStreamWriter to System.out with the default encoding:
o OutputStreamWriter osw = new OutputStreamWriter(System.out);
• On the other hand if you wanted to write a file encoded in UTF-16, you might do this:
o FileOutputStream fos = new FileOutputStream("file.utf16.txt");
o OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-16");
• Methods:
o public String getEncoding():The getEncoding() method returns a string containing the name of the encoding used by this writer.
o public void write(int c) throws IOException
o public void write(char[] text, int offset, int length) throws IOException
o public void write(String s, int offset, int length) throws IOException
o public void flush() throws IOException
o public void close() throws IOException
Reading Files
• The FileReader class reads text files using the platform's default character encoding and the buffer size.
• If you need to change these values, construct an InputStreamReader on a FileInputStream instead.
• Constructors
o public FileReader(String fileName) throws FileNotFoundException
o public FileReader(File file) throws FileNotFoundException
o public FileReader(FileDescriptor fd)
• Eg: FileReader fr = new FileReader("36.html");
Writing Text Files
• The java.io.FileWriter class writes text files using the platform's default character encoding and the buffer size.
• If you need to change these values, construct an OutputStreamReader on a FileOutputStream instead.
• Constructors
o public FileWriter(String fileName) throws IOException
o public FileWriter(String fileName, boolean append) throws IOException
o public FileWriter(File file) throws IOException
o public FileWriter(FileDescriptor fd)
Buffering Reads for Better Performance
• The java.io.BufferedReader class is a subclass of java.io.Reader that you chain to another Reader class to buffer characters.
• This allows more efficient reading of characters and lines.
• The BufferedReader is also notable for its readLine() method that allows you to read text a line at a time.
• There are two constructors, one with a default buffer size of 8192 characters:
o public BufferedReader(Reader in, int size)
o public BufferedReader(Reader in)
• The one new method in this class is readLine().
o public String readLine() throws IOException
• This method returns a String that contains a line of text from a text file. \r, \n, and \r\n are assumed to be line breaks and are not included in the returned String.
• The following example reads a text file, line by line, and prints it to System.out:
// Implement the Unix cat utility in Java
import java.io.*;
class Cat {
public static void main (String args[]) {
String thisLine;
//Loop across the arguments
for (int i=0; i < args.length; i++) {
//Open the file for reading
try {
BufferedReader br = new BufferedReader(new FileReader(args[i]));
while ((thisLine = br.readLine()) != null) {
System.out.println(thisLine);
} // end while
} // end try
catch (IOException ex) {
System.err.println("Error: " + ex.getMessage());
}
} // end for
} // end main
}
Buffering Writes for Better Performance
• The java.io.BufferedWriter class is a subclass of java.io.Writer that you chain to another Writer class to buffer characters.
• This allows more efficient writing of text.
• There are two constructors, one with a default buffer size of 8192 characters:
o public BufferedWriter(Writer out)
o public BufferedWriter(Writer out, int size)
• The one new method in this class is newLine(). This method that writes a platform dependent line terminator string, \n on Unix, \r on the Mac, \r\n on Windows.
o public String newLine() throws IOException
Serialization
• Serialization is the process of writing the state of an object to a byte stream
• Needed to implement RMI (Remote Method Invocation) where a Java Object on one machine is used to invoke a method of a Java object on a different machine
• Serialization can be perform on only those objects which implement Serializable interface
• This interface doesn’t define members but rather indicate that a class may be serialized
• Static variable and Transient variable are not saved when the serialized objects are saved
• Streams used to read and write objects are ObjectOutputStream and ObjectInputStream
• Constructor of ObjectOutputStream:
o public ObjectOutputStream(OutputStream out) throws IOException
• Major methods of ObjectOutputStream:
o void writeObject(Object obj)
• Constructor of ObjectInputStream:
o public ObjectInputStream (InputStream in) throws IOException
• Major methods of ObjectInputStream:
o Object readObject(Object obj)
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related download
- dwarf debugging information format
- notes on file handling in java
- introduction unicode
- how to write an open diameter client or server application
- 219241 programming assignment 1 kasetsart university
- java sequenceinputstream class weebly
- garnet pager applicaiton design specification
- chapter 9 files and security seton hall university
- ifs internationalization support
Related searches
- notes on strategic marketing
- notes on strategic management
- notes on principle of management
- us history notes on powerpoint
- notes on photosynthesis
- notes on statistics
- notes on economics free pdf
- file hash for java jre downloads
- notes on digital marketing
- notes on books chapter summaries
- notes on financial management
- notes on algebra 1