Transcript of Understanding java streams
- Understand the stream Know the difference between byte and
character streams Know Javas byte stream classes Know Javas
character stream classes Know the predefined streams Use byte
streams Use byte streams for file I/O Read and write binary data
Use character streams Use character streams for file I/O Object
Serialization Object Deserialization
- A stream is an abstract representation of an input or output
device that is a source of,or destination for, data. You can write
data to a stream and read data from a stream.You can visualize a
stream as a sequence of bytes that flows into or out of
yourprogramJava programs perform I/O through streams.A stream is an
abstraction that either produces or consumes information. A stream
is linked to a physical device by the Java I/O system.All streams
behave in the same manner, even if the actual physical devices they
arelinked to differ.Thus, the same I/O classes and methods can be
applied to any type of device.For example, the same methods that
you use to write to the console can also be usedto write to a disk
file. Java implements streams within class hierarchies defined in
thejava.io package.
- Modern versions of Java define two types of Streams: byte
andcharacter.Byte streams provide a convenient means for handling
input andoutput of bytes.Byte streams are used, for example, when
reading or writingbinary data. They are especially helpful when
working with files.Character streams are designed for handling the
input andoutput of characters.Character streams use Unicode and,
therefore, can beinternationalized. Also, in some cases, character
streams are more efficient than byte streams.At the lowest level,
all I/O is still byte-oriented. The character-basedstreams simply
provide a convenient and efficient means for
handlingcharacters.
- Byte streams are defined by using two class hierarchies.At the
top of these are two abstract classes:InputStream and
OutputStream.InputStream defines the characteristics common to
byteinput streams and OutputStream describes the behavior ofbyte
output streams.From InputStream and OutputStream are created
severalconcrete subclasses that offer varying functionality
andhandle the details of reading and writing to various
devices,such as disk files.
- Character streams are defined by using two classhierarchies
topped by these two abstract classes: Reader and Writer.Reader is
used for input, and Writer is used foroutput.Concrete classes
derived from Reader and Writeroperate on Unicode character
streams.From Reader and Writer are derived severalconcrete
subclasses that handle various I/Osituations. In general, the
character-based classesparallel the byte-based classes.
- As you know, all Java programs automatically import
thejava.lang package. This package defines a class called
System,which encapsulates several aspects of the run-time
environment.Among other things, it contains three predefined stream
variables,called in, out, and err.These fields are declared as
public and static within System.This means that they can be used by
any other part of yourprogram and without reference to a specific
System object.System.out refers to the standard output stream. By
default,this is the console. System.in refers to standard input,
which isby default the keyboard.System.err refers to the standard
error stream, which is also theconsole by default. However, these
streams can be redirected toany compatible I/O device.
- BufferedInputStream InputStream BufferedOutputStream
ObjectInputStream ByteArrayInputStream ObjectOutputStream
ByteArrayOutputStream OutputStream DataInputStream PipedInputStream
DataOutputStream PipedOutputStream FileInputStream PrintStream
FileOutputStream PushbackInputStream FilterInputStream
RandomAccessFile FilterOutputStream SequenceInputStream
- BufferedReader LineNumberReader BufferedWriter
OutputStreamWriter CharArrayReader PipedReader CharArrayWriter
PipedWriter FileReader PrintWriter FileWriter PushbackReader
FilterReader Reader FilterWriter StringReader InputStreamReader
StringWriter
- import java.io.*;class ReadBytes { public static void
main(String args[]) throws Exception { byte data[] = new byte[10];
System.out.println("Enter some characters."); System.in.read(data);
System.out.print("You entered: "); for(int i=0; i < data.length;
i++) System.out.print((char) data[i]); } }
- class WriteDemo { public static void main(String args[]) { int
b; b = X; System.out.write(b); System.out.write(n); } }
- import java.io.*;class ShowFile { public static void
main(String args[]) throws IOException { int i; FileInputStream fin
= new FileInputStream(args[0]); do { i = fin.read(); if(i != -1)
System.out.print((char) i); } while(i != -1); fin.close(); } }
- import java.io.*;class CopyFile { public static void
main(String args[]) throws Exception { int i; FileInputStream fin =
new FileInputStream(args[0]); FileOutputStream fout = new
FileOutputStream(args[1]); do { i = fin.read(); if(i != -1)
fout.write(i); } while(i != -1); fin.close(); fout.close(); }}
- import java.io.*;class RWData { public static void main(String
args[]) throws Exception { DataOutputStream dataOut = new
DataOutputStream(newFileOutputStream("testdata")); int i = 10;
double d = 1023.56; boolean b = true; System.out.println("Writing "
+ i); dataOut.writeInt(i); System.out.println("Writing " + d);
dataOut.writeDouble(d); System.out.println("Writing " + b);
dataOut.writeBoolean(b); System.out.println("Writing " + 12.2 *
7.4); dataOut.writeDouble(12.2 * 7.4); dataOut.close();
System.out.println(); DataInputStream dataIn = new
DataInputStream(new FileInputStream("testdata")); i =
dataIn.readInt(); System.out.println("Reading " + i); d =
dataIn.readDouble(); System.out.println("Reading " + d); b =
dataIn.readBoolean(); System.out.println("Reading " + b); d =
dataIn.readDouble(); System.out.println("Reading " + d);
dataIn.close(); }}
- import java.io.*;class CompFiles { public static void
main(String args[])throws Exception { int i=0, j=0; FileInputStream
f1 = new FileInputStream(args[0]); FileInputStream f2 = new
FileInputStream(args[1]); do { i = f1.read(); j = f2.read(); if(i
!= j) break; } while(i != -1 && j != -1); if(i != j)
System.out.println("Files differ."); else System.out.println("Files
are the same."); f1.close(); f2.close(); }}
- import java.io.*;class ReadChars {public static void
main(String args[]) throws Exception {char c;BufferedReader br =
new BufferedReader( new
InputStreamReader(System.in));System.out.println("Enter characters,
period to quit.");do {c = (char) br.read();System.out.println(c);}
while(c != .);}}
- import java.io.*;Create BufferedReaderclass ReadLines {public
static void main(String args[]) Throws Exception {BufferedReader br
= new BufferedReader(new InputStreamReader(System.in));String
str;System.out.println("Enter lines of
text.");System.out.println("Enter stop to quit.");do {str =
br.readLine();System.out.println(str);}
while(!str.equals("stop"));}}
- import java.io.*;public class PrintWriterDemo {public static
void main(String args[]) {PrintWriter pw = new
PrintWriter(System.out, true);int i = 10;double d =
123.65;pw.println("Using a
PrintWriter.");pw.println(i);pw.println(d);pw.println(i + " + " + d
+ " is " + (i+d));}}
- import java.io.*;class KtoD {public static void main(String
args[]) throws Exception {String str;FileWriter fw = new
FileWriter("test.txt");BufferedReader br = new BufferedReader( new
InputStreamReader(System.in));System.out.println("Enter text (stop
to quit).");do {System.out.print(": "); str =
br.readLine();if(str.compareTo("stop") == 0) break;str = str +
"rn"; // add newlinefw.write(str);} while(str.compareTo("stop") !=
0);fw.close();}}
- import java.io.*;class DtoS {public static void main(String
args[]) throws Exception {FileReader fr = new
FileReader("test.txt");BufferedReader br = new
BufferedReader(fr);String s;while((s = br.readLine()) != null)
{System.out.println(s);}fr.close();}}
- class MyClass implements Serializable { double id; String name;
String course; public MyClass(double i, String n, String c) { id=i;
name=n;course=c; } public String toString() { return ID: " + id +
nNAME: " + name + nCOURSE: "+ course; }}
- import java.io.*; public class SerializationDemo { public
static void main(String args[]) throws Exception{// Object
serialization MyClass object1 = new MyClass(2342, Shahjahan, Java);
System.out.println("object1: " + object1);FileOutputStream fos =
new FileOutputStream("serial");ObjectOutputStream oos = new
ObjectOutputStream(fos);oos.writeObject(object1);oos.flush();oos.close();}
- // Object deserializationMyClass object2;FileInputStream fis =
new FileInputStream("serial");ObjectInputStream ois = new
ObjectInputStream(fis);object2 =
(MyClass)ois.readObject();ois.close();System.out.println("object2:
" + object2);}}
- import java.util.zip.*;import java.io.*;public class
GZIPcompress {public static void main(String[] args)throws
IOException {BufferedReader in = new BufferedReader( new
FileReader(args[0]));BufferedOutputStream out = new
BufferedOutputStream( new GZIPOutputStream(new
FileOutputStream("test.gz")));int c; while((c = in.read()) != -1)
out.write(c);in.close(); out.close();BufferedReader in2 = new
BufferedReader( new InputStreamReader(new GZIPInputStream( new
FileInputStream("test.gz"))));String s; while((s = in2.readLine())
!= null) System.out.println(s);}}