Performing input and output operations using a Byte Stream

Transcription

1 Performing input and output operations using a Byte Stream public interface DataInput The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the Java primitive types. There is also a facility for reconstructing a String from data in modified UTF-8 format. Modified UTF-8 Implementations of the DataInput and DataOutput interfaces represent Unicode strings in a format that is a slight modification of UTF-8. (For information regarding the standard UTF-8 format, see section 3.9 Unicode Encoding Forms of The Unicode Standard, Version 4.0). Note that in the following table, the most significant bit appears in the far left-hand column. All characters in the range '\u0001' to '\u007f' are represented by a single byte: Bit Values Byte 1 0 bits 6-0 The null character '\u0000' and characters in the range '\u0080' to '\u07ff' are represented by a pair of bytes: Bit Values Byte bits 10-6 Byte bits 5-0 char values in the range '\u0800' to '\uffff' are represented by three bytes: Bit Values Byte bits Byte bits 11-6 Byte bits 5-0 The differences between this format and the standard UTF-8 format are the following: The null byte '\u0000' is encoded in 2-byte format rather than 1-byte, so that the encoded strings never have embedded nulls. Data Streams Data streams support binary I/O of primitive data type values (boolean, char, byte, short, int, long, float, and 1

2 double) as well as String values. All data streams implement either the DataInput interface or the DataOutput interface. This section focuses on the most widely-used implementations of these interfaces, DataInputStream and DataOutputStream. The DataStreams example demonstrates data streams by writing out a set of data records, and then reading them in again. Each record consists of three values related to an item on an invoice, as shown in the following table: Order in Data Data Sample Output Method Input Method record type description Value 1 double Item price DataOutputStream.writeDouble DataInputStream.readDouble int Unit count DataOutputStream.writeInt DataInputStream.readInt 12 3 String Item description double price; 2 DataOutputStream.writeUTF DataInputStream.readUTF "Java T- Shirt" Let's examine crucial code in DataStreams. First, the program defines some constants containing the name of the data file and the data that will be written to it: static final String datafile = "invoicedata"; static final double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 ; static final int[] units = { 12, 8, 13, 29, 50 ; static final String[] descs = { "Java T-shirt", "Java Mug", "Duke Juggling Dolls", "Java Pin", "Java Key Chain" ; Then DataStreams opens an output stream. Since a DataOutputStream can only be created as a wrapper for an existing byte stream object, DataStreams provides a buffered file output byte stream. out = new DataOutputStream(new BufferedOutputStream( new FileOutputStream(dataFile))); DataStreams writes out the records and closes the output stream. for (int i = 0; i < prices.length; i ++) { out.writedouble(prices[i]); out.writeint(units[i]); out.writeutf(descs[i]); The writeutf method writes out String values in a modified form of UTF-8. This is a variable-width character encoding that only needs a single byte for common Western characters. Now DataStreams reads the data back in again. First it must provide an input stream, and variables to hold the input data. Like DataOutputStream, DataInputStream must be constructed as a wrapper for a byte stream. in = new DataInputStream(new BufferedInputStream(new FileInputStream(dataFile)));

3 int unit; String desc; double total = 0.0; Now DataStreams can read each record in the stream, reporting on the data it encounters. try { while (true) { price = in.readdouble(); unit = in.readint(); desc = in.readutf(); System.out.format("You ordered %d" + " units of %s at $%.2f%n", unit, desc, price); total += unit * price; catch (EOFException e) { Notice that DataStreams detects an end-of-file condition by catching EOFException, instead of testing for an invalid return value. All implementations of DataInput methods use EOFException instead of return values. Also notice that each specialized write in DataStreams is exactly matched by the corresponding specialized read. It is up to the programmer to make sure that output types and input types are matched in this way: The input stream consists of simple binary data, with nothing to indicate the type of individual values, or where they begin in the stream. DataStreams uses one very bad programming technique: it uses floating point numbers to represent monetary values. In general, floating point is bad for precise values. It's particularly bad for decimal fractions, because common values (such as 0.1) do not have a binary representation. The correct type to use for currency values is java.math.bigdecimal. Unfortunately, BigDecimal is an object type, so it won't work with data streams. However, BigDecimal will work with object streams, which are covered in the next section. Basic Streams in JAVA Java defines two types of streams. They are- Byte Streams :- These are the most basic type of Stream for input output operations and are used to process data byte by byte. Byte based streams generally end up calling by word Stream like InputStream and OutputStream and are used to process a raw Byte at a time. Some Exceptions are DataInputStream and DataOutputStream which are used to read and write Java standard datatypes like int, long, float and double. Character Streams :- These provide a convenient way for handling character inputs and output. These can be used for internationalization purpose as Character Streams uses UNICODE characters. These streams end up calling by a word Reader or Writer like InputStreamReader, FileReader, OutputStreamWriter, FileWriter etc. Data Streams are used to perform binary input output operations of all the primitive data types in Java including Strings i.e. if you want to perform i/o operations for boolean, char, byte, short, int, long, float, double or Strings then data streams provide a very convenient and an efficient way for that. This allows you to read-write Java primitives 3

4 instead of raw bytes. Data streams in java Interfaces Every Data Stream class implements either of the two interfaces- 1. DataInput 2. DataOutput Classes for these two Interfaces 1. DataInputStream It wraps an InputStream Object and let the application read the Java primitive data types from the wrapped input stream. This whole process of reading and converting into a primitive data is machine independent. User is responsible for making DataInputStream safe in multithreaded environment. DataOutputStream is used to write data which is used by DataInputStream to read later. 2. DataOutputStream It wraps an OutputStream Object and let the application write Java primitives to the wrapped output stream. DataInputStream is used to read back the data written by this data stream. Example Reading data from a file using DataInputStream package codingeekexamples; import java.io.*; public class DataInputStreamExample { 4 public static void main(string[] args) { double price; int quantity;

5 String item; try ( // create input stream. Same rules applies to file name again InputStream is = new FileInputStream("data.txt"); // create buffered input stream. you can skip this. BufferedInputStream bis = new BufferedInputStream(is); // create data input stream to read data in form of primitives. DataInputStream in = new DataInputStream(bis);) { System.out.println("Selected items are"); /** * Reading whole data from the file. Remember to read it in the same * order in which it was stored i.e. if integer is stored first then * readint() method should be invoked first otherwise unexpected * error or output will be there. */ while (in.available() > 0) { item = in.readutf(); quantity = in.readint(); price = in.readdouble(); System.out.format("%-20s %-10d $%.2f%n", item, quantity, price); catch (FileNotFoundException e) { e.printstacktrace(); catch (IOException e) { e.printstacktrace(); Output:- Selected items are keyboard 10 $15.43 mouse 23 $10.12 core java ebook 45 $50.80 ups 14 $ pen drive 2 $18.99 Note:- Each method of DataOutputStream is matched with corresponding method of DataInputStream. Be assure that you are using the corresponding method and in the correct order otherwise while reading data, output will be unexpected. Example readdouble() for writedouble( double ), readutf() for writeutf(string) etc. Note:- Since we generally use Buffered Streams for improving performance either we should us try with resources or we should close the stream or at least flush it in case of Output Stream otherwise we could lose the buffered data. Example Writing data to file using DataOutputStream package codingeekexamples; 5

6 import java.io.*; public class DataOutputStreamExample { static final double[] price = { 15.43, 10.12, 50.8, , ; static final int[] qty = { 10, 23, 45, 14, 2 ; static final String[] items = { "keyboard", "mouse", "core java ebook", "ups", "pen drive", ; public static void main(string[] args) { /** * Use try with resources or don't forget to close the stream( because * we use BufferedStream here). */ try ( // Create File output Stream. data.txt should be in classpath //or provide fully qualified path OutputStream os = new FileOutputStream("data.txt"); // Create Buffered stream. You can skip this step also BufferedOutputStream bos = new BufferedOutputStream(os); // create data output stream ) { DataOutputStream out = new DataOutputStream(bos) // stuffing item name, quantity, price one by one in output stream for (int i = 0; i < price.length; i++) { out.writeutf(items[i]); out.writeint(qty[i]); out.writedouble(price[i]); System.out.println("Data successfully written to a file"); catch (IOException e) { e.printstacktrace(); Output:- Data successfully written to a file 6

7 Byte Streams Programs use byte streams to perform input and output of 8-bit bytes. 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 and FileOutputStream. Other kinds of byte streams are used in much the same way; they differ mainly in the way they are constructed. Using Byte Streams 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. import java.io.fileinputstream; import java.io.fileoutputstream; import java.io.ioexception; public class CopyBytes { public static void main(string[] args) throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("xanadu.txt"); out = new FileOutputStream("outagain.txt"); int c; while ((c = in.read())!= -1) { out.write(c); finally { if (in!= null) { in.close(); if (out!= null) { out.close(); CopyBytes spends most of its time in a simple loop that reads the input stream and writes the output stream, one byte at a time, as shown in the following figure. 7

8 Simple byte stream input and output. Always Close Streams Closing a stream when it's no longer needed is very important so important that CopyBytes uses a finally block to guarantee that both streams will be closed even if an error occurs. This practice helps avoid serious resource leaks. One possible error is that CopyBytes was unable to open one or both files. When that happens, the stream variable corresponding to the file never changes from its initial null value. That's why CopyBytes makes sure that each stream variable contains an object reference before invoking close. When Not to Use Byte Streams CopyBytes seems like a normal program, but it actually represents a kind of low-level I/O that you should avoid. Since xanadu.txt contains character data, the best approach is to use character streams, as discussed in the next section. There are also streams for more complicated data types. Byte streams should only be used for the most primitive I/O. So why talk about byte streams? Because all other stream types are built on byte streams. 8

9 buffered approach In this data is processed(read/write) in the form of a byte or we can use buffered approach for more structured fast and convenient input output operations. public class ByteStreamsExample { public static void main(string[] args) throws IOException { try ( // Declaring and initializing both the Streams inside try so that there // is no need to close them. You can do this with many other classes but // make sure that they all implements the Closable Interface InputStream inputstream = new FileInputStream("input.jpg"); OutputStream outputstream = new FileOutputStream("output.jpg") ) { Integer c; //continue reading till the end of the file while ((c = inputstream.read())!= -1) { //writes to the output Stream outputstream.write(c); Note We should not use Byte Stream for the Streams that represent the character data i.e. for the input output operations of text data. It is because For example if the file uses UNICODE system of encoding than each character will be denoted by two Bytes but Byte Stream will treat them differently and you have to handle the case using some programming logic. Such Streams are known as Character Streams and we use specialized classes for this purpose, Example BufferedReader, InputStreamReader, FileReader etc. 9

10 10