I/O Fundamentals in JAVA 3

Node Stream:-

In the java JDK, there are three fundamental types of nodes,

• Files
• Memory (such a arrays or String objects)
• Pipes (a channel from one process or thread [a light-weight process] to another; the output pipe stream of one thread is attached to the input pipe stream of another thread)

It is possible to create new node stream classes, but it requires handling native function calls to device driver, and this is non portable.

Below shows the node streams:

Type	Character Streams	Byte Streams
File	FileReader	FileInputStream
	FileWriter	FileOutputStream
Memory Array	CharArrayReader	ByteArrayInputStream
	CharArrayWriter	ByteArrayOutputStream
Memory String	StringReader	N/A
	StringWriter
Pipe	PipedReader	PipedInputStream
	PipedWriter	PipedOutputStream

A simple Example:-

• The code given below reads character from a file named by the first command line argument and writes the character out to a file named by the second command line argument.
• Thus, it copies the file. This is how the program might be invoked:

 

1. import java.io.*;
3. public class TestNodeStreams
4. {
6. public static void main(String args[])
7. {
8. try{
9. FileReader input = new FileReader(args[0]);
10. try{
11. FileWritere output = new FileWriter(args[1]);
12. try{
13. chat[] buffer = new char[128];
14. int charsRead;
16. // read the first buffer
17. charsRead = input.read(buffer);
18. while(chars!=-1)
20. // write buffer to the output file
21. Output.write(buffer,0,charsRead);
23. // read the next buffer
24. charsRead = input.read(buffer);
25. }finally
26. {
27. output.close();
28. }
29. }finally{
30. input.close();
31. }
32. }catch(IOException e)
33. {
34. e.printStackTrace();
35. }
36. }
37. }

• As easy as this was, handling the buffer is tedious and error prone. It turns out that there are classes that handle the buffering for you and present you with the capability to read a stream a line at a time.
• It is called a BufferedReader and is a type of a stream called a processing stream.

Buffered Stream:-

The code given below performs the same function as the program in above code but uses BufferedReader and BufferedWriter.

1. import java.io.*;
3. public class TestBufferedStreams
4. {
6. public static void main(String args[])
7. {
8. try{
9. FileReader input = new FileReader(args[0]);
10. BufferedReader bufInput = new BufferedReader(input);
11. try{
12. FileWritere output = new FileWriter(args[1]);
13. BufferedWriter bufOutput = new BufferedWriter(Output);
14. try{
15. String line;
16. // read the first line
17. line = bufInput.readLine();
18. while(line!=null)
19. // write the line out to the output file
20. bufOutput.write(line,0,line.length());
21. bufOutput.readLine();
22. // read the next line
23. line = bufInput.readLine();
24. }finally
25. {
26. bufOutput.close();
27. }
28. }finally{
29. bufInput.close();
30. }
31. }catch(IOException e)
32. {
33. e.printStackTrace();
34. }
35. }
36. }

• The flow of this program is the same as before. Instead of reading a buffer, this program reads a line at a time using the line variable to hold the String returned by the readLine method (Line 18 and Line 24), which provides greater efficiency.
• Line 11 chains the file reader object within a buffered reader stream. You manipulate the outer most stream in the chain (bufInput), which manipulates the inner most stream (input).

For more reading about technology news in singapore or from all over the world in all aspect from seo to online marketing do view more about other pages.