{"id":604,"date":"2019-09-03T12:30:43","date_gmt":"2019-09-03T06:45:43","guid":{"rendered":"https:\/\/bcisnotes.com\/secondsemester\/?p=604"},"modified":"2020-01-10T14:14:09","modified_gmt":"2020-01-10T08:29:09","slug":"byte-and-character-streams","status":"publish","type":"post","link":"https:\/\/bcisnotes.com\/secondsemester\/object-oriented-programming\/byte-and-character-streams\/","title":{"rendered":"Byte and Character Streams || Java.IO || Bcis Notes"},"content":{"rendered":"

Byte and Character Streams<\/h2>\n

Byte and Character Streams are described below:-<\/p>\n

The java.io package contains nearly every class you might ever need to perform input and output (I\/O) in Java. All these streams represent an input source and an output destination. The stream in the java.io package supports many data such as primitives, object, localized characters, etc.<\/p>\n

Byte Streams<\/h2>\n

Programs use byte streams to perform input and output of 8-bit bytes<\/strong>. All byte stream classes are descended from InputStream and OutputStream. There are many byte stream classes. To demonstrate how byte streams work, we’ll focus on the file I\/O byte streams, FileInputStream<\/strong> and FileOutputStream<\/strong>. Other kinds of byte streams are used in much the same way; they differ mainly in the way they are constructed.<\/p>\n

Using Byte Streams<\/strong><\/p>\n

We’ll explore FileInputStream and FileOutputStream by examining an example program named CopyBytes, which uses byte streams to copy xanadu.txt, one byte at a time.<\/p>\n

import java.io.FileInputStream;
\nimport java.io.FileOutputStream;
\nimport java.io.IOException;
\npublic class CopyBytes {
\npublic static void main(String[] args) throws IOException {
\nFileInputStream in = null;
\nFileOutputStream out = null;
\ntry {
\nin = new FileInputStream(“xanadu.txt”);
\nout = new FileOutputStream(“outagain.txt”);
\nint c;
\nwhile ((c = in.read()) != -1) {
\nout.write(c);
\n}
\n} finally {
\nif (in != null) {
\nin.close();
\n}
\nif (out != null) {
\nout.close();
\n}
\n}
\n}
\n}<\/p>\n

Character Stream<\/h2>\n

Java Byte streams are used to perform input and output of 8-bit bytes<\/strong>, whereas Java Character streams are used to perform input and output for 16-bit<\/strong> Unicode. Though there are many classes related to character streams but the most frequently used classes are, FileReader<\/strong> and FileWriter<\/strong>. Though internally FileReader uses FileInputStream and FileWriter uses FileOutputStream but here the major difference is that FileReader reads two bytes at a time and FileWriter writes two bytes at a time.<\/p>\n

Java write file<\/strong><\/p>\n

Write Text Files
\nThe java.io.PrintWriter class provides methods to write to text files. Its constructor takes a file name as the parameter; it creates a new file, or truncate the existing file to zero sizes.
\npublic PrintWriter(String fileName) throws FileNotFoundException<\/p>\n

Example<\/strong><\/p>\n

import java.io.FileNotFoundException;
\nimport java.io.PrintWriter;
\npublic class WriteFile
\n{
\npublic static void main(String[] args)
\nthrows FileNotFoundException
\n{
\nPrintWriter out = new PrintWriter(“random.txt”);
\nint line = 1;
\nwhile (line <= 100)
\nout.println((line++) + “: ” + Math.random());
\nout.close();
\n}
\n}<\/p>\n

Java read file<\/strong><\/p>\n

The class java.io.File is an abstract representation of file and directory pathnames. Together with the java.util.Scanner class, we can read text files. The following code creates a Fileobject, and then passes it to a Scanner object.
\nScanner scan = new Scanner(new File(\u201ctest.txt\u201d));<\/p>\n

Example<\/strong><\/p>\n

import java.util.Scanner;
\nimport java.io.File;
\nimport java.io.FileNotFoundException;<\/p>\n

public class ReadFile
\n{
\npublic static void main(String[] args)
\n{
\nScanner scan;
\ntry
\n{
\nscan = new Scanner(new File(“test.txt”));
\n}
\ncatch (FileNotFoundException e)
\n{
\ne.printStackTrace();
\nreturn;
\n}<\/p>\n

int line = 1;
\nwhile (scan.hasNext())
\n{
\nString str = scan.nextLine();
\nSystem.out.println((line++) + “: ” + str);
\n}
\n}
\n}<\/p>\n

Java Data Input and Output Stream<\/strong><\/p>\n

Data Input Stream class:<\/strong>
\nThis is used for two purposes. They are reading the data from an input device like a keyboard and reading the data from a remote machine like a server.<\/p>\n

Data Output Stream class:<\/strong>
\nThis is used for displaying the data onto the console and also used for writing the data to a remote machine.<\/p>\n

 <\/p>\n

Difference Between Byte Stream and Character Stream in Java<\/h3>\n

Definition<\/strong>
\nByte Stream is a mechanism that performs input and output of 8-bit bytes while Character Stream is a mechanism in Java that performs input and output operations of 16-bit Unicode. Thus, this is the main difference between Byte Stream and Character Stream in Java.<\/p>\n

Functionality<\/strong>
\nAnother difference between Byte Stream and Character Stream in Java is that Byte Stream performs input and output operations of 8-bit bytes while Character stream performs input and output operations of 16-bit Unicode.<\/p>\n

Associated Classes<\/strong>
\nThe common classes for byte streaming in Java are FileInputStream and FileOutputStream. However, the common classes for Character streaming in Java are FileReader and FileWriter. Hence, this is another difference between Byte Stream and Character Stream in Java.<\/p>\n

Conclusion<\/strong>
\nA stream refers to a sequence of data. Two methods of performing operations on streams in Java are using Byte Stream and character stream. The main difference between Byte Stream and Character Stream in Java is that Byte Stream helps to perform input and output operations of 8-bit bytes while Character stream helps to perform input and output operations of 16-bit Unicode.<\/p>\n

You may also like inheritance<\/a><\/p>\n

<\/div>