Notes on File Handling in Java

whooshribbitΛογισμικό & κατασκευή λογ/κού

2 Δεκ 2013 (πριν από 3 χρόνια και 11 μήνες)

102 εμφανίσεις

Notes on File Handli
ng in Java


For BIM V Semester

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 lik
e 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 Contr
ol
-
D. On Windows, you type end
-
of
-
stream with
Control
-
Z.



Java 2 defines two types of Streams:

o

Byte Streams

o

Character Streams

Notes on File Handli
ng in Java


For BIM V Semester


The
Byte
Stream Classes



Most stream classes are part of the
java.io

package.



The two main classes
for handling byte streams of d
ata
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

Byte
ArrayOutputStream

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
Inpu
tStream
, 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

publ
ic 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)

Notes on File Handli
ng in Java


For BIM V Semester

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 excepti
ons.

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 ma
in(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();

Notes on File Handli
ng in Java


For BIM V Semester


}

}

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 t
hen 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() thro
ws 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.



T
hree methods support this:

o


public void mark(int readLimit)

o


public void reset() throws IOException

o


public boolean markSupported()

Notes on File Handli
ng in Java


For BIM V Semester

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
IOException
s.

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
IOException
s.



You
close a stream with the
close()

method:

public void close() throws IOException

The
Output
Stream 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 ar
e 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.

Notes on File Handli
ng in Java


For BIM V Semester



This buffering is at the nati
ve 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
IOException
s.



Sample Program illustrati
ng 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 fro
m 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

Notes on File Handli
ng in Java


For BIM V Semester



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 f
rom 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

}


Notes on File Handli
ng in Java


For BIM V Semester

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(byt
e[] 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 (IOExcep
tion 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++) {

Notes on File Handli
ng in Java


For BIM V Semester







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 tha
n 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

Notes on File Handli
ng in Java


For BIM V Semester




byte[] buffer = new byte[BUFFER_SIZE];




try {





while (true) {






int result = System.in.read(buffer);






if (resu
lt ==
-
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 (IOExcepti
on 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 su
bclasses 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

Notes on File Handli
ng in Java


For BIM V Semester

Filter Stream Classes

BufferedInputStream

and
BufferedOutputStream



Thes
e classes buffer reads and writes by reading data first into a buffe
r (an internal array of
bytes)



Thus an application can read bytes from the stream without necessarily calli
ng 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 prim
itive 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
Pri
ntStream
.


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



Subclas
ses 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.

Notes on File Handli
ng in Java


For BIM V Semester

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 t
he 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(Input
Stream 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 writeBy
te(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 f
inal 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

Notes on File Handli
ng in Java


For BIM V Semester

o

public final int size()

o

public vo
id 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 fina
l 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

publi
c 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 IOExcep
tion

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 cha
nge the default buffer size with the second constructor below:

Notes on File Handli
ng in Java


For BIM V Semester

o

public PushbackInputStream(InputStream in)

o

public PushbackInputStream(InputStream in, int size)

Notes on File Handli
ng in Java


For BIM V Semester

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 SecurityExceptio
n

o

p
ublic boolean canRead() throws SecurityException

o

public boolean isFile() throws SecurityException

o

public boolean isDirectory() throws SecurityException

o

pub
lic 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 SecurityExce
ption

o

public boolean delete() throws SecurityException

Notes on File Handli
ng in Java


For BIM V Semester

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.isFil
e()) {






System.out.println(f.getName() + " is a file.");





}





else if (f.isDirectory()) {






System.out.println(f.getName() + " is a directory.");





}





else {





System.out.println("Wh
at 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 {

Notes on File Handli
ng in Java


For BIM V Semester





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 st
andard 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.

Mak
e 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 mnemo
nic 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(),

Notes on File Handli
ng in Java


For BIM V Semester


"Ple
ase 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 D
ialogs



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
EOFException
s.

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.

Notes on File Handli
ng in Java


For BIM V Semester

Readers and Writers



The
java.io.Reader

and
java.io.Writer

classes are abstract superclas
ses for classes that read
and write character based data.



The subclasses are notable for handling the conversion between different character sets.



R
eaders and writers are based on characters, which can have varying widths depending on the
character set be
ing 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 seam
lessly.

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 IOExcep
tion

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 underl
ying 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

Notes on File Handli
ng in Java


For BIM V Semester

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 rea
ds 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 w
anted 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()

meth
od 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.

Notes on File Handli
ng in Java


For BIM V Semester



The enco
ding 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
OutputS
treamWriter

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.utf1
6.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

pu
blic 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 FileNotFoundExce
ption

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 enc
oding and
the buffer size.



If you need to change these values, construct an
OutputStreamReader

on a
FileOutputStream

instead.

Notes on File Handli
ng in Java


For BIM V Semester



Constructors

o

public FileWriter(String fileName) throws IOException

o

public FileWriter(String fileName, boolean append) throws IOE
xception

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 character
s.



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

publ
ic 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 ((t
hisLine = br.readLine()) != null) {






System.out.println(thisLine);





} // end while




} // end try

Notes on File Handli
ng in Java


For BIM V Semester




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 de
fault 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 M
ac,
\
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



Maj
or 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)