Java語言深入 文件和流

　　Java I/O系統的類實在是太多了這裡我們只學習一些基本的和常用的相信能夠掌握這些就可以解決我們以後的普通應用了

什麼是數據流 ?
數據流是指所有的數據通信通道
有兩類流InputStream and OutputStreamJava中每一種流的基本功能依賴於它們
InputStream 用於readOutputStream 用於write 讀和寫都是相對與內存說的讀就是從其他地方把數據拿進內存寫就是把數據從內存推出去
這兩個都是抽象類不能直接使用
InputStream 的方法有
read() 從流中讀入數據 有中方式
int read() 一次讀一個字節
int read(byte[]) 讀多個字節到數組中
int read(byte[]int offint len) 指定從數組的哪裡開始讀多長
skip() 跳過流中若干字節
available() 返回流中可用字節數但基於網絡時無效返回
markSupported() 判斷是否支持標記與復位操作
mark() 在流中標記一個位置要與markSupported()連用
reset() 返回標記過的位置
close() 關閉流
OutputStream 的方法:
write(int) 寫一個字節到流中
write(byte[]) 將數組中的內容寫到流中
write(byte[]int offint len) 將數組中從off指定的位置開始len長度的數據寫到流中
close() 關閉流
flush() 將緩沖區中的數據強制輸出
File 類
File 可以表示文件也可以表示目錄File 類控制所有硬盤操作
構造器
File(File parentString child) 用父類和文件名構造
File(String pathname) 用絕對路徑構造
File(String parentString child) 用父目錄和文件名構造
File(URI uri) 用遠程文件構造
常用方法
boolean createNewFile();
boolean exists();

例子
//建立 testtxt 文件對象判斷是否存在不存在就創建
import javaio*;

public class CreateNewFile{
public static void main(String args[]){
File f=new File(testtxt);
try{
if(!fexists())
fcreateNewFile();
else
Systemoutprintln(exists);
}catch(Exception e){
eprintStackTrace();
}
}
}

boolean mkdir()/mkdirs()
boolean renameTo(File destination)
例子//看一下這 mkdir()/mkdirs() 的區別和 renameTo 的用法
import javaio*;
public class CreateDir{
public static void main(String args[]){
File f=new File(testtxt);
File f=new File(Dir);
File f=new File(Top/Bottom);
File f=new File(newTesttxt);
try{
frenameTo(f);
fmkdir();
fmkdirs();
}catch(Exception e){
eprintStackTrace();
}
}
}

String getPath()/getAbsolutePath()
String getParent()/getName()
例子//硬盤上並沒有parent 目錄和 testtxt 文件但我們仍然可以操作因為我們創建了他們的對象是對對象進行操作
import javaio*;
public class Test{
public static void main(String args[]){
File f=new File(parent/testtxt);
File f=new File(newTesttxt);
try{
Systemoutprintln(fgetParent());
Systemoutprintln(fgetName());
Systemoutprintln(fgetPath());
Systemoutprintln(fgetAbsolutePath());
}catch(Exception e){
eprintStackTrace();
}
}
}

　　String list[] //顯示目錄下所有文件
long lastModified() //返回  到最後修改時間的秒數
boolean isDirectory()
例子//列出目錄下的所有文件和目錄最後修改時間是目錄的後面標出<DIR>是文件的後面標出文件長度
import javaio*;
import javautil*;
public class Dir{
public static void main(String args[]){
File f=new File(Dir);
String[] listAll=null;
File temp=null;
try{
listAll=flist();
for(int i=;i<listAlllength;i++){
temp=new File(listAll<i>);
Systemoutprint(listAll<i>+\t);
if(tempisDirectory())
Systemoutprint(\t<DIR>\t);
else
Systemoutprint(templength()+\t);
Systemoutprintln(new Date(templastModified()));
}
}catch(Exception e){
eprintStackTrace();
}
}
}



文件流的建立
File f=new File(temptxt);
FileInputStream in=new FileInputStream(f);
FileOutputStream out=new FileOutputStream(f);

例子文件拷貝
import javaio*;
public class Copy{
public static void main(String args[]){
FileInputStream fis=null;
FileOutputStream fos=null;
try{
fis=new FileInputStream(cgif);
fos=new FileOutputStream(c_copygif);
int c;
while((c=fisread()) != )
foswrite(c);
}catch(Exception e){
eprintStackTrace();
}finally{
if(fis != null) try{ fisclose(); }catch(Exception e){ eprintStackTrace(); }
if(fos!= null) try{ fosclose(); }catch(Exception e){ eprintStackTrace(); }
}
}
}


緩沖區流
BufferedInputStream
BufferedOutputStream
他們是在普通文件流上加了緩沖的功能所以構造他們時要先構造普通流
例子文件拷貝的緩沖改進

import javaio*;
public class Copy{
public static void main(String args[]){
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
byte buf[]=new byte[];
try{
bis=new BufferedInputStream(new FileInputStream(persiamp));
bos=new BufferedOutputStream(new FileOutputStream(persia_copymp));
int len=;
while( true ){
len=bisread(buf);
if(len<=) break;
boswrite(buflen);
}
bosflush();//緩沖區只有滿時才會將數據輸出到輸出流用flush()將未滿的緩沖區中數據強制輸出
}catch(Exception e){
eprintStackTrace();
}finally{
if(bis != null) try{ bisclose(); }catch(Exception e){ eprintStackTrace(); }
if(bos!= null) try{ bosclose(); }catch(Exception e){ eprintStackTrace(); }
}
}
}


原始型數據流
DataInputStream
DataOutputStream
他們是在普通流上加了讀寫原始型數據的功能所以構造他們時要先構造普通流
方法
readBoolean()/writeBoolean()
readByte()/writeByte()
readChar()/writeByte()


例子//這個流比較簡單要注意的就是讀時的順序要和寫時的一樣
import javaio*;
public class DataOut{
public static void main(String args[]){
DataOutputStream dos=null;
try{
dos=new DataOutputStream(new FileOutputStream(dataouttxt));
doswriteInt();
doswriteBoolean(true);
doswriteLong(L);
doswriteChar(a);
}catch(Exception e){
eprintStackTrace();
}finally{
if(dos!=null)
try{
dosclose();
}catch(Exception e){
}
}
}
}

import javaio*;
public class DataIn{
public static void main(String args[]){
DataInputStream dis=null;
try{
dis=new DataInputStream(new FileInputStream(dataouttxt));
Systemoutprintln(disreadInt());
Systemoutprintln(disreadBoolean());
Systemoutprintln(disreadLong());
Systemoutprintln(disreadChar());
}catch(Exception e){
eprintStackTrace();
}finally{
if(dis!=null)
try{
disclose();
}catch(Exception e){
}
}
}
}

　　對象流
串行化對象通過寫出描述自己狀態的數值來記述自己的過程叫串行話
對象流能夠輸入輸出對象的流
將串行化的對象通過對象流寫入文件或傳送到其他地方
對象流是在普通流上加了傳輸對象的功能所以構造對象流時要先構造普通文件流
注意只有實現了Serializable接口的類才能被串行化
例子
import javaio*;
class Student implements Serializable{
private String name;
private int age;

public Student(String nameint age){
thisname=name;
thisage=age;
}

public void greeting(){
Systemoutprintln(hello my name is +name);
}

public String toString(){
return Student[+name++age+];
}
}
public class ObjectOutTest{
public static void main(String args[]){
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(
new FileOutputStream(studenttxt));
Student s=new Student(Jerry);
Student s=new Student(Andy);

ooswriteObject(s);
ooswriteObject(s);
}catch(Exception e){
eprintStackTrace();
}finally{
if(oos!=null)
try{
oosclose();
}catch(Exception e){
eprintStackTrace();
}
}
}
}

import javaio*;
public class ObjectInTest{
public static void main(String args[]){
ObjectInputStream ois=null;
Student s=null;
try{
ois=new ObjectInputStream(
new FileInputStream(studenttxt));
Systemoutprintln();
s=(Student)oisreadObject();
Systemoutprintln(s);
sgreeting();
Systemoutprintln();
s=(Student)oisreadObject();
Systemoutprintln(s);
sgreeting();
}catch(Exception e){
eprintStackTrace();
}finally{
if(ois!=null)
try{
oisclose();
}catch(Exception e){
eprintStackTrace();
}
}
}
}


字符流 InputStreamReader/OutputStreamWriter
上面的幾種流的單位是 byte所以叫做字節流寫入文件的都是二進制字節我們無法直接看下面要學習的是字節流
Java采用 Unicode 字符集每個字符和漢字都采用個字節進行編碼ASCII 碼是 Unicode 編碼的自集
InputStreamReader 是 字節流 到 字符橋的橋梁 （ byte>char 讀取字節然後用特定字符集編碼成字符)
OutputStreamWriter是 字符流 到 字節流的橋梁 （ char>byte )
他們是在字節流的基礎上加了橋梁作用所以構造他們時要先構造普通文件流
我們常用的是:
BufferedReader 方法readLine()
PrintWriter 方法println()

例子
import javaio*;
public class PrintWriterTest{
public static void main(String args[]){
PrintWriter pw=null;
try{
pw=new PrintWriter(
new OutputStreamWriter(
new FileOutputStream(bufferedwritertxt)));
pwprintln(hello world);
}catch(Exception e){
eprintStackTrace();
}finally{
if(pw!=null)
try{
pwclose();
}catch(Exception e){
eprintStackTrace();
}
}
}
}

　　import javaio*;
public class BufferedReaderTest{
public static void main(String args[]){
BufferedReader br=null;
try{
br=new BufferedReader(
new InputStreamReader(
new FileInputStream(bufferedwritertxt)));
Systemoutprintln(brreadLine());
}catch(Exception e){
eprintStackTrace();
}finally{
if(br!=null)
try{
brclose();
}catch(Exception e){
eprintStackTrace();
}
}
}
}

隨機存取文件 RandomAccessFile
可同時完成讀寫操作
支持隨機文件操作的方法:
readXXX()/writeXXX()
seek() 將指針調到所需位置
getFilePointer() 返回指針當前位置
length() 返回文件長度
例子把若干個位的整數寫到一個名為 temptxt的文件中然後利用seek方法以相反的順序再讀取這些數據
import javaio*;
public class RandomFile{
public static void main(String args[]){
RandomAccessFile raf=null;
int data[]={};
try{
raf=new RandomAccessFile(temptxtrw);
for(int i=;i<datalength;i++)
rafwriteInt(data<i>);
for(int i=datalength;i>=;i){
rafseek(i*);
Systemoutprintln(rafreadInt());
}
}catch(Exception e){
egetMessage();
}finally{
if(raf!=null)
try{
rafclose();
}catch(Exception e){
egetMessage();
}
}
}
}


小結
這部分的難點就是類比較復雜尤其是每個類的構造方式我認為記住下面這個圖比記類的繼承關系更好些

a 字節流
InputStream
| FileInputStream (基本文件流）
| BufferedInputStream
| DataInputStream
| ObjectInputStream
OutputStream 同上圖
BufferedInputStream DataInputStream ObjectInputStream 只是在 FileInputStream 上增添了相應的功能構造時先構造FileInputStream

b 字符流
Reader
| InputStreamReader (byte>char 橋梁）
| BufferedReader (常用）

Writer
| OutputStreamWriter (char>byte 橋梁）
| BufferedWriter
| PrintWriter （常用）

c 隨機存取文件 RandomAccessFile

From:http://tw.wingwit.com/Article/program/Java/hx/201311/26725.html