輸入輸出流。

InputStream與OutputStream 讀與寫

void readAndWriteWithIOStream(String inputFileName, String outputFileName) 
    throws IOException {
    File outputFile = new File(outputFileName);
    if (!outputFile.exists()) {
        outputFile.createNewFile();
    }

    InputStream inputStream = new FileInputStream(inputFileName);
    BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
    BufferedOutputStream bufferedOutputStream = 
        new BufferedOutputStream(new FileOutputStream(outputFile));

    int byteSize = 1024;
    int count = 0;
    byte[] bytes = new byte[byteSize];
    try {
        while ((count = bufferedInputStream.read(bytes)) > 0) {
            bufferedOutputStream.write(bytes, 0, count);
        }
    } finally {
        IOUtil.close(bufferedInputStream);
        IOUtil.close(bufferedOutputStream);
    }
}

使用InputStream讀取字節并轉為字符串

String readWithInputStream(String inputFileName)
     throws IOException {
    InputStream inputStream = new FileInputStream(inputFileName);
    BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
    int byteSize = 1024;
    int count = 0;
    byte[] bytes = new byte[byteSize];
    String line = null;
    StringBuilder stringBuilder = new StringBuilder();
    try {
        while ((count = bufferedInputStream.read(bytes)) > 0) {
            line = new String(bytes, 0, count, Charset.forName("UTF-8"));
            stringBuilder.append(line);
        }
    } finally {
        IOUtil.close(bufferedInputStream);
    }
    return stringBuilder.toString();
}

輸入流的復用

判斷是否支持復用：boolean InputStream#markSupported()
標記：InputStream#inputStream.mark(int)
重置：InputStream#inputStream.reset()

void read(InputStream inputStream) throws IOException {
    if (!inputStream.markSupported()) {
        //包裝
        inputStream = new BufferedInputStream(inputStream);
    }
    byte[] bytes = new byte[32];
    //標記
    inputStream.mark(0);
    //第一次讀
    inputStream.read(bytes);

    String s = new String(bytes, Charset.forName("utf8"));
    System.out.println(s);

    //重置
    inputStream.reset();
    //第二次讀
    inputStream.read(bytes);
    inputStream.close();

    s = new String(bytes, Charset.forName("utf8"));
    System.out.println(s);
}

//構造輸入流
InputStream getInputStream(String filePath) throws FileNotFoundException {
    return new FileInputStream(new File(filePath));
}

第一次讀和第二次讀，內容相同，內部維護一個數組，東西讀出來存在數組里面，之后就是操作數組了。

InputStream#mark(int readlimit)函數，標記當前位置，并保證在mark以后最多可以讀取readlimit字節數據，mark標記仍有效。如果在mark后讀取超過readlimit字節數據，mark標記就會失效。但是，判斷mark標記位是否仍有效的并不是只有readlimit一個參數，還有內部緩沖區的大小，public BufferedInputStream(InputStream in, int size)，默認緩沖區大小int DEFAULT_BUFFER_SIZE = 8192,8192字節，如果待讀取文件大于8192字節，還大于readlimit字節，再調用BufferedInputStream#reset()就會報java.io.IOException: Resetting to invalid mark。

看BufferedInputStream#read()中調用的fill()函數。

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos < 0)
        pos = 0;            /* no mark: throw away the buffer */
    else if (pos >= buffer.length)  /* no room left in buffer */
        if (markpos > 0) {  /* can throw away early part of the buffer */
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        } else if (buffer.length >= marklimit) {
            markpos = -1;   /* buffer got too big, invalidate mark */
            pos = 0;        /* drop buffer contents */
        }
        ...

readlimit是int型的，也就是說最多也只能保存 Integer.MAX_VALUE 個字節。緩沖區使用byte[]數組保存字節的，byte[]數組最大長度是 Integer.MAX_VALUE 個字節。

ObjectInputStream與ObjectOutputStream

用于對象的序列化：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    String fileName = "E:\\temp\\obj.txt";
    SerA serA = new SerA();
    serA.setName("pepelu");
    ObjectOutputStream objectOutputStream =
            new ObjectOutputStream(new FileOutputStream(fileName));
    objectOutputStream.writeObject(serA);

    ObjectInputStream objectInputStream = new ObjectInputStream(
            new FileInputStream(fileName));
    SerA sa = (SerA) objectInputStream.readObject();

    objectInputStream.close();
    objectOutputStream.close();
    
    System.out.println(sa.getName());
    System.out.println(serA == sa);
}

/* SerA.java */
public class SerA implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

output:

pepelu
false

這兩個對象并不是同一個對象，至少在堆上的地址不同。

BufferedReader讀取字符串

String readWithReader(InputStream inputStream) throws IOException {
    BufferedReader bufferedReader = new BufferedReader(
            new InputStreamReader(inputStream, Charset.forName("UTF-8")));
    String line = null;
    StringBuilder stringBuilder = new StringBuilder();
    try {
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line).append("\n");
        }
    } finally {
        IOUtil.close(bufferedReader);
    }
    return stringBuilder.toString();
}

BufferedWriter寫字符串

void writeWithBufferedWriter(String outputFileName) throws IOException {
    BufferedWriter bufferedWriter = new BufferedWriter(
            new OutputStreamWriter(new FileOutputStream(outputFileName)));
    try {
        bufferedWriter.write("hello,bitch");
    } finally {
        bufferedWriter.close();
    }
}

IOUtil關閉流

public static void close(Closeable closeable) {
    if (closeable == null) {
        return;
    }
    try {
        closeable.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}