一、緩衝流
1、緩衝流，也叫高效流，是對4個基本的FileXxx 流的增強，所以也是4個流，按照數據類型分類：
字節緩衝流：BufferedInputStream，BufferedOutputStream
字符緩衝流：BufferedReader，BufferedWriter
緩衝流的基本原理：在創建流對象時，會創建一個內置的默認大小的緩衝區數組，通過緩衝區讀寫，減少系統IO次數，從而提高讀寫的效率。
2、字符緩衝流
構造方法
public BufferedInputStream(InputStream in) ：創建一個 新的緩衝輸入流。
public BufferedOutputStream(OutputStream out)： 創建一個新的緩衝輸出流。
構造舉例，代碼如下：
// 創建字節緩衝輸入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 創建字節緩衝輸出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
BufferedInputStream字節緩衝輸入流示例代碼：
/*
java.io.BufferedInputStream extends InputStream
BufferedInputStream:字節緩衝輸入流
繼承自父類的成員方法:
int read()從輸入流中讀取數據的下一個字節。
int read(byte[] b) 從輸入流中讀取一定數量的字節，並將其存儲在緩衝區數組 b 中。
void close() 關閉此輸入流並釋放與該流關聯的所有系統資源。
構造方法:
BufferedInputStream(InputStream in) 創建一個 BufferedInputStream 並保存其參數，即輸入流 in，以便將來使用。
BufferedInputStream(InputStream in, int size) 創建具有指定緩衝區大小的 BufferedInputStream 並保存其參數，即輸入流 in，以便將來使用。
參數:
InputStream in:字節輸入流
我們可以傳遞FileInputStream,緩衝流會給FileInputStream增加一個緩衝區,提高FileInputStream的讀取效率
int size:指定緩衝流內部緩衝區的大小,不指定默認
使用步驟(重點):
1.創建FileInputStream對象,構造方法中綁定要讀取的數據源
2.創建BufferedInputStream對象,構造方法中傳遞FileInputStream對象,提高FileInputStream對象的讀取效率
3.使用BufferedInputStream對象中的方法read,讀取文件
4.釋放資源
*/
public class Demo02BufferedInputStream {
public static void main(String[] args) throws IOException {
//1.創建FileInputStream對象,構造方法中綁定要讀取的數據源
FileInputStream fis = new FileInputStream("10_IO\\a.txt");
//2.創建BufferedInputStream對象,構造方法中傳遞FileInputStream對象,提高FileInputStream對象的讀取效率
BufferedInputStream bis = new BufferedInputStream(fis);
//3.使用BufferedInputStream對象中的方法read,讀取文件
//int read()從輸入流中讀取數據的下一個字節。
/*int len = 0;//記錄每次讀取到的字節
while((len = bis.read())!=-1){
System.out.println(len);
}*/
//int read(byte[] b) 從輸入流中讀取一定數量的字節，並將其存儲在緩衝區數組 b 中。
byte[] bytes =new byte[1024];//存儲每次讀取的數據
int len = 0; //記錄每次讀取的有效字節個數
while((len = bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
//4.釋放資源
bis.close();
}
}
BufferedOutputStream字節緩衝輸出流示例代碼：
/*
java.io.BufferedOutputStream extends OutputStream
BufferedOutputStream:字節緩衝輸出流
繼承自父類的共性成員方法:
- public void close() ：關閉此輸出流並釋放與此流相關聯的任何系統資源。
- public void flush() ：刷新此輸出流並強制任何緩衝的輸出字節被寫出。
- public void write(byte[] b)：將 b.length字節從指定的字節數組寫入此輸出流。
- public void write(byte[] b, int off, int len) ：從指定的字節數組寫入 len字節，從偏移量 off開始輸出到此輸出流。
- public abstract void write(int b) ：將指定的字節輸出流。
構造方法:
BufferedOutputStream(OutputStream out) 創建一個新的緩衝輸出流，以將數據寫入指定的底層輸出流。
BufferedOutputStream(OutputStream out, int size) 創建一個新的緩衝輸出流，以將具有指定緩衝區大小的數據寫入指定的底層輸出流。
參數:
OutputStream out:字節輸出流
我們可以傳遞FileOutputStream,緩衝流會給FileOutputStream增加一個緩衝區,提高FileOutputStream的寫入效率
int size:指定緩衝流內部緩衝區的大小,不指定默認
使用步驟(重點)
1.創建FileOutputStream對象,構造方法中綁定要輸出的目的地
2.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream對象對象,提高FileOutputStream對象效率
3.使用BufferedOutputStream對象中的方法write,把數據寫入到內部緩衝區中
4.使用BufferedOutputStream對象中的方法flush,把內部緩衝區中的數據,刷新到文件中
5.釋放資源(會先調用flush方法刷新數據,第4部可以省略)
*/
public class Demo01BufferedOutputStream {
public static void main(String[] args) throws IOException {
//1.創建FileOutputStream對象,構造方法中綁定要輸出的目的地
FileOutputStream fos = new FileOutputStream("10_IO\\a.txt");
//2.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream對象對象,提高FileOutputStream對象效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.使用BufferedOutputStream對象中的方法write,把數據寫入到內部緩衝區中
bos.write("我把數據寫入到內部緩衝區中".getBytes());
//4.使用BufferedOutputStream對象中的方法flush,把內部緩衝區中的數據,刷新到文件中
bos.flush();
//5.釋放資源(會先調用flush方法刷新數據,第4部可以省略)
bos.close();
}
}
3、字符緩衝流
構造方法：
public BufferedReader(Reader in) ：創建一個 新的緩衝輸入流。
public BufferedWriter(Writer out)： 創建一個新的緩衝輸出流。
構造舉例，代碼如下：
// 創建字符緩衝輸入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 創建字符緩衝輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
特有方法：
字符緩衝流的基本方法與普通字符流調用方式一致，不再闡述，我們來看它們具備的特有方法。
BufferedReader：public String readLine(): 讀一行文字。
BufferedWriter：public void newLine(): 寫一行行分隔符,由系統屬性定義符號。
BufferedReader字符緩衝輸入流示例代碼：
/*
java.io.BufferedReader extends Reader
BufferedReader:字符緩衝輸入流
繼承自父類的共性成員方法:
int read() 讀取單個字符並返回。
int read(char[] cbuf)一次讀取多個字符,將字符讀入數組。
void close() 關閉該流並釋放與之關聯的所有資源。
構造方法:
BufferedReader(Reader in) 創建一個使用默認大小輸入緩衝區的緩衝字符輸入流。
BufferedReader(Reader in, int sz) 創建一個使用指定大小輸入緩衝區的緩衝字符輸入流。
參數:
Reader in:字符輸入流
我們可以傳遞FileReader,緩衝流會給FileReader增加一個緩衝區,提高FileReader的讀取效率
特有的成員方法:
String readLine() 讀取一個文本行。讀取一行數據
行的終止符號:通過下列字符之一即可認爲某行已終止：換行 ('\n')、回車 ('\r') 或回車後直接跟着換行(\r\n)。
返回值:
包含該行內容的字符串，不包含任何行終止符，如果已到達流末尾，則返回 null
使用步驟:
1.創建字符緩衝輸入流對象,構造方法中傳遞字符輸入流
2.使用字符緩衝輸入流對象中的方法read/readLine讀取文本
3.釋放資源
*/
public class Demo04BufferedReader {
public static void main(String[] args) throws IOException {
//1.創建字符緩衝輸入流對象,構造方法中傳遞字符輸入流
BufferedReader br = new BufferedReader(new FileReader("10_IO\\c.txt"));
//2.使用字符緩衝輸入流對象中的方法read/readLine讀取文本
/*String line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);
line = br.readLine();
System.out.println(line);*/
/*
發下以上讀取是一個重複的過程,所以可以使用循環優化
不知道文件中有多少行數據,所以使用while循環
while的結束條件,讀取到null結束
*/
String line;
while((line = br.readLine())!=null){
System.out.println(line);
}
//3.釋放資源
br.close();
}
}
BufferedWriter字符緩衝輸出流示例代碼：
/*
java.io.BufferedWriter extends Writer
BufferedWriter:字符緩衝輸出流
繼承自父類的共性成員方法:
- void write(int c) 寫入單個字符。
- void write(char[] cbuf)寫入字符數組。
- abstract void write(char[] cbuf, int off, int len)寫入字符數組的某一部分,off數組的開始索引,len寫的字符個數。
- void write(String str)寫入字符串。
- void write(String str, int off, int len) 寫入字符串的某一部分,off字符串的開始索引,len寫的字符個數。
- void flush()刷新該流的緩衝。
- void close() 關閉此流，但要先刷新它。
構造方法:
BufferedWriter(Writer out) 創建一個使用默認大小輸出緩衝區的緩衝字符輸出流。
BufferedWriter(Writer out, int sz) 創建一個使用給定大小輸出緩衝區的新緩衝字符輸出流。
參數:
Writer out:字符輸出流
我們可以傳遞FileWriter,緩衝流會給FileWriter增加一個緩衝區,提高FileWriter的寫入效率
int sz:指定緩衝區的大小,不寫默認大小
特有的成員方法:
void newLine() 寫入一個行分隔符。會根據不同的操作系統,獲取不同的行分隔符
換行:換行符號
windows:\r\n
linux:/n
mac:/r
使用步驟:
1.創建字符緩衝輸出流對象,構造方法中傳遞字符輸出流
2.調用字符緩衝輸出流中的方法write,把數據寫入到內存緩衝區中
3.調用字符緩衝輸出流中的方法flush,把內存緩衝區中的數據,刷新到文件中
4.釋放資源
*/
public class Demo03BufferedWriter {
public static void main(String[] args) throws IOException {
//System.out.println();
//1.創建字符緩衝輸出流對象,構造方法中傳遞字符輸出流
BufferedWriter bw = new BufferedWriter(new FileWriter("10_IO\\c.txt"));
//2.調用字符緩衝輸出流中的方法write,把數據寫入到內存緩衝區中
for (int i = 0; i <10 ; i++) {
bw.write("傳智播客");
//bw.write("\r\n");
bw.newLine();
}
//3.調用字符緩衝輸出流中的方法flush,把內存緩衝區中的數據,刷新到文件中
bw.flush();
//4.釋放資源
bw.close();
}
}
二、轉換流
1、字符編碼和字符集
計算機中儲存的信息都是用二進制數表示的，而我們在屏幕上看到的數字、英文、標點符號、漢字等字符是二進制數轉換之後的結果。按照某種規則，將字符存儲到計算機中，稱爲編碼 。反之，將存儲在計算機中的二進制數按照某種規則解析顯示出來，稱爲解碼 。比如說，按照A規則存儲，同樣按照A規則解析，那麼就能顯示正確的文本符號。反之，按照A規則存儲，再按照B規則解析，就會導致亂碼現象。
編碼:字符(能看懂的)–字節(看不懂的)
解碼:字節(看不懂的)–>字符(能看懂的)
字符編碼Character Encoding : 就是一套自然語言的字符與二進制數之間的對應規則。
編碼表：生活中文字和計算機中二進制的對應規則。
字符集：
字符集 Charset：也叫編碼表。是一個系統支持的所有字符的集合，包括各國家文字、標點符號、圖形符號、數字等。
計算機要準確的存儲和識別各種字符集符號，需要進行字符編碼，一套字符集必然至少有一套字符編碼。常見字符集有ASCII字符集、GBK字符集、Unicode字符集等。
可見，當指定了編碼，它所對應的字符集自然就指定了，所以編碼纔是我們最終要關心的。
在IDEA中，使用FileReader 讀取項目中的文本文件。由於IDEA的設置，都是默認的UTF-8編碼，所以沒有任何問題。但是，當讀取Windows系統中創建的文本文件時，由於Windows系統的默認是GBK編碼，就會出現亂碼。
2、InputStreamReader類
轉換流java.io.InputStreamReader，是Reader的子類，是從字節流到字符流的橋樑。它讀取字節，並使用指定的字符集將其解碼爲字符。它的字符集可以由名稱指定，也可以接受平臺的默認字符集。
構造方法：
InputStreamReader(InputStream in): 創建一個使用默認字符集的字符流。
InputStreamReader(InputStream in, String charsetName): 創建一個指定字符集的字符流。
InputStreamReader字符轉換輸入流示例代碼：
/*
java.io.InputStreamReader extends Reader
InputStreamReader:是字節流通向字符流的橋樑：它使用指定的 charset 讀取字節並將其解碼爲字符。(解碼:把看不懂的變成能看懂的)
繼承自父類的共性成員方法:
int read() 讀取單個字符並返回。
int read(char[] cbuf)一次讀取多個字符,將字符讀入數組。
void close() 關閉該流並釋放與之關聯的所有資源。
構造方法:
InputStreamReader(InputStream in) 創建一個使用默認字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName) 創建使用指定字符集的 InputStreamReader。
參數:
InputStream in:字節輸入流,用來讀取文件中保存的字節
String charsetName:指定的編碼表名稱,不區分大小寫,可以是utf-8/UTF-8,gbk/GBK,...不指定默認使用UTF-8
使用步驟:
1.創建InputStreamReader對象,構造方法中傳遞字節輸入流和指定的編碼表名稱
2.使用InputStreamReader對象中的方法read讀取文件
3.釋放資源
注意事項:
構造方法中指定的編碼表名稱要和文件的編碼相同,否則會發生亂碼
*/
public class Demo03InputStreamReader {
public static void main(String[] args) throws IOException {
//read_utf_8();
read_gbk();
}
/*
使用InputStreamReader讀取GBK格式的文件
*/
private static void read_gbk() throws IOException {
//1.創建InputStreamReader對象,構造方法中傳遞字節輸入流和指定的編碼表名稱
//InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"UTF-8");//???
InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"GBK");//你好
//2.使用InputStreamReader對象中的方法read讀取文件
int len = 0;
while((len = isr.read())!=-1){
System.out.println((char)len);
}
//3.釋放資源
isr.close();
}
/*
使用InputStreamReader讀取UTF-8格式的文件
*/
private static void read_utf_8() throws IOException {
//1.創建InputStreamReader對象,構造方法中傳遞字節輸入流和指定的編碼表名稱
//InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"),"UTF-8");
InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"));//不指定默認使用UTF-8
//2.使用InputStreamReader對象中的方法read讀取文件
int len = 0;
while((len = isr.read())!=-1){
System.out.println((char)len);
}
//3.釋放資源
isr.close();
}
}
3、OutputStreamWriter類
轉換流java.io.OutputStreamWriter ，是Writer的子類，是從字符流到字節流的橋樑。使用指定的字符集將字符編碼爲字節。它的字符集可以由名稱指定，也可以接受平臺的默認字符集。
構造方法：
OutputStreamWriter(OutputStream in): 創建一個使用默認字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName): 創建一個指定字符集的字符流。
OutputStreamWriter字符轉換輸出流示例代碼：
/*
java.io.OutputStreamWriter extends Writer
OutputStreamWriter: 是字符流通向字節流的橋樑：可使用指定的 charset 將要寫入流中的字符編碼成字節。(編碼:把能看懂的變成看不懂)
繼續自父類的共性成員方法:
- void write(int c) 寫入單個字符。
- void write(char[] cbuf)寫入字符數組。
- abstract void write(char[] cbuf, int off, int len)寫入字符數組的某一部分,off數組的開始索引,len寫的字符個數。
- void write(String str)寫入字符串。
- void write(String str, int off, int len) 寫入字符串的某一部分,off字符串的開始索引,len寫的字符個數。
- void flush()刷新該流的緩衝。
- void close() 關閉此流，但要先刷新它。
構造方法:
OutputStreamWriter(OutputStream out)創建使用默認字符編碼的 OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName) 創建使用指定字符集的 OutputStreamWriter。
參數:
OutputStream out:字節輸出流,可以用來寫轉換之後的字節到文件中
String charsetName:指定的編碼表名稱,不區分大小寫,可以是utf-8/UTF-8,gbk/GBK,...不指定默認使用UTF-8
使用步驟:
1.創建OutputStreamWriter對象,構造方法中傳遞字節輸出流和指定的編碼表名稱
2.使用OutputStreamWriter對象中的方法write,把字符轉換爲字節存儲緩衝區中(編碼)
3.使用OutputStreamWriter對象中的方法flush,把內存緩衝區中的字節刷新到文件中(使用字節流寫字節的過程)
4.釋放資源
*/
public class Demo02OutputStreamWriter {
public static void main(String[] args) throws IOException {
//write_utf_8();
write_gbk();
}
/*
使用轉換流OutputStreamWriter寫GBK格式的文件
*/
private static void write_gbk() throws IOException {
//1.創建OutputStreamWriter對象,構造方法中傳遞字節輸出流和指定的編碼表名稱
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
//2.使用OutputStreamWriter對象中的方法write,把字符轉換爲字節存儲緩衝區中(編碼)
osw.write("你好");
//3.使用OutputStreamWriter對象中的方法flush,把內存緩衝區中的字節刷新到文件中(使用字節流寫字節的過程)
osw.flush();
//4.釋放資源
osw.close();
}
/*
使用轉換流OutputStreamWriter寫UTF-8格式的文件
*/
private static void write_utf_8() throws IOException {
//1.創建OutputStreamWriter對象,構造方法中傳遞字節輸出流和指定的編碼表名稱
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"),"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"));//不指定默認使用UTF-8
//2.使用OutputStreamWriter對象中的方法write,把字符轉換爲字節存儲緩衝區中(編碼)
osw.write("你好");
//3.使用OutputStreamWriter對象中的方法flush,把內存緩衝區中的字節刷新到文件中(使用字節流寫字節的過程)
osw.flush();
//4.釋放資源
osw.close();
}
}
三、序列化
Java 提供了一種對象序列化的機制。用一個字節序列可以表示一個對象，該字節序列包含該對象的數據、對象的類型和對象中存儲的屬性等信息。字節序列寫出到文件之後，相當於文件中持久保存了一個對象的信息。
反之，該字節序列還可以從文件中讀取回來，重構對象，對它進行反序列化。對象的數據、對象的類型和對象中存儲的數據信息，都可以用來在內存中創建對象。看圖理解序列化。
1、 ObjectOutputStream序列化類
java.io.ObjectOutputStream 類，將Java對象的原始數據類型寫出到文件,實現對象的持久存儲。
構造方法：
public ObjectOutputStream(OutputStream out)： 創建一個指定OutputStream的ObjectOutputStream。
一個對象要想序列化，必須滿足兩個條件:
1） 該類必須實現java.io.Serializable 接口，Serializable 是一個標記接口，不實現此接口的類將不會使任何狀態序列化或反序列化，會拋出NotSerializableException 。
2）該類的所有屬性必須是可序列化的。如果有一個屬性不需要可序列化的，則該屬性必須註明是瞬態的，使用transient 關鍵字修飾。
ObjectOutputStream對象的序列化流示例代碼：
/*
java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream:對象的序列化流
作用:把對象以流的方式寫入到文件中保存
構造方法:
ObjectOutputStream(OutputStream out) 創建寫入指定 OutputStream 的 ObjectOutputStream。
參數:
OutputStream out:字節輸出流
特有的成員方法:
void writeObject(Object obj) 將指定的對象寫入 ObjectOutputStream。
使用步驟:
1.創建ObjectOutputStream對象,構造方法中傳遞字節輸出流
2.使用ObjectOutputStream對象中的方法writeObject,把對象寫入到文件中
3.釋放資源
*/
public class Demo01ObjectOutputStream {
public static void main(String[] args) throws IOException {
//1.創建ObjectOutputStream對象,構造方法中傳遞字節輸出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\person.txt"));
//2.使用ObjectOutputStream對象中的方法writeObject,把對象寫入到文件中
oos.writeObject(new Person("美女",18));
//3.釋放資源
oos.close();
}
}
2、ObjectInputStream反序列化類
ObjectInputStream反序列化流，將之前使用ObjectOutputStream序列化的原始數據恢復爲對象。
構造方法：
public ObjectInputStream(InputStream in)： 創建一個指定InputStream的ObjectInputStream。
ObjectInputStream對象的反序列化流示例代碼：
/*
java.io.ObjectInputStream extends InputStream
ObjectInputStream:對象的反序列化流
作用:把文件中保存的對象,以流的方式讀取出來使用
構造方法:
ObjectInputStream(InputStream in) 創建從指定 InputStream 讀取的 ObjectInputStream。
參數:
InputStream in:字節輸入流
特有的成員方法:
Object readObject() 從 ObjectInputStream 讀取對象。
使用步驟:
1.創建ObjectInputStream對象,構造方法中傳遞字節輸入流
2.使用ObjectInputStream對象中的方法readObject讀取保存對象的文件
3.釋放資源
4.使用讀取出來的對象(打印)
readObject方法聲明拋出了ClassNotFoundException(class文件找不到異常)
當不存在對象的class文件時拋出此異常
反序列化的前提:
1.類必須實現Serializable
2.必須存在類對應的class文件
*/
public class Demo02ObjectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1.創建ObjectInputStream對象,構造方法中傳遞字節輸入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\person.txt"));
//2.使用ObjectInputStream對象中的方法readObject讀取保存對象的文件
Object o = ois.readObject();
//3.釋放資源
ois.close();
//4.使用讀取出來的對象(打印)
System.out.println(o);
Person p = (Person)o;
System.out.println(p.getName()+p.getAge());
}
}
反序列化操作報錯情況：
另外，當JVM反序列化對象時，能找到class文件，但是class文件在序列化對象之後發生了修改，那麼反序列化操作也會失敗，拋出一個InvalidClassException異常。發生這個異常的原因如下：
該類的序列版本號與從流中讀取的類描述符的版本號不匹配
該類包含未知數據類型
該類沒有可訪問的無參數構造方法
Serializable 接口給需要序列化的類，提供了一個序列版本號。
serialVersionUID 該版本號的目的在於驗證序列化的對象和對應類是否版本匹配。
public class Employee implements java.io.Serializable {
// 加入序列版本號
private static final long serialVersionUID = 1L;
public String name;
public String address;
// 添加新的屬性 ,重新編譯, 可以反序列化,該屬性賦爲默認值.
public int eid;
public void addressCheck() {
System.out.println("Address check : " + name + " -- " + address);
}
}
四、打印流
平時我們在控制檯打印輸出，是調用print方法和println方法完成的，這兩個方法都來自於java.io.PrintStream類，該類能夠方便地打印各種數據類型的值，是一種便捷的輸出方式。
PrintStream類
構造方法：
public PrintStream(String fileName)： 使用指定的文件名創建一個新的打印流。
構造舉例，代碼如下：
PrintStream ps = new PrintStream("ps.txt")；
改變打印流向：
System.out就是PrintStream類型的，只不過它的流向是系統規定的，打印在控制檯上。不過，既然是流對象，我們就可以玩一個"小把戲"，改變它的流向。
/*
java.io.PrintStream:打印流
PrintStream 爲其他輸出流添加了功能，使它們能夠方便地打印各種數據值表示形式。
PrintStream特點:
1.只負責數據的輸出,不負責數據的讀取
2.與其他輸出流不同，PrintStream 永遠不會拋出 IOException
3.有特有的方法,print,println
void print(任意類型的值)
void println(任意類型的值並換行)
構造方法:
PrintStream(File file):輸出的目的地是一個文件
PrintStream(OutputStream out):輸出的目的地是一個字節輸出流
PrintStream(String fileName) :輸出的目的地是一個文件路徑
PrintStream extends OutputStream
繼承自父類的成員方法:
- public void close() ：關閉此輸出流並釋放與此流相關聯的任何系統資源。
- public void flush() ：刷新此輸出流並強制任何緩衝的輸出字節被寫出。
- public void write(byte[] b)：將 b.length字節從指定的字節數組寫入此輸出流。
- public void write(byte[] b, int off, int len) ：從指定的字節數組寫入 len字節，從偏移量 off開始輸出到此輸出流。
- public abstract void write(int b) ：將指定的字節輸出流。
注意:
如果使用繼承自父類的write方法寫數據,那麼查看數據的時候會查詢編碼表 97->a
如果使用自己特有的方法print/println方法寫數據,寫的數據原樣輸出 97->97
*/
public class Demo01PrintStream {
public static void main(String[] args) throws FileNotFoundException {
//System.out.println("HelloWorld");
//創建打印流PrintStream對象,構造方法中綁定要輸出的目的地
PrintStream ps = new PrintStream("10_IO\\print.txt");
//如果使用繼承自父類的write方法寫數據,那麼查看數據的時候會查詢編碼表 97->a
ps.write(97);
//如果使用自己特有的方法print/println方法寫數據,寫的數據原樣輸出 97->97
ps.println(97);
ps.println(8.8);
ps.println('a');
ps.println("HelloWorld");
ps.println(true);
//釋放資源
ps.close();
}
}