The most troublesome problem in byte input stream is that when using read() method to read, only byte array can be received.

Note that a new method has been added to InputStream class since JDK 1.9: public byte[] readAllBytes() throws IOException;

 1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.InputStream;
 4 public class JavaAPIDemo {
 5     public static void main(String[] args) throws Exception {
 6         File file = new File("D:" + File.separator + "hello" + File.separator + "mldn.txt");
 7         InputStream input = new FileInputStream(file) ;
 8         byte data [] = input.readAllBytes() ; // Read all data
 9         System.out.println("[" + new String(data) + "]");
10         input.close();
11     }
12 }

If the content to be read is very large now, this kind of reading will directly crash the program. If you want to use it, try not to exceed 10KB.

3. Character output stream: Writer

When OutputStream byte output stream is used for data output, byte type data is used. In many cases, string output is more convenient. So for java.io package, character output stream is introduced in JDK 1.1: Writer. The definition of this class is as follows:

public abstract class Writer  extends Object implements Appendable, Closeable, Flushable

There are many output operation methods provided in the Writer class, focusing on two aspects:

Output character array: public void write (char[] cbuf) throws IOException;

Output string: public void write (String str) throws IOException;

Example: using Writer output

 1 import java.io.File;
 2 import java.io.FileWriter;
 3 import java.io.Writer;
 4 public class JavaAPIDemo {
 5     public static void main(String[] args) throws Exception {
 6         File file = new File("D:" + File.separator + "hello" + File.separator + "mldn.txt");
 7         if (!file.getParentFile().exists()) {
 8             file.getParentFile().mkdirs(); // Parent directory must exist
 9         }
10         Writer out = new FileWriter(file) ; 
11         String str = "www.mldn.cn" ;
12         out.write(str); 
13         out.close();
14     }
15 }

JavaAPIDemo

The biggest advantage of using writer output is that it can be done directly with strings. Writer is a character stream. The advantage of character processing lies in Chinese data.  

4. Character input stream: Reader

Reader is a type of character input stream. It belongs to an abstract class. The definition of this class is as follows:

public abstract class Reader extends Object implements Readable, Closeable

The Reader class does not provide the input processing operation with the whole string like the Writer class. Only character data can be used to receive:

Receive data: public int read (char[] cbuf) throws IOException;

Example: data reading

 1 import java.io.File;
 2 import java.io.FileReader;
 3 import java.io.Reader;
 4 public class JavaAPIDemo {
 5     public static void main(String[] args) throws Exception {
 6         File file = new File("D:" + File.separator + "hello" + File.separator + "mldn.txt");
 7         if (file.exists()) {    // Read if file exists
 8             Reader in = new FileReader(file) ;
 9             char data[] = new char[1024];
10             int len = in.read(data) ;
11             System.out.println("Read content:" + new String(data,0,len));
12             in.close();
13         }
14     }
15 }

When the character stream is read, the processing operation can only be implemented in the form of an array.

5. Difference between byte stream and character stream

Now through a series of analysis, we can know the basic operation of byte stream and character stream. However, there are still differences between the two kinds of streams. We will focus on the analysis of the output processing operation. At the end of using OutputStream and Writer output, we found that the close() method was used for closing.

When using the OutputStream class output, if the close() method is not used to close the output stream, normal output can still be achieved. However, if the close() method is not used to close the output stream when using the Writer, then the content will not be able to output at this time, because the Writer uses the buffer, when the close() method is used, it will actually In case of forced buffer refresh, the content will be output at this time. If it is not closed, the output operation cannot be performed. Therefore, if you want to output all the content without closing, you can use the flush() method to force clear.  

Example: use Writer and force clear

 1 import java.io.File;
 2 import java.io.FileWriter;
 3 import java.io.Writer;
 4 public class JavaAPIDemo {
 5     public static void main(String[] args) throws Exception {
 6         File file = new File("D:" + File.separator + "hello" + File.separator + "mldn.txt");
 7         if (!file.getParentFile().exists()) {
 8             file.getParentFile().mkdirs(); // Parent directory must exist
 9         }
10         Writer out = new FileWriter(file) ; 
11         String str = "www.mldn.cn" ;
12         out.write(str); 
13         out.flush();  // Mandatory refresh
14     }
15 }

Question: can you change the code to make the difference between out.flush() and non-existent? See what's the difference between the two?

Note: the out stream in the above example cannot be closed, otherwise it will automatically flush() and it will not achieve the desired result

Byte streams do not use buffers when they are processed, but character streams use buffers. In addition, the character stream using buffer is more suitable for Chinese data processing, so in future program development, if it involves the output containing Chinese information, it will generally use character stream processing, but on the other hand, the basic processing form of byte stream and character stream is similar, because IO is used for data transmission in many cases (binary) so this lecture will focus on byte stream.

Topics: Java JDK