I/O複習(一)——Java I/O

File

特定文件

FileDemo.java：

import java.io.File;

public class FileDemo {
    static void p(String s) {
        System.out.println(s);
    }

    public static void main(String[] args) {
        File f1 = new File("./src/main/java/com/yangyun/javae/chapter20/FileDemo.java");
        // 文件名
        p("File Name:" + f1.getName());
        // 文件路徑
        p("Path:" + f1.getPath());
        // 絕對路徑
        p("Abs Path:" + f1.getAbsolutePath());
        // 父級
        p("Parent:" + f1.getParent());
        // 文件是否存在
        p(f1.exists() ? "exists" : "does not exist");
        // 文件是否可寫
        p(f1.canWrite() ? "is writeable" : "is not writeable");
        // 文件是否可讀
        p(f1.canRead() ? "is readable" : "is not readable");
        // 是文件還是文件夾
        p("is " + (f1.isDirectory() ? " a directory" : "not a directory"));
        // 是否是常規文件，設備驅動和命名管道返回false
        p(f1.isFile() ? "is normal file" : "might be a named pipe");
        // 文件是否具有絕對路徑
        p(f1.isAbsolute() ? "is absolute" : "is not absolute");
        // 文件上次修改時間
        p("File last modified:" + f1.lastModified());
        // 文件大小
        p("File size:" + f1.length() + " Bytes");
    }
}

一個目錄下的一組文件的名稱

DirList.java：

import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
import java.util.regex.Pattern;


public class DirList {
    /**
     * 傳向filter()的參數必須是final的。這在匿名內部類中是必須的，這樣才能使用來自該類範圍之外的對象。
     * @param regex
     * @return
     */
    public static FilenameFilter filter(final String regex) {
        // 創建匿名內部類
        return new FilenameFilter() {
            private Pattern pattern = Pattern.compile(regex);
            @Override
            public boolean accept(File dir, String name) {
                return pattern.matcher(name).matches();
            }
        };
    }

    public static void main(String[] args) {
        // 獲取當前項目下的文件名稱
        File path = new File(".");
        String[] list;
        if (args.length == 0) {
            list = path.list();
        } else {
            list = path.list(filter(args[0]));
        }

        // 對結果進行排序
        Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);

        for (String dirItem : list) {
            System.out.println(dirItem);
        }
    }
}

DirListOnly.java：

import java.io.File;
import java.io.FilenameFilter;

class OnlyExt implements FilenameFilter {
    String ext;

    public OnlyExt(String ext) {
        this.ext = "." + ext;
    }

    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(ext);
    }
}

public class DirListOnly {
    public static void main(String[] args) {
        String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javaee/chapte1";
        File f1 = new File(dirname);
        FilenameFilter only = new OnlyExt("java");
        String[] s = f1.list(only);
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
       
    }
}

創建目錄

MakeDirDemo.java：

import java.io.File;

public class MakeDirDemo {
    public static void main(String[] args) {
        String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/chapter40";
        File f1 = new File(dirname);
        if (f1.mkdir()) {
            System.out.println("mkdir success");
        } else {
            System.out.println("mkdir fail");
        }

    }
}

MakeDirsDemo.java：

import java.io.File;

public class MakeDirsDemo {
    public static void main(String[] args) {
        String dirname = "/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/yy/chapter40";
        File f1 = new File(dirname);
        if (f1.mkdirs()) {
            System.out.println("mkdirs success");
        } else {
            System.out.println("mkdirs fail");
        }

    }
}

字節流

InputStream（輸入流）

表1-1 InputStream類型

類	功能	構造器/如何使用
ByteArrayInputStream	允許將內存的緩衝區當作InputStream使用	緩衝區，字節將從中取出 作爲一種數據源：將其與FilterInputStream 對象相連使用以提供有用的接口
FileInputStream	用於從文件中讀取信息	字符串，表示文件名、文件或FileDescriptor對象作爲一種數據源：將其與FilterInputStream對象相連以提供有用的接口
SequenceInputStream	將兩個或多個InputStream 對象轉換成單一InputStream	兩個InputStream對象或一個容納InputStream對象的容器Enumeration 作爲一種數據源：將其與FilterInputStream對象相連以提供有用的接口
PipedInputStream	產生用於寫入相關PipedOutputStream 的數據。實現“管道化”概念	PipedOutputStream作爲多線程中數據源：將其與FilterInputStream對象相連以提供有用的接口
FilterInputStream	抽象類，作爲裝飾器的接口，其中，裝飾器爲其他的InputStream類提供有用的功能	見表1-3

ByteArrayInputStrea

ByteArrayInputStreamDemo.java：

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamDemo {
    public static void main(String[] args) {
        String tmp = "abcdefghijklmnopqrstuvwzyz";
        byte[] b = tmp.getBytes();

        ByteArrayInputStream input1 = new ByteArrayInputStream(b);
        ByteArrayInputStream input2 = new ByteArrayInputStream(b, 0, 3);
    }
}

ByteArrayInputStreamReset.java：

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamReset {
    public static void main(String[] args) {
        String tmp = "abcdefg";
        byte[] b = tmp.getBytes();
        ByteArrayInputStream in = new ByteArrayInputStream(b);

        for (int i = 0; i < 2; i++) {
            int c;

            while ((c = in.read()) != -1) {
                if (i == 0) {
                    char val = (char) c;
                    System.out.print(val);
                    if (val == 'a') {
                        // 設置流中當前標記的位置
                        in.mark(1);
                    }
                } else {
                    System.out.print(Character.toUpperCase((char) c));
                }
            }
            System.out.println();
            // 如果沒有調用mark( )方法，reset( )方法會將指針設置爲流的開頭，否則回到上次mark( )的地方
            in.reset();
        }
    }
}

FileInputStream

FileInputStreamDemo.java：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo {
    public static void main(String[] args) {
        int size;
        try (FileInputStream f = new FileInputStream("./src/main/java/com/yangyun/javae/chapter20/FileInputStreamDemo.java")) {
            System.out.println("Total Available Bytes:" + (size = f.available()));
            int n = size / 40;
            System.out.println("First " + n + " bytes of the file one read() at a time");
            for (int i = 0; i < n; i++) {
                System.out.print((char) f.read());
            }
            System.out.println("\nStill Available:" + f.available());
            System.out.println("------------------------------------");


            System.out.println("Reading the next " + n + " with one read(b[])");
            byte[] b = new byte[n];
            if (f.read(b) != n) {
                System.err.println("couldn't read " + n + " bytes.");
            }
            System.out.println(new String(b, 0, n));
            System.out.println("\nStill Available:" + (size = f.available()));
            System.out.println("Skipping half of remaining bytes with skip()");
            f.skip(size / 2);
            System.out.println("Still Available:" + f.available());
            System.out.println("------------------------------------");


            System.out.println("Reading " + n / 2 + " into the end of array");
            // 返回成功讀取的字節數
            if (f.read(b, n / 2, n / 2) != n / 2) {
                System.out.println("couldn't read " + n / 2 + " bytes.");
            }
            System.out.println(new String(b, 0, b.length));
            System.out.println("\nStill Available:" + f.available());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedInputStream

BufferInputStreamDemo.java：

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        String s = "This is a © copyright symbol but this is &copy not.\n";
        byte[] buf = s.getBytes();
        ByteArrayInputStream in = new ByteArrayInputStream(buf);

        int c;
        boolean marked = false;

        try (BufferedInputStream f = new BufferedInputStream(in)) {
            while ((c = f.read()) != -1) {
                switch (c) {
                    case '&':
                        if (!marked) {
                            f.mark(32);
                            marked = true;
                        } else {
                            marked = false;
                        }
                        break;
                    case ';':
                        if (marked) {
                            marked = false;
                            System.out.print("(c)");
                        } else {
                            System.out.print((char) c);
                        }
                        break;
                    case ' ':
                        if (marked) {
                            marked = false;
                            f.reset();
                            System.out.print("&");
                        } else {
                            System.out.print((char) c);
                        }
                        break;
                    default:
                        if (!marked) {
                            System.out.print((char) c);
                        }
                        break;
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

SequenceInputStream

SequenceInputStreamDemo.java：

import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Enumeration;
import java.util.Vector;

class InputStreamEnumerator implements Enumeration<FileInputStream> {

    private Enumeration<String> files;

    public InputStreamEnumerator(Vector<String> files) {
        this.files = files.elements();
    }

    @Override
    public boolean hasMoreElements() {
        return files.hasMoreElements();
    }

    @Override
    public FileInputStream nextElement() {
        try {
            return new FileInputStream(files.nextElement().toString());
        } catch (FileNotFoundException e) {
            return null;
        }
    }
}

public class SequenceInputStreamDemo {
    public static void main(String[] args) {
        int c;
        Vector<String> files = new Vector<>();
        files.addElement("file1.txt");
        files.addElement("file2.txt");
        files.addElement("file3.txt");
        InputStreamEnumerator ise = new InputStreamEnumerator(files);


        try (InputStream input = new SequenceInputStream(ise)) {
            while ((c = input.read()) != -1) {
                System.out.print((char) c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream（輸出流）

表1-2 OutputStream類型

類	功能	構造器/如何使用
ByteArrayOutputStream	在內存中創建緩衝區。所有送往流的數據都要放置在此緩衝區	緩衝區初始化尺寸（可選的）用於指定數據的目的地：將其與FilterOutputStream對象相連以提供有用的接口
FileOutputStream	用於將信息寫至文件	字符串，表示文件名、文件或FileDescriptor對象。指定數據的目的地：將其與FilterOutputStream對象相連以提供有用的接口
PipedOutputStream	任何寫入其中的信息都會自動作爲相關 PipedOutputStream的輸出。實現管道化概念。	PipedInputStream指定用於多線程的數據的目的地：將其與FilterOutputStream對象相連以提供有用的接口
FilterOutputStream	抽象類，作爲裝飾器的接口。其中，裝飾器爲其他OutputStream提供有用功能	見表1-4

ByteArrayOutputStream

ByteArrayOutputStreamDemo.java：

import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteArrayOutputStreamDemo {
    public static void main(String[] args) {
        ByteArrayOutputStream f = new ByteArrayOutputStream();
        String s = "This should end up in the array";
        byte[] buf = s.getBytes();

        try {
            f.write(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Buffer as a String");
        System.out.println(f.toString());
        System.out.println("Into array");
        byte[] b = f.toByteArray();
        for (int i = 0; i < b.length; i++) {
            System.out.print((char) b[i]);
        }
        System.out.println("\nTo an OutputStream()");

        try (FileOutputStream f2 = new FileOutputStream("test.txt")) {
            // 將f的內容寫入test.txt文件中
            f.writeTo(f2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Doing a reset");
        f.reset();
        for (int i = 0; i < 3; i++) {
            f.write('X');
        }
        System.out.println(f.toString());
    }
}

FileOutputStream

FileOutputStreamDemo.java：

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
    public static void main(String[] args) {
        String source = "Now is the time for all good men\n"
                + " to come to the aid of their country\n"
                + " and pay their due taxes.";

        byte[] buf = source.getBytes();

        try ( FileOutputStream f0 = new FileOutputStream("file1.txt");
              FileOutputStream f1 = new FileOutputStream("file2.txt");
              FileOutputStream f2 = new FileOutputStream("file3.txt")){

            // 寫第一個文件
            for (int i = 0; i < buf.length; i += 2) {
                f0.write(buf[i]);
            }

            // 寫第二個文件
            f1.write(buf);

            // 寫第三個文件
            f2.write(buf, buf.length - buf.length / 4, buf.length / 4);
        } catch(IOException e){
            System.out.println("An I/O Error Occurred");
        }
    }
}

FilterInputStream

表1-3 FilterInputStream類型

類	功能	構造器/如何使用
DataInputStream	與DataOutputStream搭配使用，因此我們 可以按照移植方式從流讀取基本數據類型	InputStream包含用於讀取基本類型數據的全部接口
BufferedInputStream	使用它可以防止每次讀取時都進行實際寫操作。代表“使用緩衝區”	InputStream,可以指定緩衝區大小；本質上不提供接口，只不過是向進程中添加緩衝區所必需的。與接口對象搭配
LineNumberInputStream	跟蹤輸入流中的行號；可調用getLineNumber()和setLineNumber(int)	IntputStream僅增加了行號，因此可能要與接口對象搭配使用
PushbackInputStream	具有“能彈出一個字節的緩衝區”。因此可以將讀到的最後一個字符回退	InputStream通常作爲編譯器的掃描器，之所以包含在內是因爲Java編譯器的需要，我們可能永遠不會用到

DataInputStream

DataIODemo.java：

import java.io.*;

public class DataIODemo {
    public static void main(String[] args) {
        // 寫數據
        try (DataOutputStream dout = new DataOutputStream(new FileOutputStream("Test.txt"))) {
            dout.writeDouble(98.6);
            dout.writeInt(1000);
            dout.writeBoolean(true);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (DataInputStream din = new DataInputStream(new FileInputStream("Test.txt"))) {
            double d = din.readDouble();
            int i = din.readInt();
            boolean b = din.readBoolean();
            System.out.println("Here are the values:" + d + " " + i + " " + b);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PushbackInputStream

PushInputStreamDemo.java：

import java.io.ByteArrayInputStream;
import java.io.PushbackInputStream;

public class PushInputStreamDemo {
    public static void main(String args[]) throws Exception {
        // 定義字符串
        String str = "www.baidu.com";
        // 定義回退流對象
        PushbackInputStream push = null;
        // 定義內存輸入流
        ByteArrayInputStream bai = null;
        // 實例化內存輸入流
        bai = new ByteArrayInputStream(str.getBytes());
        // 從內存中讀取數據
        push = new PushbackInputStream(bai);
        System.out.print("讀取之後的數據爲：");
        int temp = 0;
        // 讀取內容
        while ((temp = push.read()) != -1) {
            // 判斷是否讀取到了“.”
            if (temp == '.') {
                // 放回到緩衝區之中
                push.unread(temp);
                // 再讀一遍
                temp = push.read();
                System.out.print("（退回" + (char) temp + "）");
            } else {
                // 輸出內容
                System.out.print((char) temp);
            }
        }
    }
}

PushbackInputStreamDemo.java：

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;

public class PushbackInputStreamDemo {
    public static void main(String[] args) {
        String s = "if (a == 4) a = 0;\n";
        byte[] buf = s.getBytes();
        ByteArrayInputStream in = new ByteArrayInputStream(buf);
        int c;
        try (PushbackInputStream f = new PushbackInputStream(in)) {
            while ((c = f.read()) != -1) {
                switch (c) {
                    case '=':
                        if ((c = f.read()) == '=') {
                            System.out.print(".eq.");
                        } else {
                            System.out.print("<-");
                            f.unread(c);
                        }
                        break;
                    default:
                        System.out.print((char) c);
                        break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意事項：PushbackInputStream對象會使得InputStream對象的mark( )或reset( )方法無效。所以對於準備使用mark( )或reset( )方法的任何流來說，都應該先使用markSupport( )方法進行檢查。

FilterOutputStream

表1-4 FilterOutputStream類型

類	功能	構造器/如何使用
DataOutputStream	與DataInputStream搭配使用，因此可以 按照可移植方式向流中寫入基本類型數據	OutputStream包含用於讀取基本類型數據的全部接口
PrintStream	用於產生格式化輸出。其中DataOutputStream處理數據的存儲，PrintStream處理顯示	OutputStream，可以用boolean值指示是否在每次換行時清空緩衝區（可選的）應該是對OutputStream對象的“final”封裝。可能會經常使用到它
BufferedOutputStream	使用它以避免每次發送數據時都要進行實際的鞋操作。代表“使用緩衝區”。可以調用flush()清空緩衝區	OutputStream，可以指定緩衝區大小（可選的）

DataOutputStream

見DataIODemo：

RandomAccessFile

UsingRandomAccessFile.java：

import java.io.IOException;
import java.io.RandomAccessFile;

public class UsingRandomAccessFile {
    static String file = "/Users/yangyun/Documents/linux/shell/exam1/test1";

    static void display() throws IOException {
        RandomAccessFile rf = new RandomAccessFile(file, "r");
        for (int i = 0; i < 7; i++) {
            System.out.println("Value " + i + ":" + rf.readDouble());
        }

        System.out.println(rf.readUTF());
        rf.close();
    }

    public static void main(String[] args) throws IOException {
        RandomAccessFile rf = new RandomAccessFile(file, "rw");
        for (int i = 0; i < 7; i++) {
            rf.writeDouble(i * 1.414);
        }
        rf.writeUTF("The end of the file");
        rf.close();
        display();
        rf = new RandomAccessFile(file, "rw");
        rf.seek(5 * 8);
        rf.writeDouble(47.0001);
        rf.close();
        display();
    }
}

字符流

InputStream和OutputStream在以面向字節形式的I/O中仍可以提供極有價值的功能，Reader和Writer則提供兼容Unicode與面向字符的I/O功能。
一般我們把來自於“字節”層次結構中的類和“字符”層次結構中的類結合起來使用。爲了實現這個目的，要用到“適配器”（adapter）類：InputStreamReader可以把InputStream轉換爲Reader，而OutputStreamWriter可以把OutputStream轉換爲Writer。設計Reader和Writer繼承層次結構主要是爲了國際化。老的I/O流繼承層次結構僅支持8位字節流，並且不能很好地處理16位的Unicode字符。由於Unicode用於字符國際化，所以添加Reader和Writer繼承層次結構就是爲了在所有的I/O操作中都支持Unicode。

Reader

FileReader

FileReaderDemo.java：

mport java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("/Users/yangyun/Documents/personal_project/thinking-in-java/src/main/java/com/yangyun/javae/chapter20/FileReaderDemo.java")) {
            int c;
            while ((c = fr.read()) != -1) {
                System.out.print((char) c);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

CharArrayReader

CharArrayReaderDemo.java：

import java.io.CharArrayReader;
import java.io.IOException;

public class CharArrayReaderDemo {
    public static void main(String[] args) {
        String tmp = "abcdefghijklmnopqrstuvwxyz";
        int length = tmp.length();
        char[] c = new char[length];

        tmp.getChars(0, length, c, 0);

        int i;

        try (CharArrayReader input1 = new CharArrayReader(c)) {
            System.out.println("input1 is:");
            while ((i = input1.read()) != -1) {
                System.out.print((char) i);
            }
            System.out.println();
        } catch (IOException e) {
            System.out.println("I/O Error:" + e);
        }

        try (CharArrayReader input2 = new CharArrayReader(c,0,5)) {
            System.out.println("input2 is:");
            while ((i = input2.read()) != -1) {
                System.out.print((char) i);
            }
            System.out.println();
        } catch (IOException e) {
            System.out.println("I/O Error:" + e);
        }
    }
}

BufferedReader

BufferedReaderDemo.java：

import java.io.*;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        String s = "This is a © copyright symbol but this is &copy not.\n";
        char[] buf = new char[s.length()];
        s.getChars(0, s.length(), buf, 0);

        CharArrayReader in = new CharArrayReader(buf);
        int c;
        boolean marked = false;

        try (BufferedReader f = new BufferedReader(in)) {
            while ((c = f.read()) != -1) {
                switch (c) {
                    case '&':
                        if (!marked) {
                            f.mark(32);
                            marked = true;
                        } else {
                            marked = false;
                        }
                        break;
                    case ';':
                        if (marked) {
                            marked = false;
                            System.out.print("(c)");
                        } else {
                            System.out.print((char) c);
                        }
                        break;
                    case ' ':
                        if (marked) {
                            marked = false;
                            f.reset();
                            System.out.print("&");
                        } else {
                            System.out.print((char) c);
                        }
                        break;
                    default:
                        if (!marked) {
                            System.out.print((char) c);
                        }
                        break;
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PushbackReader

PushbackReaderDemo.java：

import java.io.*;

public class PushbackReaderDemo {
    public static void main(String[] args) {
        String s = "if (a == 4) a = 0;\n";
        char[] buf = new char[s.length()];
        s.getChars(0,s.length(),buf,0);
        CharArrayReader in = new CharArrayReader(buf);
        int c;
        try (PushbackReader f = new PushbackReader(in)) {
            while ((c = f.read()) != -1) {
                switch (c) {
                    case '=':
                        if ((c = f.read()) == '=') {
                            System.out.print(".eq.");
                        } else {
                            System.out.print("<-");
                            f.unread(c);
                        }
                        break;
                    default:
                        System.out.print((char) c);
                        break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Writer

FileWriter

FileWriterDemo.java：

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    public static void main(String[] args) {
        String source = "Now is the time for all good men\n"
                + " to come to the aid of their country\n"
                + " and pay their due taxes.";

        char[] buffer = new char[source.length()];

        source.getChars(0, source.length(), buffer, 0);


        try (FileWriter f0 = new FileWriter("file1.txt");
             FileWriter f1 = new FileWriter("file2.txt");
             FileWriter f2 = new FileWriter("file3.txt")) {
            for (int i = 0; i < buffer.length; i += 2) {
                f0.write(buffer[i]);
            }

            f1.write(buffer);

            f2.write(buffer, buffer.length - buffer.length / 4, buffer.length / 4);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

CharArrayWriter

CharArrayWriterDemo.java：

import java.io.CharArrayWriter;
import java.io.FileWriter;
import java.io.IOException;

public class CharArrayWriterDemo {
    public static void main(String[] args) {
        CharArrayWriter f = new CharArrayWriter();
        String s = "This should end up in the array";
    
        char[] buf = new char[s.length()];

        s.getChars(0, s.length(), buf, 0);
        try {
            f.write(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Buffer as a String");
        System.out.println(f.toString());
        System.out.println("Into array");

        char[] c = f.toCharArray();
        for (int i = 0; i < c.length; i++) {
            System.out.print(c[i]);
        }

        System.out.println("\nTo a FileWriter()");

        try (FileWriter f2 = new FileWriter("test.txt")) {
            f.writeTo(f2);
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Doing a reset");
        f.reset();

        for (int i = 0; i < 3; i++) {
            f.write('X');
        }
        System.out.println(f.toString());
    }
}

PrintWriter

BasicFileOutput.java：

import java.io.*;

public class BasicFileOutput {
    static String file = "BasicFileOutput.out";

    public static String read(String filename) throws IOException {
        // 按行讀取
        BufferedReader in = new BufferedReader(new FileReader(filename));
        String s;
        StringBuilder sb = new StringBuilder();
        while ((s = in.readLine()) != null) {
            sb.append(s + "\n");
        }
        // 關閉流
        in.close();
        return sb.toString();
    }


    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new StringReader(BufferedInputFile.read(
                "/Users/yangyun/Documents/linux/shell/exam1/test3")));
        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(file)));
        int lineCount = 1;
        String s;
        while ((s = in.readLine()) != null) {
            out.println(lineCount++ + ":" + s);
        }
        out.close();

        // 展示保存的文件
        System.out.println(BufferedInputFile.read(file));
    }
}

ChangeSystemOut.java：

import java.io.PrintWriter;
// PrintWriter有一個可以接受OutputStream作爲參數的構造器
public class ChangeSystemOut {
    public static void main(String[] args) {
        PrintWriter out = new PrintWriter(System.out, true);
        out.println("Hello,world");
    }
}

標準I/O重定向

Redirecting.java：

import java.io.*;

public class Redirecting {
    public static void main(String[] args) throws IOException {
        PrintStream console = System.out;
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("/Users/yangyun/Documents/linux/shell/exam1/test2"));
        PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream("test.out")));
        System.setIn(in);
        System.setOut(out);
        System.setErr(out);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
        System.out.println("hello");
        out.close();

        System.setOut(console);
        System.out.println("hello");
    }
}

串行化

SerializationDemo.java：

import java.io.*;

class MyClass implements Serializable {
    //transient String s;
    String s;
    private int i;
    private double d;

    public MyClass(String s, int i, double d) {
        this.s = s;
        this.i = i;
        this.d = d;
    }

    @Override
    public String toString() {
        return "s=" + s + ";i=" + i + ";d=" + d;
    }
}
public class SerializationDemo {
    public static void main(String[] args) throws IOException {
        try (ObjectOutputStream objOStrm = new ObjectOutputStream(new FileOutputStream("serial"))) {
            MyClass object1 = new MyClass("Hello", -7, 2.7e10);

            System.out.println("object1:" + object1);

            objOStrm.writeObject(object1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (ObjectInputStream objIStrm = new ObjectInputStream(new FileInputStream("serial"))) {
            MyClass object2 = (MyClass) objIStrm.readObject();
            System.out.println("object2:" + object2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
       
    }
}

字節流與字符流的對應關係

表1-5 字節流與字符流的對應關係

字節流	字符流
InputStream	Reader(適配器：InputStreamReader)
OutputStream	Writer(適配器：OutputStreamWriter)
FileInputStream	FileReader
FileOutputStream	FileWriter
StringBufferInputStream(Deprecated)	StringReader
StringWriter
ByteArrayInputStream	CharArrayReader
ByteArrayOutputStream	CharArrayWriter
PipedInputStream	PipedReader
PipedOutputStream	PipedWriter
FilterInputStream	FilterReader
FilterOutputStream	FilterWriter
BufferedInputStream	BufferedReader
BufferedOutputStream
PrintStream	PrintWriter
LineNumberInputStream(Deprecated)	LineNumberReader
StreamTokenizer	StreamTokenizer(使用接受Reader的構造器)
PushbackInputStream	PushbackReader