流的操作規律
1. 明確源和目的。
數據源：就是需要讀取，可以使用兩個體系：InputStream、Reader；
數據匯：就是需要寫入，可以使用兩個體系：OutputStream、Writer；
2. 操作的數據是否是純文本數據？
如果是：數據源：Reader
數據匯：Writer
如果不是：數據源：InputStream
數據匯：OutputStream
3. 雖然確定了一個體系，但是該體系中有太多的對象，到底用哪個呢？
明確操作的數據設備。
數據源對應的設備：硬盤(File)，內存(數組)，鍵盤(System.in)
數據匯對應的設備：硬盤(File)，內存(數組)，控制檯(System.out)。
4，需要在基本操作上附加其他功能嗎？比如緩衝。
如果需要就進行裝飾。
————————————————————————————————————
以下內容爲引用資料
PrintStream(File file) ：創建具有指定文件且不帶自動行刷新的新打印流。
PrintStream(File file, String csn) ：創建具有指定文件名稱和字符集且不帶自動行刷新的新打印流。
PrintStream(OutputStream out) ：創建新的打印流。
PrintStream(OutputStream out, boolean autoFlush) ：創建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding) ：創建新的打印流。
PrintStream(String fileName) ：創建具有指定文件名稱且不帶自動行刷新的新打印流。
PrintStream(String fileName, String csn)
PrintStream可以操作目的：
1. File對象。2. 字符串路徑。3. 字節輸出流。
前兩個都JDK1.5版本纔出現。而且在操作文本文件時，可指定字符編碼了。
當目的是一個字節輸出流時，如果使用的println方法，可以在printStream對象上加入一個true參數。這樣對於println方法可以進行自動的刷新，而不是等待緩衝區滿了再刷新。最終print方法都將具體的數據轉成字符串，而且都對IO異常進行了內部處理。
既然操作的數據都轉成了字符串，那麼使用PrintWriter更好一些。因爲PrintWrite是字符流的子類，可以直接操作字符數據，同時也可以指定具體的編碼。
PrintWriter：具備了PrintStream的特點同時，還有自身特點：
該對象的目的地有四個：1：File對象。2：字符串路徑。3：字節輸出流。4：字符輸出流。
開發時儘量使用PrintWriter。
方法中直接操作文件的第二參數是編碼表。
直接操作輸出流的，第二參數是自動刷新。
//讀取鍵盤錄入將數據轉成大寫顯示在控制檯.
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//源：鍵盤輸入
//目的：把數據寫到文件中，還想自動刷新。
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);//設置true後自動刷新
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
out.println(line.toUpperCase());//轉大寫輸出
}
//注意：System.in，System.out這兩個標準的輸入輸出流，在jvm啓動時已經存在了。隨時可以使用。當jvm結束了，這兩個流就結束了。但是，當使用了顯示的close方法關閉時，這兩個流在提前結束了。
out.close();
bufr.close();SequenceInputStream：序列流，作用就是將多個讀取流合併成一個讀取流。實現數據合併。
表示其他輸入流的邏輯串聯。它從輸入流的有序集合開始，並從第一個輸入流開始讀取，直到到達文件末尾，接着從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾爲止。
這樣做，可以更方便的操作多個讀取流，其實這個序列流內部會有一個有序的集合容器，用於存儲多個讀取流對象。
該對象的構造函數參數是枚舉，想要獲取枚舉，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中沒有枚舉，只有自己去創建枚舉對象。
但是方法怎麼實現呢？因爲枚舉操作的是具體集合中的元素，所以無法具體實現，但是枚舉和迭代器是功能一樣的，所以，可以用迭代替代枚舉。
合併原理：多個讀取流對應一個輸出流。
切割原理：一個讀取流對應多個輸出流。
import java.io.*;
import java.util.*;
class SplitFileDemo{
private static final String CFG = ".properties";
private static final String SP = ".part";
public static void main(String[] args) throws IOException{
File file = new File("c:\\0.bmp");
File dir = new File("c:\\partfiles");
meger(dir);
}
//數據的合併。
public static void meger(File dir)throws IOException{
if(!(dir.exists() && dir.isDirectory()))
throw new RuntimeException("指定的目錄不存在，或者不是正確的目錄");
File[] files = dir.listFiles(new SuffixFilter(CFG));
if(files.length==0)
throw new RuntimeException("擴展名.proerpties的文件不存在");
//獲取到配置文件
File config = files[0];
//獲取配置文件的信息。
Properties prop = new Properties();
FileInputStream fis = new FileInputStream(config);
prop.load(fis);
String fileName = prop.getProperty("filename");
int partcount = Integer.parseInt(prop.getProperty("partcount"));
//--------------------------
File[] partFiles = dir.listFiles(new SuffixFilter(SP));
if(partFiles.length!=partcount)
throw new RuntimeException("缺少碎片文件");
//---------------------
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=0; x<partcount; x++){
al.add(new FileInputStream(new File(dir,x+SP)));
}
Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);
File file = new File(dir,fileName);
FileOutputStream fos = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
//帶有配置信息的數據切割。
public static void splitFile(File file)throws IOException{
//用一個讀取流和文件關聯。
FileInputStream fis = new FileInputStream(file);
//創建目的地。因爲有多個。所以先創建引用。
FileOutputStream fos = null;
//指定碎片的位置。
File dir = new File("c:\\partfiles");
if(!dir.exists())
dir.mkdir();
//碎片文件大小引用。
File f = null;
byte[] buf = new byte[1024*1024];
//因爲切割完的文件通常都有規律的。爲了簡單標記規律使用計數器。
int count = 0;
int len = 0;
while((len=fis.read(buf))!=-1){
f = new File(dir,(count++)+".part");
fos = new FileOutputStream(f);
fos.write(buf,0,len);
fos.close();
}
//碎片文件生成後，還需要定義配置文件記錄生成的碎片文件個數。以及被切割文件的名稱。
//定義簡單的鍵值信息，可是用Properties。
String filename = file.getName();
Properties prop = new Properties();
prop.setProperty("filename",filename);
prop.setProperty("partcount",count+"");
File config = new File(dir,count+".properties");
fos = new FileOutputStream(config);
prop.store(fos,"");
fos.close();
fis.close();
}
}
class SuffixFilter implements FileFilter{
private String suffix;
SuffixFilter(String suffix){
this.suffix = suffix;
}
public boolean accept(File file){
return file.getName().endsWith(suffix);
}
}RandomAccessFile:
特點：
- 該對象即可讀取，又可寫入。
- 該對象中的定義了一個大型的byte數組，通過定義指針來操作這個數組。
- 可以通過該對象的getFilePointer()獲取指針的位置，通過seek()方法設置指針的位置。
- 該對象操作的源和目的必須是文件。
- 其實該對象內部封裝了字節讀取流和字節寫入流。
注意：實現隨機訪問，最好是數據有規律。
class RandomAccessFileDemo{
public static void main(String[] args) throws IOException{
write();
read();
randomWrite();
}
//隨機寫入數據，可以實現已有數據的修改。
public static void randomWrite()throws IOException{
RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
raf.seek(8*4);
System.out.println("pos :"+raf.getFilePointer());
raf.write("王武".getBytes());
raf.writeInt(102);
raf.close();
}
public static void read()throws IOException{
RandomAccessFile raf = new RandomAccessFile("random.txt","r");//只讀模式。
//指定指針的位置。
raf.seek(8*1);//實現隨機讀取文件中的數據。注意：數據最好有規律。
System.out.println("pos1 :"+raf.getFilePointer());
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println(name+"::"+age);
System.out.println("pos2 :"+raf.getFilePointer());
raf.close();
}
public static void write()throws IOException{
//rw：當這個文件不存在，會創建該文件。當文件已存在，不會創建。所以不會像輸出流一樣覆蓋。
RandomAccessFile raf = new RandomAccessFile("random.txt","rw");//rw讀寫模式
//往文件中寫入人的基本信息，姓名，年齡。
raf.write("張三".getBytes());
raf.writeInt(97);
raf.close();
}
}管道流：
管道讀取流和管道寫入流可以像管道一樣對接上，管道讀取流就可以讀取管道寫入流寫入的數據。
注意：
需要加入多線程技術，因爲單線程，先執行read，會發生死鎖，因爲read方法是阻塞式的，沒有數據的read方法會讓線程等待。
public static void main(String[] args) throws IOException{
PipedInputStream pipin = new PipedInputStream();
PipedOutputStream pipout = new PipedOutputStream();
pipin.connect(pipout);
new Thread(new Input(pipin)).start();
new Thread(new Output(pipout)).start();
}對象的序列化目的：
將一個具體的對象進行持久化，寫入到硬盤上。
注意：
靜態數據不能被序列化，因爲靜態數據不在堆內存中，是存儲在靜態方法區中。
如何將非靜態的數據不進行序列化？用transient 關鍵字修飾此變量即可。
Serializable：
用於啓動對象的序列化功能，可以強制讓指定類具備序列化功能，該接口中沒有成員，這是一個標記接口。這個標記接口用於給序列化類提供UID。這個uid是依據類中的成員的數字簽名進行運行獲取的。如果不需要自動獲取一個uid，可以在類中，手動指定一個名稱爲serialVersionUID id號。依據編譯器的不同，或者對信息的高度敏感性。最好每一個序列化的類都進行手動顯示的UID的指定。
import java.io.*;
class ObjectStreamDemo {
public static void main(String[] args) throws Exception{
writeObj();
readObj();
}
public static void readObj()throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Object obj = ois.readObject();//讀取一個對象。
System.out.println(obj.toString());
}
public static void writeObj()throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",25)); //寫入一個對象。
oos.close();
}
}
class Person implements Serializable{
private static final long serialVersionUID = 42L;
private transient String name;//用transient修飾後name將不會進行序列化
public int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name+"::"+age;
}
}
DataOutputStream、DataInputStream：專門用於操作基本數據類型數據的對象。
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(256);
dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
System.out.println(num);
dis.close();ByteArrayInputStream：源：內存
ByteArrayOutputStream：目的：內存。
這兩個流對象不涉及底層資源調用，操作的都是內存中數組，所以不需要關閉。
直接操作字節數組就可以了，爲什麼還要把數組封裝到流對象中呢？因爲數組本身沒有方法，只有一個length屬性。爲了便於數組的操作，將數組進行封裝，對外提供方法操作數組中的元素。
對於數組元素操作無非兩種操作：設置（寫）和獲取（讀），而這兩操作正好對應流的讀寫操作。這兩個對象就是使用了流的讀寫思想來操作數組。
//創建源：
ByteArrayInputStream bis = new ByteArrayInputStream("abcdef".getBytes());
//創建目的：
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int ch = 0;
while((ch=bis.read())!=-1){
bos.write(ch);
}
System.out.println(bos.toString());
