Exercise: printing the contents of all files and subfolders

import java.io.File;
import java.io.IOException;


public class demo {

    public static void main(String[] args) throws IOException {
        File currentDir = new File(".");
        printAllFile(currentDir.getCanonicalFile());
    }

    static void printAllFile(File dir) {
        // Print the contents of all files and subfolders
        File[] files = dir.listFiles();
        if(files != null){
            for(File f : files){
                System.out.println(f.getName());
            }
        }
    }
}

InputStream/OutputStream

The java.io.InputStream/java.io.OutputStream of the Java standard library defines the superclasses of all input / output streams:

• FileInputStream implements file stream input, and FileOutputStream implements file stream output;

• ByteArrayInputStream simulates a byte stream input in memory,   ByteArrayOutputStream simulates a byte stream output in memory.

• In some cases, you need to manually call the flush() method of OutputStream to force the output buffer.

• Always use try(resource) to ensure proper shutdown.

InputStream is not an interface, but an abstract class, which is the superclass of all input streams. One of the most important methods defined by this abstract class is int read(). The signature is as follows:

public abstract int read() throws IOException;

Try... Finally is required to ensure that InputStream can be shut down correctly no matter whether IO error occurs:

public void readFile() throws IOException {
    InputStream input = null;
    try {
         // Define a 1000 byte buffer:
        byte[] buffer = new byte[1000];
        int n;
        while ((n = input.read(buffer)) != -1) { // Read buffer
            System.out.println("read " + n + " bytes.");
        }
    } finally {
        if (input != null) { input.close(); }
    }
}

Writing the above code with try... Finally will feel more complex. A better way is to use the new try(resource) syntax introduced by Java 7. You only need to write a try statement to let the compiler automatically close the resources for us. The recommended wording is as follows:

public void readFile() throws IOException {
    try (InputStream input = new FileInputStream("src/readme.txt")) {
         // Define a 1000 byte buffer:
        byte[] buffer = new byte[1000];
        int n;
        while ((n = input.read(buffer)) != -1) { // Read buffer
            System.out.println("read " + n + " bytes.");
        }
    } // Here the compiler automatically writes finally for us and calls close()
}

In fact, the compiler does not specifically add auto shutdown for InputStream. The compiler only depends on whether the object in try(resource =...) implements the java.lang.autoclosable interface. If so, it will automatically add a finally statement and call the close() method. Both InputStream and OutputStream implement this interface, so they can be used in try(resource)

When the read() method of InputStream is called to read data, the read() method is blocked

int n;
n = input.read(); // You must wait for the read() method to return before executing the next line of code
int m = n;

Filter pattern (a small number of class implementation function combinations)

When we need to add various functions to a "basic" InputStream, we first determine the InputStream that can provide data source, because the data we need always comes from somewhere, for example, FileInputStream, and the data comes from files:

InputStream file = new FileInputStream("test.gz");

Next, we hope that FileInputStream can provide buffering function to improve reading efficiency. Therefore, we wrap this InputStream with BufferedInputStream. The obtained packaging type is BufferedInputStream, but it is still regarded as an InputStream:

InputStream buffered = new BufferedInputStream(file);

Finally, assuming that the file has been compressed with gzip, we want to directly read the extracted content, and then we can package a GZIPInputStream:

InputStream gzip = new GZIPInputStream(buffered);

No matter how many times we wrap, the object we get is always InputStream. We can reference it directly with InputStream and read it normally:

┌─────────────────────────┐
│GZIPInputStream          │
│┌───────────────────────┐│
││BufferedFileInputStream││
││┌─────────────────────┐││
│││   FileInputStream   │││
││└─────────────────────┘││
│└───────────────────────┘│
└─────────────────────────┘

The above mode of superimposing various "additional" functional components through a "basic" component is called Filter mode (or Decorator mode). It allows us to realize the combination of various functions through a small number of classes:

                 ┌─────────────┐
                 │ InputStream │
                 └─────────────┘
                       ▲ ▲
┌────────────────────┐ │ │ ┌─────────────────┐
│  FileInputStream   │─┤ └─│FilterInputStream│
└────────────────────┘ │   └─────────────────┘
┌────────────────────┐ │     ▲ ┌───────────────────┐
│ByteArrayInputStream│─┤     ├─│BufferedInputStream│
└────────────────────┘ │     │ └───────────────────┘
┌────────────────────┐ │     │ ┌───────────────────┐
│ ServletInputStream │─┘     ├─│  DataInputStream  │
└────────────────────┘       │ └───────────────────┘
                             │ ┌───────────────────┐
                             └─│CheckedInputStream │
                               └───────────────────┘