1. 數(shù)據(jù)流
1.1 概述
數(shù)據(jù)流是操作基本數(shù)據(jù)類型的流，分為數(shù)據(jù)輸入流，數(shù)據(jù)輸出流。
1.2 數(shù)據(jù)輸入流
1、DataInputStream：數(shù)據(jù)輸出流允許應(yīng)用程序以適當(dāng)方式將基本 Java 數(shù)據(jù)類型寫入輸出流中。然后，應(yīng)用程序可以使用數(shù)據(jù)輸入流將數(shù)據(jù)讀入。
2、構(gòu)造方法
DataOutputStream(OutputStream out) ：創(chuàng)建一個新的數(shù)據(jù)輸出流，將數(shù)據(jù)寫入指定基礎(chǔ)輸出流。
1.3 數(shù)據(jù)輸出流
1、DataOutputStream：數(shù)據(jù)輸入流允許應(yīng)用程序以與機(jī)器無關(guān)方式從底層輸入流中讀取基本 Java 數(shù)據(jù)類型。應(yīng)用程序可以使用數(shù)據(jù)輸出流寫入稍后由數(shù)據(jù)輸入流讀取的數(shù)據(jù)。
2、構(gòu)造方法
DataInputStream(InputStream in) ：使用指定的底層 InputStream 創(chuàng)建一個 DataInputStream。
package cn.itcast_01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 可以讀寫基本數(shù)據(jù)類型的數(shù)據(jù)
* 數(shù)據(jù)輸入流：DataInputStream
* DataInputStream(InputStream in)
* 數(shù)據(jù)輸出流：DataOutputStream
* DataOutputStream(OutputStream out)
*/
public class DataStreamDemo {
public static void main(String[] args) throws IOException {
// 寫
// write();
// 讀
read();
}
private static void read() throws IOException {
// DataInputStream(InputStream in)
// 創(chuàng)建數(shù)據(jù)輸入流對象
DataInputStream dis = new DataInputStream(
new FileInputStream("dos.txt"));
// 讀數(shù)據(jù)
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
char c = dis.readChar();
boolean bb = dis.readBoolean();
// 釋放資源
dis.close();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(c);
System.out.println(bb);
}
private static void write() throws IOException {
// DataOutputStream(OutputStream out)
// 創(chuàng)建數(shù)據(jù)輸出流對象
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"dos.txt"));
// 寫數(shù)據(jù)了
dos.writeByte(10);
dos.writeShort(100);
dos.writeInt(1000);
dos.writeLong(10000);
dos.writeFloat(12.34F);
dos.writeDouble(12.56);
dos.writeChar('a');
dos.writeBoolean(true);
// 釋放資源
dos.close();
}
}
運(yùn)行結(jié)果：
2. 內(nèi)存操作流
2.1 概述
內(nèi)存操作流：用于處理臨時存儲信息的，程序結(jié)束，數(shù)據(jù)就從內(nèi)存中消失。
2.2 操作字節(jié)數(shù)組
2.2.1 ByteArrayInputStream
ByteArrayInputStream 包含一個內(nèi)部緩沖區(qū)，該緩沖區(qū)包含從流中讀取的字節(jié)。內(nèi)部計數(shù)器跟蹤 read 方法要提供的下一個字節(jié)。
關(guān)閉 ByteArrayInputStream 無效。此類中的方法在關(guān)閉此流后仍可被調(diào)用，而不會產(chǎn)生任何 IOException。
2.2.2 ByteArrayOutputStream
此類實現(xiàn)了一個輸出流，其中的數(shù)據(jù)被寫入一個 byte 數(shù)組。緩沖區(qū)會隨著數(shù)據(jù)的不斷寫入而自動增長?？墒褂?toByteArray() 和 toString() 獲取數(shù)據(jù)。
關(guān)閉 ByteArrayOutputStream 無效。此類中的方法在關(guān)閉此流后仍可被調(diào)用，而不會產(chǎn)生任何 IOException。
3. 操作字符數(shù)組
3.1 CharArrayReader
此類實現(xiàn)一個可用作字符輸入流的字符緩沖區(qū)。
CharArrayReader(char[] buf) // 根據(jù)指定的 char 數(shù)組創(chuàng)建一個 CharArrayReader。
CharArrayReader(char[] buf, int offset, int length) // 根據(jù)指定的 char 數(shù)組創(chuàng)建一個 CharArrayReader。
3.2 CharArrayWriter
此類實現(xiàn)一個可用作 Writer 的字符緩沖區(qū)。緩沖區(qū)會隨向流中寫入數(shù)據(jù)而自動增長?？墒褂?toCharArray() 和 toString() 獲取數(shù)據(jù)。
PS：在此類上調(diào)用 close() 無效，并且在關(guān)閉該流后可以調(diào)用此類中的各個方法，而不會產(chǎn)生任何 IOException。
CharArrayWriter() // 創(chuàng)建一個新的 CharArrayWriter。
CharArrayWriter(int initialSize) // 創(chuàng)建一個具有指定初始大小的新 CharArrayWriter。
4. 操作字符串
4.1 StringReader
其源為一個字符串的字符流。StringReader(String s) ：創(chuàng)建一個新字符串 reader。
4.2 StringWriter
一個字符流，可以用其回收在字符串緩沖區(qū)中的輸出來構(gòu)造字符串。
關(guān)閉 StringWriter 無效。此類中的方法在關(guān)閉該流后仍可被調(diào)用，而不會產(chǎn)生任何 IOException。
StringWriter() // 使用默認(rèn)初始字符串緩沖區(qū)大小創(chuàng)建一個新字符串 writer。
StringWriter(int initialSize) // 使用指定初始字符串緩沖區(qū)大小創(chuàng)建一個新字符串 writer。
package cn.itcast_02;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/*
* 內(nèi)存操作流：用于處理臨時存儲信息的，程序結(jié)束，數(shù)據(jù)就從內(nèi)存中消失。
* 字節(jié)數(shù)組：
* ByteArrayInputStream
* ByteArrayOutputStream
* 字符數(shù)組：
* CharArrayReader
* CharArrayWriter
* 字符串：
* StringReader
* StringWriter
*/
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException {
// 寫數(shù)據(jù)
// ByteArrayOutputStream()
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 寫數(shù)據(jù)
for (int x = 0; x < 10; x++) {
baos.write(("hello" + x).getBytes());
}
// 釋放資源
// 通過查看源碼我們知道這里什么都沒做，所以根本需要close()
// baos.close();
// public byte[] toByteArray()
byte[] bys = baos.toByteArray();
// 讀數(shù)據(jù)
// ByteArrayInputStream(byte[] buf)
ByteArrayInputStream bais = new ByteArrayInputStream(bys);
int by = 0;
while ((by = bais.read()) != -1) {
System.out.print((char) by);
}
// bais.close();
}
}
運(yùn)行結(jié)果：
5. 打印流
5.1 打印流概述
打印流分為： 字節(jié)流打印流PrintStream和字符打印流PrintWriter。
5.2 字節(jié)流打印流
PrintStream 為其他輸出流添加了功能，使它們能夠方便地打印各種數(shù)據(jù)值表示形式。它還提供其他兩項功能。與其他輸出流不同，PrintStream 永遠(yuǎn)不會拋出 IOException；而是，異常情況僅設(shè)置可通過 checkError 方法測試的內(nèi)部標(biāo)志。另外，為了自動刷新，可以創(chuàng)建一個 PrintStream；這意味著可在寫入 byte 數(shù)組之后自動調(diào)用 flush 方法，可調(diào)用其中一個 println 方法，或?qū)懭胍粋€換行符或字節(jié) ('\n')。
PrintStream 打印的所有字符都使用平臺的默認(rèn)字符編碼轉(zhuǎn)換為字節(jié)。在需要寫入字符而不是寫入字節(jié)的情況下，應(yīng)該使用 PrintWriter 類。
5.3 字符打印流
向文本輸出流打印對象的格式化表示形式。此類實現(xiàn)在 PrintStream 中的所有 print 方法。它不包含用于寫入原始字節(jié)的方法，對于這些字節(jié)，程序應(yīng)該使用未編碼的字節(jié)流進(jìn)行寫入。
與 PrintStream 類不同，如果啟用了自動刷新，則只有在調(diào)用 println、printf 或 format 的其中一個方法時才可能完成此操作，而不是每當(dāng)正好輸出換行符時才完成。這些方法使用平臺自有的行分隔符概念，而不是換行符。
此類中的方法不會拋出 I/O 異常，盡管其某些構(gòu)造方法可能拋出異常。客戶端可能會查詢調(diào)用 checkError() 是否出現(xiàn)錯誤。
package cn.itcast_03;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流
* 字節(jié)流打印流 PrintStream
* 字符打印流 PrintWriter
*
* 打印流的特點(diǎn)：
* A:只有寫數(shù)據(jù)的，沒有讀取數(shù)據(jù)。只能操作目的地，不能操作數(shù)據(jù)源。
* B:可以操作任意類型的數(shù)據(jù)。
* C:如果啟動了自動刷新，能夠自動刷新。
* D:該流是可以直接操作文本文件的。
* 哪些流對象是可以直接操作文本文件的呢?
* FileInputStream
* FileOutputStream
* FileReader
* FileWriter
* PrintStream
* PrintWriter
* 看API,查流對象的構(gòu)造方法，如果同時有File類型和String類型的參數(shù)，一般來說就是可以直接操作文件的。
*
* 流：
* 基本流：就是能夠直接讀寫文件的
* 高級流：在基本流基礎(chǔ)上提供了一些其他的功能
*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
// 作為Writer的子類使用
PrintWriter pw = new PrintWriter("pw.txt");
pw.write("hello");
pw.write("world");
pw.write("java");
pw.close();
}
}
package cn.itcast_03;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 1:可以操作任意類型的數(shù)據(jù)。
* print()
* println()
* 2:啟動自動刷新
* PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
* 還是應(yīng)該調(diào)用println()的方法才可以
* 這個時候不僅僅自動刷新了，還實現(xiàn)了數(shù)據(jù)的換行。
*
* println()
* 其實等價于于：
* bw.write();
* bw.newLine();
* bw.flush();
*/
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
// 創(chuàng)建打印流對象
// PrintWriter pw = new PrintWriter("pw2.txt");
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
// write()是搞不定的，怎么辦呢?
// 我們就應(yīng)該看看它的新方法
// pw.print(true);
// pw.print(100);
// pw.print("hello");
pw.println("hello");
pw.println(true);
pw.println(100);
pw.close();
}
}
5.4 打印流特點(diǎn)
- 只能操作目的地，不能操作數(shù)據(jù)。
- 可以操作任意類型的數(shù)據(jù)。
- 如果啟動了自動刷新，能夠自動刷新。
- 可以操作文件的流
5.5 打印流復(fù)制文本文件
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 需求：DataStreamDemo.java復(fù)制到Copy.java中
* 數(shù)據(jù)源：
* DataStreamDemo.java -- 讀取數(shù)據(jù) -- FileReader -- BufferedReader
* 目的地：
* Copy.java -- 寫出數(shù)據(jù) -- FileWriter -- BufferedWriter -- PrintWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 以前的版本
// 封裝數(shù)據(jù)源
// BufferedReader br = new BufferedReader(new FileReader(
// "DataStreamDemo.java"));
// // 封裝目的地
// BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
//
// String line = null;
// while ((line = br.readLine()) != null) {
// bw.write(line);
// bw.newLine();
// bw.flush();
// }
//
// bw.close();
// br.close();
// 打印流的改進(jìn)版
// 封裝數(shù)據(jù)源
BufferedReader br = new BufferedReader(new FileReader(
"DataStreamDemo.java"));
// 封裝目的地
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
String line = null;
while((line=br.readLine())!=null){
pw.println(line);
}
pw.close();
br.close();
}
}
6. 標(biāo)準(zhǔn)輸入輸出流
6.1 標(biāo)準(zhǔn)輸入輸出流
- System類中的字段：in，out。
- 它們各代表了系統(tǒng)標(biāo)準(zhǔn)的輸入和輸出設(shè)備。
- 默認(rèn)輸入設(shè)備是鍵盤，輸出設(shè)備是顯示器。
- System.in的類型是InputStream.
- System.out的類型是PrintStream是OutputStream的子類FilterOutputStream 的子類.
代碼示例：System.in 標(biāo)準(zhǔn)輸入流。是從鍵盤獲取數(shù)據(jù)的
package cn.itcast_04;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* System.in 標(biāo)準(zhǔn)輸入流。是從鍵盤獲取數(shù)據(jù)的
*
* 鍵盤錄入數(shù)據(jù)：
* A:main方法的args接收參數(shù)。
* java HelloWorld hello world java
* B:Scanner(JDK5以后的)
* Scanner sc = new Scanner(System.in);
* String s = sc.nextLine();
* int x = sc.nextInt()
* C:通過字符緩沖流包裝標(biāo)準(zhǔn)輸入流實現(xiàn)
* BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
*/
public class SystemInDemo {
public static void main(String[] args) throws IOException {
// //獲取標(biāo)準(zhǔn)輸入流
// InputStream is = System.in;
// //我要一次獲取一行行不行呢?
// //行。
// //怎么實現(xiàn)呢?
// //要想實現(xiàn)，首先你得知道一次讀取一行數(shù)據(jù)的方法是哪個呢?
// //readLine()
// //而這個方法在哪個類中呢?
// //BufferedReader
// //所以，你這次應(yīng)該創(chuàng)建BufferedReader的對象，但是底層還是的使用標(biāo)準(zhǔn)輸入流
// // BufferedReader br = new BufferedReader(is);
// //按照我們的推想，現(xiàn)在應(yīng)該可以了，但是卻報錯了
// //原因是：字符緩沖流只能針對字符流操作，而你現(xiàn)在是字節(jié)流，所以不能是用?
// //那么，我還就想使用了，請大家給我一個解決方案?
// //把字節(jié)流轉(zhuǎn)換為字符流，然后在通過字符緩沖流操作
// InputStreamReader isr = new InputStreamReader(is);
// BufferedReader br= new BufferedReader(isr);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("請輸入一個字符串：");
String line = br.readLine();
System.out.println("你輸入的字符串是：" + line);
System.out.println("請輸入一個整數(shù)：");
// int i = Integer.parseInt(br.readLine());
line = br.readLine();
int i = Integer.parseInt(line);
System.out.println("你輸入的整數(shù)是：" + i);
}
}
運(yùn)行結(jié)果：
代碼示例：標(biāo)準(zhǔn)輸入輸出流
package cn.itcast_04;
import java.io.PrintStream;
/*
* 標(biāo)準(zhǔn)輸入輸出流
* System類中的兩個成員變量：
* public static final InputStream in “標(biāo)準(zhǔn)”輸入流。
* public static final PrintStream out “標(biāo)準(zhǔn)”輸出流。
*
* InputStream is = System.in;
* PrintStream ps = System.out;
*/
public class SystemOutDemo {
public static void main(String[] args) {
// 有這里的講解我們就知道了，這個輸出語句其本質(zhì)是IO流操作，把數(shù)據(jù)輸出到控制臺。
System.out.println("helloworld");
// 獲取標(biāo)準(zhǔn)輸出流對象
PrintStream ps = System.out;
ps.println("helloworld");
ps.println();
// ps.print();//這個方法不存在
// System.out.println();
// System.out.print();
}
}
代碼示例：轉(zhuǎn)換流的應(yīng)用
package cn.itcast_04;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
* 轉(zhuǎn)換流的應(yīng)用。
*/
public class SystemOutDemo2 {
public static void main(String[] args) throws IOException {
// 獲取標(biāo)準(zhǔn)輸入流
// // PrintStream ps = System.out;
// // OutputStream os = ps;
// OutputStream os = System.out; // 多態(tài)
// // 我能不能按照剛才使用標(biāo)準(zhǔn)輸入流的方式一樣把數(shù)據(jù)輸出到控制臺呢?
// OutputStreamWriter osw = new OutputStreamWriter(os);
// BufferedWriter bw = new BufferedWriter(osw);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
System.out));
bw.write("hello");
bw.newLine();
// bw.flush();
bw.write("world");
bw.newLine();
// bw.flush();
bw.write("java");
bw.newLine();
bw.flush();
bw.close();
}
}
運(yùn)行結(jié)果：
7. 隨機(jī)訪問流
7.1 RandomAccessFile概述
RandomAccessFile類不屬于流，是Object類的子類。但它融合了InputStream和OutputStream的功能。
此類的實例支持對隨機(jī)訪問文件的讀取和寫入。隨機(jī)訪問文件的行為類似存儲在文件系統(tǒng)中的一個大型 byte 數(shù)組。存在指向該隱含數(shù)組的光標(biāo)或索引，稱為文件指針；輸入操作從文件指針開始讀取字節(jié)，并隨著對字節(jié)的讀取而前移此文件指針。如果隨機(jī)訪問文件以讀取/寫入模式創(chuàng)建，則輸出操作也可用；輸出操作從文件指針開始寫入字節(jié)，并隨著對字節(jié)的寫入而前移此文件指針。寫入隱含數(shù)組的當(dāng)前末尾之后的輸出操作導(dǎo)致該數(shù)組擴(kuò)展。該文件指針可以通過 getFilePointer 方法讀取，并通過 seek 方法設(shè)置。
通常，如果此類中的所有讀取例程在讀取所需數(shù)量的字節(jié)之前已到達(dá)文件末尾，則拋出 EOFException（是一種 IOException）。如果由于某些原因無法讀取任何字節(jié)，而不是在讀取所需數(shù)量的字節(jié)之前已到達(dá)文件末尾，則拋出 IOException，而不是 EOFException。需要特別指出的是，如果流已被關(guān)閉，則可能拋出 IOException。
7.2 構(gòu)造方法
public RandomAccessFile(String name,String mode)
第一個參數(shù)是文件路徑，第二個參數(shù)是操作文件的模式。模式有四種，我們最常用的一種叫"rw",這種方式表示我既可以寫數(shù)據(jù)，也可以讀取數(shù)據(jù)
package cn.itcast_05;
import java.io.IOException;
import java.io.RandomAccessFile;
/*
* 隨機(jī)訪問流：
* RandomAccessFile類不屬于流，是Object類的子類。
* 但它融合了InputStream和OutputStream的功能。
* 支持對文件的隨機(jī)訪問讀取和寫入。
*
* public RandomAccessFile(String name,String mode)：第一個參數(shù)是文件路徑，第二個參數(shù)是操作文件的模式。
* 模式有四種，我們最常用的一種叫"rw",這種方式表示我既可以寫數(shù)據(jù)，也可以讀取數(shù)據(jù)
*/
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException {
// write();
read();
}
private static void read() throws IOException {
// 創(chuàng)建隨機(jī)訪問流對象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
int i = raf.readInt();
System.out.println(i);
// 該文件指針可以通過 getFilePointer方法讀取，并通過 seek 方法設(shè)置。
System.out.println("當(dāng)前文件的指針位置是：" + raf.getFilePointer());
char ch = raf.readChar();
System.out.println(ch);
System.out.println("當(dāng)前文件的指針位置是：" + raf.getFilePointer());
String s = raf.readUTF();
System.out.println(s);
System.out.println("當(dāng)前文件的指針位置是：" + raf.getFilePointer());
// 我不想重頭開始了，我就要讀取a，怎么辦呢?
raf.seek(4);
ch = raf.readChar();
System.out.println(ch);
}
private static void write() throws IOException {
// 創(chuàng)建隨機(jī)訪問流對象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
// 怎么玩呢?
raf.writeInt(100);
raf.writeChar('a');
raf.writeUTF("中國");
raf.close();
}
}
運(yùn)行結(jié)果：
8. 合并流
8.1 SequenceInputStream概述
SequenceInputStream類可以將多個輸入流串流在一起，合并為一個輸入流，因此，該流也被稱為合并流。
SequenceInputStream 表示其他輸入流的邏輯串聯(lián)。它從輸入流的有序集合開始，并從第一個輸入流開始讀取，直到到達(dá)文件末尾，接著從第二個輸入流讀取，依次類推，直到到達(dá)包含的最后一個輸入流的文件末尾為止。
8.2 SequenceInputStream的構(gòu)造方法
8.3 把多個文件的內(nèi)容寫入到一個文本文件
package cn.itcast_06;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/*
* 以前的操作：
* a.txt -- b.txt
* c.txt -- d.txt
* e.txt -- f.txt
*
* 現(xiàn)在想要：
* a.txt+b.txt+c.txt -- d.txt
*/
public class SequenceInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 需求：把下面的三個文件的內(nèi)容復(fù)制到Copy.java中
// ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java
// SequenceInputStream(Enumeration e)
// 通過簡單的回顧我們知道了Enumeration是Vector中的一個方法的返回值類型。
// Enumeration<E> elements()
Vector<InputStream> v = new Vector<InputStream>();
InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
InputStream s2 = new FileInputStream("CopyFileDemo.java");
InputStream s3 = new FileInputStream("DataStreamDemo.java");
v.add(s1);
v.add(s2);
v.add(s3);
Enumeration<InputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));
// 如何寫讀寫呢，其實很簡單，你就按照以前怎么讀寫，現(xiàn)在還是怎么讀寫
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
sis.close();
}
}
9. 序列化流
9.1 序列化流ObjectOutputStream
ObjectOutputStream 將 Java 對象的基本數(shù)據(jù)類型和圖形寫入 OutputStream。可以使用 ObjectInputStream 讀?。ㄖ貥?gòu)）對象。通過在流中使用文件可以實現(xiàn)對象的持久存儲。如果流是網(wǎng)絡(luò)套接字流，則可以在另一臺主機(jī)上或另一個進(jìn)程中重構(gòu)對象。
只能將支持 java.io.Serializable 接口的對象寫入流中。每個 serializable
對象的類都被編碼，編碼內(nèi)容包括類名和類簽名、對象的字段值和數(shù)組值，以及從初始對象中引用的其他所有對象的閉包。
writeObject 方法用于將對象寫入流中。所有對象（包括 String 和數(shù)組）都可以通過 writeObject 寫入?？蓪⒍鄠€對象或基元寫入流中。必須使用與寫入對象時相同的類型和順序從相應(yīng) ObjectInputstream 中讀回對象。
還可以使用 DataOutput 中的適當(dāng)方法將基本數(shù)據(jù)類型寫入流中。還可以使用 writeUTF 方法寫入字符串。
對象的默認(rèn)序列化機(jī)制寫入的內(nèi)容是：對象的類，類簽名，以及非瞬態(tài)和非靜態(tài)字段的值。其他對象的引用（瞬態(tài)和靜態(tài)字段除外）也會導(dǎo)致寫入那些對象。可使用引用共享機(jī)制對單個對象的多個引用進(jìn)行編碼，這樣即可將對象的圖形恢復(fù)為最初寫入它們時的形狀。
構(gòu)造方法：
ObjectOutputStream() ：為完全重新實現(xiàn) ObjectOutputStream 的子類提供一種方法，讓它不必分配僅由 ObjectOutputStream 的實現(xiàn)使用的私有數(shù)據(jù)。
ObjectOutputStream(OutputStream out) ：創(chuàng)建寫入指定 OutputStream 的 ObjectOutputStream。
9.2 反序列化流ObjectInputStream
1、ObjectInputStream 對以前使用 ObjectOutputStream 寫入的基本數(shù)據(jù)和對象進(jìn)行反序列化。
2、ObjectOutputStream 和 ObjectInputStream 分別與 FileOutputStream 和 FileInputStream 一起使用時，可以為應(yīng)用程序提供對對象圖形的持久存儲。ObjectInputStream 用于恢復(fù)那些以前序列化的對象。其他用途包括使用套接字流在主機(jī)之間傳遞對象，或者用于編組和解組遠(yuǎn)程通信系統(tǒng)中的實參和形參。
3、ObjectInputStream 確保從流創(chuàng)建的圖形中所有對象的類型與 Java 虛擬機(jī)中顯示的類相匹配。使用標(biāo)準(zhǔn)機(jī)制按需加載類。
4、只有支持 java.io.Serializable 或 java.io.Externalizable 接口的對象才能從流讀取。
5、readObject 方法用于從流讀取對象。應(yīng)該使用 Java 的安全強(qiáng)制轉(zhuǎn)換來獲取所需的類型。在 Java 中，字符串和數(shù)組都是對象，所以在序列化期間將其視為對象。讀取時，需要將其強(qiáng)制轉(zhuǎn)換為期望的類型。
6、可以使用 DataInput 上的適當(dāng)方法從流讀取基本數(shù)據(jù)類型。
7、默認(rèn)情況下，對象的反序列化機(jī)制會將每個字段的內(nèi)容恢復(fù)為寫入時它所具有的值和類型。反序列化進(jìn)程將忽略聲明為瞬態(tài)或靜態(tài)的字段。對其他對象的引用使得根據(jù)需要從流中讀取這些對象。使用引用共享機(jī)制能夠正確地恢復(fù)對象的圖形。反序列化時始終分配新對象，這樣可以避免現(xiàn)有對象被重寫。
8、序列化操作問題：NotSerializableException:未序列化異常
9、為什么要實現(xiàn)序列化?如何實現(xiàn)序列化?
類通過實現(xiàn) java.io.Serializable 接口以啟用其序列化功能。未實現(xiàn)此接口的類將無法使其任何狀態(tài)序列化或反序列化。
該接口居然沒有任何方法，類似于這種沒有方法的接口被稱為標(biāo)記接口
10、序列化數(shù)據(jù)后，再次修改類文件，讀取數(shù)據(jù)會出問題，如何解決呢?
每次修改java文件的內(nèi)容的時候,class文件的id值都會發(fā)生改變。而讀取文件的時候，會和class文件中的id值進(jìn)行匹配。所以，就會出問題。讓這個id值在java文件中是一個固定的值，這樣，你修改文件的時候，這個id值就不會發(fā)生改變。
我們要知道的是：看到類實現(xiàn)了序列化接口的時候，要想解決黃色警告線問題，就可以自動產(chǎn)生一個序列化id值。而且產(chǎn)生這個值以后，我們對類進(jìn)行任何改動，它讀取以前的數(shù)據(jù)是沒有問題的。
?
11、我一個類中可能有很多的成員變量，有些我不想進(jìn)行序列化。請問該怎么辦呢?
使用transient關(guān)鍵字聲明不需要序列化的成員變量
package cn.itcast_07;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
* 序列化流：把對象按照流一樣的方式存入文本文件或者在網(wǎng)絡(luò)中傳輸。對象 -- 流數(shù)據(jù)(ObjectOutputStream)
* 反序列化流:把文本文件中的流對象數(shù)據(jù)或者網(wǎng)絡(luò)中的流對象數(shù)據(jù)還原成對象。流數(shù)據(jù) -- 對象(ObjectInputStream)
*/
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// 由于我們要對對象進(jìn)行序列化，所以我們先自定義一個類
// 序列化數(shù)據(jù)其實就是把對象寫到文本文件
// write();
read();
}
private static void read() throws IOException, ClassNotFoundException {
// 創(chuàng)建反序列化對象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"oos.txt"));
// 還原對象
Object obj = ois.readObject();
// 釋放資源
ois.close();
// 輸出對象
System.out.println(obj);
}
private static void write() throws IOException {
// 創(chuàng)建序列化流對象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"oos.txt"));
// 創(chuàng)建對象
Person p = new Person("林青霞", 27);
// public final void writeObject(Object obj)
oos.writeObject(p);
// 釋放資源
oos.close();
}
}
10. Properties集合
10.1 Properties概述
- Properties：屬性集合類。是一個可以和IO流相結(jié)合使用的集合類。
- Properties 可保存在流中或從流中加載。屬性列表中每個鍵及其對應(yīng)值都是一個字符串。
- 是Hashtable的子類，說明是一個Map集合。
10.2 Properties的常用操作方法
10.2.1 構(gòu)造方法
Properties() // 創(chuàng)建一個無默認(rèn)值的空屬性列表。
Properties(Properties defaults) // 創(chuàng)建一個帶有指定默認(rèn)值的空屬性列表
10.2.2 Properties作為Map集合的使用
package cn.itcast_08;
import java.util.Properties;
import java.util.Set;
/*
* Properties:屬性集合類。是一個可以和IO流相結(jié)合使用的集合類。
* Properties 可保存在流中或從流中加載。屬性列表中每個鍵及其對應(yīng)值都是一個字符串。
*
* 是Hashtable的子類，說明是一個Map集合。
*/
public class PropertiesDemo {
public static void main(String[] args) {
// 作為Map集合的使用
// 下面這種用法是錯誤的，一定要看API，如果沒有<>，就說明該類不是一個泛型類,在使用的時候就不能加泛型
// Properties<String, String> prop = new Properties<String, String>();
Properties prop = new Properties();
// 添加元素
prop.put("it002", "hello");
prop.put("it001", "world");
prop.put("it003", "java");
// System.out.println("prop:" + prop);
// 遍歷集合
Set<Object> set = prop.keySet();
for (Object key : set) {
Object value = prop.get(key);
System.out.println(key + "---" + value);
}
}
}
運(yùn)行結(jié)果：
10.3 Properties的特殊功能
public Object setProperty(String key,String value) // 添加元素
public String getProperty(String key) // 獲取元素
public Set<String> stringPropertyNames() // 獲取所有的鍵的集合
package cn.itcast_08;
import java.util.Properties;
import java.util.Set;
/*
* 特殊功能：
* public Object setProperty(String key,String value)：添加元素
* public String getProperty(String key):獲取元素
* public Set<String> stringPropertyNames():獲取所有的鍵的集合
*/
public class PropertiesDemo2 {
public static void main(String[] args) {
// 創(chuàng)建集合對象
Properties prop = new Properties();
// 添加元素
prop.setProperty("張三", "30");
prop.setProperty("李四", "40");
prop.setProperty("王五", "50");
// public Set<String> stringPropertyNames():獲取所有的鍵的集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + "---" + value);
}
}
}
/*
* class Hashtalbe<K,V> { public V put(K key,V value) { ... } }
*
* class Properties extends Hashtable { public V setProperty(String key,String
* value) { return put(key,value); } }
*/
運(yùn)行結(jié)果：
10.4 Properties和IO流的結(jié)合使用
public void load(Reader reader) // 把文件中的數(shù)據(jù)讀取到集合中
public void store(Writer writer,String comments) // 把集合中的數(shù)據(jù)存儲到文件
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
/*
* 這里的集合必須是Properties集合：
* public void load(Reader reader):把文件中的數(shù)據(jù)讀取到集合中
* public void store(Writer writer,String comments):把集合中的數(shù)據(jù)存儲到文件
*
* 單機(jī)版游戲：
* 進(jìn)度保存和加載。
* 三國群英傳，三國志，仙劍奇?zhèn)b傳...
*
* 呂布=1
* 方天畫戟=1
*/
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
// myLoad();
myStore();
}
private static void myStore() throws IOException {
// 創(chuàng)建集合對象
Properties prop = new Properties();
prop.setProperty("林青霞", "27");
prop.setProperty("武鑫", "30");
prop.setProperty("劉曉曲", "18");
//public void store(Writer writer,String comments):把集合中的數(shù)據(jù)存儲到文件
Writer w = new FileWriter("name.txt");
prop.store(w, "helloworld");
w.close();
}
private static void myLoad() throws IOException {
Properties prop = new Properties();
// public void load(Reader reader):把文件中的數(shù)據(jù)讀取到集合中
// 注意：這個文件的數(shù)據(jù)必須是鍵值對形式
Reader r = new FileReader("prop.txt");
prop.load(r);
r.close();
System.out.println("prop:" + prop);
}
}
10.5 Properties練習(xí)
我有一個文本文件，我知道數(shù)據(jù)是鍵值對形式的，但是不知道內(nèi)容是什么。請寫一個程序判斷是否有“l(fā)isi”這樣的鍵存在，如果有就改變其實為”100”
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
/*
* 我有一個文本文件(user.txt)，我知道數(shù)據(jù)是鍵值對形式的，但是不知道內(nèi)容是什么。
* 請寫一個程序判斷是否有“l(fā)isi”這樣的鍵存在，如果有就改變其實為”100”
*
* 分析：
* A:把文件中的數(shù)據(jù)加載到集合中
* B:遍歷集合，獲取得到每一個鍵
* C:判斷鍵是否有為"lisi"的，如果有就修改其值為"100"
* D:把集合中的數(shù)據(jù)重新存儲到文件中
*/
public class PropertiesTest {
public static void main(String[] args) throws IOException {
// 把文件中的數(shù)據(jù)加載到集合中
Properties prop = new Properties();
Reader r = new FileReader("user.txt");
prop.load(r);
r.close();
// 遍歷集合，獲取得到每一個鍵
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
// 判斷鍵是否有為"lisi"的，如果有就修改其值為"100"
if ("lisi".equals(key)) {
prop.setProperty(key, "100");
break;
}
}
// 把集合中的數(shù)據(jù)重新存儲到文件中
Writer w = new FileWriter("user.txt");
prop.store(w, null);
w.close();
}
}
我有一個猜數(shù)字小游戲的程序，請寫一個程序?qū)崿F(xiàn)在測試類中只能用5次，超過5次提示：游戲試玩已結(jié)束，請付費(fèi)。
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
/*
* 我有一個猜數(shù)字小游戲的程序，請寫一個程序?qū)崿F(xiàn)在測試類中只能用5次，超過5次提示：游戲試玩已結(jié)束，請付費(fèi)。
*/
public class PropertiesTest2 {
public static void main(String[] args) throws IOException {
// 讀取某個地方的數(shù)據(jù)，如果次數(shù)不大于5，可以繼續(xù)玩。否則就提示"游戲試玩已結(jié)束，請付費(fèi)。"
// 創(chuàng)建一個文件
// File file = new File("count.txt");
// if (!file.exists()) {
// file.createNewFile();
// }
// 把數(shù)據(jù)加載到集合中
Properties prop = new Properties();
Reader r = new FileReader("count.txt");
prop.load(r);
r.close();
// 我自己的程序，我當(dāng)然知道里面的鍵是誰
String value = prop.getProperty("count");
int number = Integer.parseInt(value);
if (number > 5) {
System.out.println("游戲試玩已結(jié)束，請付費(fèi)。");
System.exit(0);
} else {
number++;
prop.setProperty("count", String.valueOf(number));
Writer w = new FileWriter("count.txt");
prop.store(w, null);
w.close();
GuessNumber.start();
}
}
}
