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