5 character stream reading

Commonly used to process plain text data

5.1 Reader abstract class

Abstract class used to read character stream.

Common methods:
int read() reads a single character
int read(char[] cbuf) reads characters into an array
abstract int read(char[] cbuf, int off, int len) reads characters into a part of the array
int read(CharBuffer target) attempts to read characters into the specified character buffer
abstract void close() closes the stream and releases all resources associated with it

5.2 FileReader subclass

Convenient class for reading character files. The construction method of this class assumes that both the default character encoding and the default byte buffer size are appropriate. To specify these values yourself, you can first construct an InputStreamReader on the FileInputStream.

create object
FileReader(String fileName) creates a new FileReader given the filename from which the data is read
FileReader(File file) creates a new FileReader given the File from which to read data

5.3 BufferedReader subclass

Read the text from the character input stream and buffer each character, so as to realize the efficient reading of characters, arrays and lines.
You can specify the size of the buffer, or you can use the default size. In most cases, the default value is large enough.

create object
BufferedReader(Reader in) creates a buffered character input stream using the default size input buffer

5.4 exercise: character stream reading case

Create package: CN tedu. file
Create class: testin2 java

package cn.tedu.file;
import java.io.*;
/*This class is used to test the reading of character stream*/
public class TestIn2 {
    public static void main(String[] args) {
        //method();// Test normal character input stream
        method2();//Test efficient character input stream
    }
    //Create a method for testing efficient character input streams
    private static void method2() {
        //1. Define a local variable that takes effect in this method, and manually initialize the value null
        Reader in=null;
        try{
            //1. Create an efficient character reading stream object
            //in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
            in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
            //2. Using flow objects
            int b;
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //3. Close the flow object
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //Create a method to test the normal character input stream
    private static void method() {
        //1.1 create a local variable that takes effect in this method. Note that the initialization value is null
        Reader in = null;
        try {
            //1.2 when creating a character input stream object, note that exceptions need to be caught
            //Reader in = new Reader();// Error reason: the abstract parent cannot be instantiated
            //in = new FileReader(new File("E:\\ready\\1.txt"));
            in = new FileReader("E:\\ready\\1.txt");
            //2. Using flow objects
            //System.out.println(in.read());
            //Requirement: read all contents in the file circularly. As long as it is not - 1, there is still data. Continue reading
            //3.1 define variables and record the read data
            int b;
            while((b = in.read())!= -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {//3. Shut off
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

6-byte stream write out

6.1 OutputStream abstract class

This abstract class is a superclass that represents all classes of the output byte stream The output stream accepts the output bytes and sends them to a receiver

Common methods:
Void close() closes the output stream and frees all system resources associated with the stream
Void flush() flushes this output stream and forces all buffered output bytes to be written out
Void write (byte [] b) writes b.length bytes from the specified byte array to this output stream
Void write (byte [] B, int off, int len) writes len bytes from the offset off in the specified byte array to the output stream
Abstract void write(int b) writes the specified byte to this output stream

6.2 FileOutputStream subclass

Insert it directly into the file and write out the file data directly

Construction method (create object):
FileOutputStream(String name)
Creates a file output stream that writes data to a file with the specified name
FileOutStream(File file)
Creates a File output stream that writes data to the File represented by the specified File object
Fileoutstream (file, Boolean append) - if the second parameter is true, it means append and do not overwrite
Create a File output stream that writes data to the File represented by the specified File object. The following parameters refer to whether to overwrite the contents of the original File

6.3 BufferedOutputstream subclass

This class implements the buffered output stream. By setting this output stream, the application can write each byte to the underlying output stream without calling the underlying system every time for byte writing

Construction method (create object):
BufferedOutputStream(OutputStream out)
Create a new buffered output stream to write data to the specified underlying output stream

6.4 exercise: byte output stream test:

Create package: CN tedu. file
Create class: testout java

package cn.tedu.file;
import java.io.*;
/*This class is used to test byte output streams*/
public class TestOut {
    public static void main(String[] args) {
        method();//Used to test normal byte output stream
        //method2();// Used to test efficient byte output stream
    }
    //Create a method for testing efficient byte output streams
    private static void method2() {
        //1. Create a local variable that takes effect in this method. Pay attention to manual initialization
        OutputStream out = null;
        try{
            //2. Create efficient byte output stream object
//          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
            out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
            //3. Write out using stream object
            out.write(97);
            out.write(97);
            out.write(97);
        }catch (Exception e){
            e.printStackTrace();
        }finally {//The flow closing operation should be placed in finally {}
            try {
                //4. Shut off
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //Create a method to test the normal byte output stream
    private static void method() {
        //1. Create a local variable that takes effect in this method. Pay attention to manually initializing null
        OutputStream out = null;
        //2. Create a try catch finally structure because IO operations may generate exceptions
        try{
            //3. Create ordinary byte output stream object
            //out = new FileOutputStream(new File("E:\\ready\\2.txt"));
            //out = new FileOutputStream("E:\\ready\\2.txt");
            out = new FileOutputStream("E:\\ready\\2.txt",true);
            //4. Write out using stream object
            out.write(99);//Corresponding to a in ASCII code table
            out.write(99);//Corresponding to b in ASCII code table
            out.write(99);//Corresponding to c in ASCII code table
        }catch (Exception e){
            e.printStackTrace();
        }finally {//If you want the code to be executed, you need to write it in finally
            try {
                //5. Shut down operation
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

7 character stream write out

7.1 Writer abstract class

An abstract class that writes to a character stream

Common methods:
Abstract void close() closes the stream, but first refreshes it
Void write (char [] cbuf) writes to the character array
Void write(int c) writes a single character
Void write(String str) writes a string
Void write(String str,int off,int len) writes a part of a string
Abstract void write(char[] cbuf,int off,int len) writes to a part of the character array

7.2 FileWriter subclass

A convenience class for writing character files. The construction method of this class assumes that the default character encoding and default byte buffer size are acceptable If you need to customize these values yourself, you can first construct an OutputStreamWriter on FileOutputStream

Construction method (create object):
FileWriter(String filename)
Construct a FileWriter object according to the given file name
FileWriter(String filename,boolean append)
The FileWriter is constructed based on the given file name and a boolean value indicating whether to attach write data

7.3 BufferedWriter subclass

Writes text to the character output stream, buffering individual characters to provide efficient writing of individual characters, arrays, and strings You can specify the size of the buffer or accept the default size, which is large enough in most cases

Construction method (create object):
BufferedWriter(Writer out)
Create a buffered character output stream using the default size output buffer

7.4 exercise: character output stream test:

Create package: CN tedu. file
Create class: testout2 java

package cn.tedu.file;
import java.io.*;
/*This class is used to test character output streams*/
public class TestOut2 {
    public static void main(String[] args) {
        //method();// Output stream for testing normal characters
        method2();//Used to test efficient character output stream
    }
    //Create a method for testing efficient character output streams
    private static void method2() {
        //1. Create a local variable that takes effect in this method. The value is null. Pay attention to manual initialization!!!
        Writer out = null;
        //2. Because the program may throw exceptions, you need to write a try catch finally structure
        try{//Store code that may throw exceptions
            //3. Create ordinary character output stream object
            //out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
            //out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
            out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
            //4. Using flow objects
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
            out.write(100);
        }catch (Exception e){//Match and catch exceptions
            e.printStackTrace();//If an exception is caught, an error message is printed
        }finally {//The code block that must be executed is often used to close the flow
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //Create a method to test the normal character output stream
    private static void method() {
        //1. Create a local variable that takes effect in this method. The value is null. Pay attention to manual initialization!!!
        Writer out = null;
        //2. Because the program may throw exceptions, you need to write a try catch finally structure
        try{//Store code that may throw exceptions
            //3. Create ordinary character output stream object
            //out = new FileWriter(new File("E:\\ready\\2.txt"));
            //out = new FileWriter("E:\\ready\\2.txt");
            out = new FileWriter("E:\\ready\\2.txt",true);
            //4. Using flow objects
            out.write(98);
            out.write(98);
            out.write(98);
            out.write(98);
        }catch (Exception e){//Match and catch exceptions
            e.printStackTrace();//If an exception is caught, an error message is printed
        }finally {//The code block that must be executed is often used to close the flow
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

8 expansion

By learning the above streams, we can also expand and try to copy the following files:
Create package: CN tedu. file
Create class: testcopyfile java

package cn.tedu.file;
import java.io.*;
import java.util.Scanner;
/*This class is used to expand exercises and copy cases*/
public class TestCopyFile {
    public static void main(String[] args) {
        //1. Prompt and receive the source file path and target location path entered by the user
        System.out.println("Please enter the source file path:");
        String f = new Scanner(System.in).nextLine();//--Copy what
        System.out.println("Please enter the destination file path:");
        String t = new Scanner(System.in).nextLine();//--Copy to where
        //2. Call the method of copying files using character stream and pass in the two parameters just received
        //ZFCopy(f,t);
        //3. Call the method of copying files using byte stream and pass in the two parameters just received
        ZJCopy(f,t);
    }
    //Create a method to copy files using byte stream. Pay attention to two parameters
    private static void ZJCopy(String f, String t) {
        //1. Define local variables that take effect in the whole method. Pay attention to manual initialization, and the value is null
        InputStream in = null;
        OutputStream out = null;
        //2. Since the code may throw exceptions, you need to complete the try catch finally structure
        try{
            //3.1 create an efficient byte input stream, and the incoming parameter is the path of the target file
            in = new BufferedInputStream(new FileInputStream(f));
            //3.2 create an efficient byte output stream. The passed in parameter is the path to which the target file is copied
            out = new BufferedOutputStream(new FileOutputStream(t));
            //4. After you get the flow object, you can do specific business operations
            //4.1 define variables to record read data
            int b ;
            //4.2 use the loop to read the target file until the return value is - 1. When there is no data, the loop ends
            while((b = in.read())!=-1){//Read the contents of the source file
                out.write(b);//Write out the contents read in this cycle to the file in the specified location
            }
            System.out.println("Congratulations! File copied successfully!");
        }catch(Exception e){
            System.out.println("I'm sorry! File copy failed!");
            e.printStackTrace();
        }finally {//The code that must be executed needs to be put in finally, such as flow closing operation
            /*Closed flows are sequential: if there are multiple flows, the last created flow is closed first
             * Multiple related flow statements need their own try catch*/
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //Create a method to copy files using character streams. Note: copying requires two stream objects
    private static void ZFCopy(String f, String t) {
        //1. Define local variables that take effect in the whole method. Pay attention to manual initialization, and the value is null
        Reader in = null;
        Writer out = null;
        //2. Since the code may throw exceptions, you need to complete the try catch finally structure
        try{
            //3.1 create an efficient character input stream, and the passed in parameter is the path of the target file
            in = new BufferedReader(new FileReader(f));
            //3.2 create an efficient character output stream. The passed in parameter is the path to which the target file is copied
            out = new BufferedWriter(new FileWriter(t));
            //4. After you get the flow object, you can do specific business operations
            //4.1 define variables to record read data
            int b ;
            //4.2 use the loop to read the target file until the return value is - 1. When there is no data, the loop ends
            while((b = in.read())!=-1){//Read the contents of the source file
                out.write(b);//Write out the contents read in this cycle to the file in the specified location
            }
            System.out.println("Congratulations! File copied successfully!");
        }catch(Exception e){
            System.out.println("I'm sorry! File copy failed!");
            e.printStackTrace();
        }finally {//The code that must be executed needs to be put in finally, such as flow closing operation
            /*Closed flows are sequential: if there are multiple flows, the last created flow is closed first
            * Multiple related flow statements need their own try catch*/
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

9 summary: inheritance structure of IO

1. Mainstream classification

1. Classification by direction: input stream output stream (relative to the program, writing data from the program to the file is output)
2. Classified by transport type: byte stream character stream
3. Combination: byte input stream byte output stream character input stream character output stream

2. Learning methods: learn general methods in the abstract parent class and how to create objects in the child class
3. Byte input stream:

The InputStream abstract class cannot be new. It can be used as a superclass to learn the common methods it provides

--FileInputStream Subclass,Byte input stream of operation file,General class
--BufferedInputStream Subclass,Buffered byte input stream,General class

4. Character input stream

The Reader abstract class cannot be new. It can be used as a superclass to learn the common methods it provides

--FileReader,Subclass,Character input stream of operation file,General class
--BufferedReader,Subclass,Buffered character input stream,General class

5. Byte output stream:

The OutputStream abstract class cannot be new. It can be used as a superclass to learn the common methods it provides

--FileOutputStream Subclass,Byte output stream of operation file,General class
--BufferedOutputStream Subclass,Buffer byte output stream,General class

6. Character output stream

The Writer abstract class cannot be new. It can be used as a superclass to learn the common methods it provides

--FileWriter,Subclass,Character output stream of operation file,General class
--BufferedWriter,Subclass,Buffered character output stream,General class