* 一個漢字是一個字符,就是2個字節,就是16位,所以,要讀取漢字,還得用字符流
*-------------------------------------- 基礎流----------------------------------------------
*/
FileInputStream ://(字節輸入流,一次讀取1個字節(就是8位))
FileInputStream fis = new FileInputStream("文件路徑");//字節輸入流
FileOutputStream : //(字節輸出流,一次讀取1個字節(就是8位))
FileOutputStream fis = new FileOutputStream("文件路徑",true);//字節輸出流 true不寫默認爲覆蓋指定文件的內容,寫了就是在內容後追加
FileReader : //(字符輸入流,一次讀取1個字符,就是2個字節(就是16位))
FileReader fis = new FileReader("文件路徑");//字符輸入流
FileWriter : //(字符輸出流,一次讀取1個字符,就是2個字節(就是16位))
FileWriter fis = new FileWeriter("文件路徑,true");//字符輸出流,true不寫默認爲覆蓋指定文件的內容,寫了就是在內容後追加
/**
*-------------------------------------- 緩衝流----------------------------------------------
*/
BufferedInputStream : //(字節輸入流的緩衝流)
1.BufferedInputStream br = new BufferedInputStream( new FileInputStream("文件路徑") );//字節輸入流的緩衝流
2.FileInputStream fis = new FileInputStream("文件路徑");//創建原始流
BufferedInputStream br = new BufferedInputStream( fis );//緩衝流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版
BufferedOutputStream : //(字節輸出流的緩衝流)
1 BufferedOutputStream br = new BufferedOutputStream( new FileOutputStream("文件路徑,true") );//字節輸出流的緩衝流
2.FileOutputStream fis = new FileOutputStream("文件路徑,true");//創建原始流 true不寫默認爲覆蓋指定文件的內容,寫了就是在內容後追加
BufferedOutputStream br = new BufferedOutputStream( fis );//緩衝流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版
BufferedReader : //(字符輸入流的緩衝流)
1 BufferedReader br = new BufferedReader( new FileReader("文件路徑") );//字符輸入流的緩衝流
2.FileReader fis = new FileReader("文件路徑");//創建原始流
BufferedReader br = new BufferedReader( fis );//緩衝流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版
BufferedWriter : //(字符輸出流的緩衝流)
1 BufferedWriter br = new BufferedWriter( new FileWriter("文件路徑,true") );//字符輸出流的緩衝流
2.FileWriter fis = new FileWriter("文件路徑,true");//創建原始流 true不寫默認爲覆蓋指定文件的內容,寫了就是在內容後追加
BufferedWriter br = new BufferedWriter( fis );//緩衝流 這兩種是一樣的,不過上面的那個相對簡單一些,就是簡寫版
/**
*-------------------------------------- 轉換流----------------------------------------------
*/
InputStreamReader : //(將字節輸入流轉爲字符輸入流)
1.InputStreamReader is = new InputStreamReader( new FileInputStream("文件路徑") );//將字節輸入流,轉爲字符輸入流,是下面的簡寫
2.FileInputStream fis = new FileInputStream("文件路徑");//創建字節原始流
InputStreamReader is = new InputStreamReader( fis );//轉換爲字符流
OutputStreamWriter : //(將字節輸出流轉爲字符輸出流)
1.InputStreamWriter is = new InputStreamWriter( new FileOutputStream("文件路徑,true") );//將字節輸出流,轉爲字符輸出流,是下面的簡寫,這裏不寫true,就是覆蓋指定文件中的內容,寫了就是內容內容後面追加
2.FileOutputStream fis = new FileOutputStream("文件路徑,true");//創建字節原始流
InputStreamWriter is = new InputStreamWriter( fis );//轉換爲字符流
/**
*------------------------------------------------------------------------------------------
*/
PRintStream :
//打印流
PrintStream ps = System.out;//(打印流)儘管沒有new,是因爲out是個靜態成員變量(靜態變量),在類加載的時候,成員類就被加載了,所以可以直接加載這個方法m
Geng_Gai_Wei_Zhi :
System.setOut() : //更改輸出位置
System.setOut(new PrintStream(new FileOutputStream("./fos_tmp_01.txt")));//這裏指定了系統默認輸出位置,這裏 是個jvm系統,會更改系統默認的位置
SimpleDateFormat :
//日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
lastModified :
//最後的修改時間
Date t = new Date(f1.lastModified());
System.out.println( new SimpleDateFormat("yyy-MM-dd HH:mm:ss SSS").format(t) );//返回的是時間 , 年月日,時分秒,毫秒,也就是上面指定的格式
DataOutputStream :
//(輸出,輸入,就是針對當前文件的進出,這裏是輸出,是把當前文件的東西,輸出到指定的文件夾中,並加密,)
DataOutputStream dos = new DataOutputStream(new FileOutputStream("./fos_tmp_01.txt"));//把添加進去的數據進行封裝,就跟加密一樣,要想查看,就要按照添加的順序去查看
byte b = 10;//變量(數據)
short s = 11;
int i = 12;
long l = 100L;
float f = 3.2f;
double d = 2.3;
boolean flag = false;
char c = 'a';
dos.writeByte(b);//添加數據
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(flag);
dos.writeChar(c);
dos.flush();//磕兩下
dos.close();//關閉資源
DataInputStream :
//(輸出,輸入,就是針對當前文件的進出,這裏是輸入,是把外面的文件的東西,輸入到當前,且 一定要按照上面輸出的時候的順序,來讀取)
DataInputStream dis = new DataInputStream(new FileInputStream("./fos_tmp_01.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();
boolean flag = dis.readBoolean();
char c = dis.readChar();
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( flag );
System.out.println( c );
dis.close();//關閉資源
File :
//文件和目錄路徑名的抽象表示形式。(抽象就是沒有的,這裏說的是內存對象裏面創建的,並不是硬盤創建的)
File f1 = new File("E:/第二期學習課程總彙/java/day11_IO/IO_01_FileInputStream_01.java");// 構造函數並不是創建新文件用的,文件是在硬盤中的,但是這裏只是把文件對象複製到內存而已,然後返回找到這個文件的路徑;
getAbsolutePath :
//返回此抽象路徑名的絕對路徑名字符串
getAbsolutePath() : //說白了,就是獲得文件的全路徑(絕對路徑) 如 : ( E:/第二期學習課程總彙/java/day11_IO/IO_01_FileInputStream_01.java )
getName :
//返回由此抽象路徑名錶示的文件或目錄的名稱。
getName() : //說白了就是隻獲得文件的文件名,和擴展名,如 : ( IO_01_FileInputStream_01.java )
getParent :
//返回此抽象路徑名父目錄的路徑名字符串;如果此路徑名沒有指定父目錄,則返回 null。
getParent() : //說白了,就是獲得當前文件的目錄,就是 ./ 如 : ( E:/第二期學習課程總彙/java/day11_IO )
isFile :
isFile();//判斷是不是文件 返回值是boolean true/false
System.out.println( f1.isFile() );//判斷f1是不是文件 true
isDirectory :
isDirectory();//判斷是不是目錄 返回值是boolean true.false
System.out.println( f1.isDirectory() ); //判斷f1是不是目錄 false
createNewFile :
createNewFile();//這個是創建文件(不是創建目錄) 返回值是boolean true/false 如果有這個文件,或者是沒有這個目錄,就返回false 如果有這個目錄,沒有這個文件,創建成功,返回true
System.out.println( f1.createNewFile() );
length :
length();//獲取文本的長度,返回值是文本的長度
System.out.println( f1.length() );
listFiles :
File f2 = new File("E:/第二期學習課程總彙/java/day11_IO/");// 構造函數並不是創建新文件用的,文件是在硬盤中的,但是這裏只是把文件對象複製到內存而已,然後返回找到這個文件的路徑;
//列出子文件 就是把指定的目錄每一個文件添加到數組中,在遍歷數組
File[] fs = f2.listFiles();//創建一個數組,把指定的目錄裏面的文件都添加到數組,在遍歷數組
for(File f:fs){//foreach循環(for的增強版 只能遍歷集合和數組)
System.out.println( f.getAbsolutePath() );//返回文件的全路徑(這裏是遍歷,就是把每個文件都輸出全路徑)
}
endsWith :
endsWith();//篩選
File[] fs = f2.listFiles();//創建一個數組,把指定的目錄裏面的文件都添加到數組,在遍歷數組
for(File f:fs){
if (f.getAbsolutePath().endsWith(".java")) {//篩選,以.java結束的文件
System.out.println( f.getAbsolutePath() );//獲得文件的全路徑
}
}
Wen_Jian_Fu_Zhi : //文件複製(數組)
//輸入流的方法 : FileInputStream
1.read(); 2.read(bytes);//下面有方法的例子和解釋
//輸出流的放法 : FileOutputStream
3.writer(); 4.write(bytes,0,tmp);//下面有方法的例子和解釋
5. flush();//磕兩下,往輸出流裏面添加懂東西了,就要磕兩下,要麼容易出錯
//字節(文本)複製
FileInputStream :
FileOutputStream :
try(
FileInputStream fis = new FileInputStream("./IO流.java");//輸入流 , 把指定文件中的數據,讀取(輸入)到當前文件中
FileOutputStream fos = new FileOutputStream("./新建文本文檔.txt");//輸出流 , 把指定的數據,輸出到指定的文件中去
){
byte[] bytes = new byte[1024];//動態聲明一個byte數組,且1024個字節
int tmp;//爲什麼用int聲明?因爲read(bytes);返回值是bytes這個數組中,添加元素的個數(字節數),如果達到了指定的個數(這裏是1024),tmp就會爲0,數組也會清空,然後依次循環,且 當讀取到最後一位的時候,返回值爲-1
while((tmp = fis.read(bytes)) != -1){//這是判斷語句,當輸入流指定的文件中,讀取到最後一位的時候,就會返回-1,然後這個tmp != -1 判斷語句 就爲false 就不在循環了
fos.write(bytes,0,tmp);//將bytes數組,從下標爲0開始,輸出tmp個,(tmp就代表是數組裏面已添加的字節個數)
}
fos.flush();//磕兩下,往輸出流指定的文件中添加東西,都要磕兩下
}catch(Exception e){//捕捉異常
e.printStackTrace();//對異常進行打印追蹤棧幀
}
read :
read();//讀取指定文件,默認一次讀取1字節,並且返回值是下一個字節的值(因爲讀取的時候,讀取指針是在頂端的,並不是在第一個字節) 如果到達最後一位字節的時候(就是最後的,後面沒有了),就返回-1
fis.read();//就讀取指定文件的第一個字節
read_Bytes :
read(byte[] bytes);//返回值是bytes這個數組中,添加元素的個數(字節數),如果達到了數組指定的長度(字節數),(這裏是1024),tmp就會爲0,數組也會清空,然後接着當前讀取的位置依次循環添加,一直到讀取完最後一位,且 當讀取到最後一位的時候,返回值爲-1,(一般用於遍歷,但是一次也是讀取一個,只不過會一直讀取,一直到數組滿了(達到了指定的數組長度),然後再輸出到指定的文件,然後數組清空,tmp爲0,依次循環,一直到讀取完指定文件的最後一個字節)
fis.read(bytes);//就是讀取第一個字節,並把這個字節存入到bytes數組中
write :
write();
fos.write(添加);//把元素添加到輸出流指定的文件中,可以是任何東西
write_bytes_0_tmp :
write(bytes,0,tmp);
fos.write(bytes,0,tmp);//把bytes數組中的元素,從下標爲0開始,添加tmp位(個)元素
//純文本字符流複製
FileReader :
FileWriter :
try(
FileReader fr = new FileReader("./IO流.java");//字符輸入流 指定文件
FileWriter fw = new FileWriter("./新建文本文檔.txt");//字符輸出流 指定文件
){
char[] chars = new char[512];//這裏是char類型的數組,因爲純字符流複製,就是純文本,一個漢字就是一個字符,就是兩個字節,就是16位,所以這裏用的是char字符型數組
int tmp = 0;//和上面一樣,這裏爲什麼要用int聲明?
while(-1 != (tmp = fr.read(chars))){//遍歷循環 將輸出流指定的文件中的內容,先複製到char數組,
fw.write(chars,0,tmp);//把數組的內容,複製到輸出流指定的文件中,並清空數組
}
fw.flush();//磕兩下 輸出流的方法
}catch(Exception e){//捕捉異常
e.printStackTrace();
}
Wen_Jian_Fu_Zhi : //文件複製(緩衝流)
BufferedReader : //字符輸入緩衝流
readLine :
方法 : readLine();//一次讀取一行
//返回值 : 返回該行內容的字符串,不包含任何行終止符,如果已到達流末尾(最後的,沒有東西了),則返回 null
BufferedWriter : //字符輸出緩衝流
newLine :
方法 : newLine();//新建一行,相當於換行符,
try(
BufferedReader br = new BufferedReader(new FileReader("./IO流.java"));//字符輸入流的緩衝流
BufferedWriter bw = new BufferedWriter(new FileWriter("./新建文本文檔.txt"));//字符輸出流的緩衝流
){
String tmp = null;//爲什麼用String?因爲裏面都是字符串,讀取一行,是以字符串的形式 ,所以要用String
int count = 0;//這裏現在是判斷作用,用於添加換行符(下面)
while(true){//while循環,如果不,判斷語句是true 如果不終止,就是死循環把
count++;
tmp = br.readLine();//讀取字符輸入流指定文件的一行,並賦值給tmp
if (tmp == null) {//判斷,如果tmp==null 就執行一下語句 當readLine()方法,讀取到文件尾端的時候,讀取完成,就返回null,所以,當讀取完成後就要終止循環
break;//終止循環
}
//另起一行開始寫,就是一個符號,在兩行之間,顯示的是換行
if (count > 1) {//這是判斷,除了第一行,別的我們都需要換行,這裏就是判斷,如果大於1 那就是第二行,和以下行了,就需要換行
bw.newLine();//換行符,是在行首
}
bw.write(tmp);//添加(複製)到輸出流指定的文件中,(一次是一行),然後數組清空
}
bw.flush();//添加(複製)完,就要磕兩下
}catch(Exception e){//捕捉異常
e.printStackTrace();//處理異常(打印追蹤棧幀)
}
substring :
substring();//返回一個新的字符串,它是此字符串的一個子字符串。該子字符串從指定索引處的字符開始,直到此字符串末尾。
如 : String s = "12345";
String s1 = s.substring(1);//是從原字符串的,下標爲1的那位開始,至字符串的末尾,生成一個新的字符串
s1就是"2345";
String s2 = "A"+s.substring(1);
s2就是"A2345";
exists :
exists();//判斷該路徑是否存在,判斷目標位置所在的盤是不是有這個目錄(或文件),返回值爲boolea true/false
File f = new File("E:/Zuo/You/Xia");//這個目錄(文件)路徑是在內存裏面的,不是硬盤裏面的
f.exists();//這裏是判斷,硬盤裏面是否有這個目錄(或文件)(全路徑)
mkdirs :
mkdirs();//在硬盤中創建指定(抽象,也就是內存中)文件(或目錄)的全路徑
f.mkdirs();//在硬盤中,就會創建一個跟內存(抽象的)中一樣的文件(或目錄)的全路徑
//注意,此操作失敗時也可能已經成功地創建了一部分必需的父目錄。
//就是在硬盤中創建 E:/Zuo/You/Xia
mkdir :
mkdir();//在硬盤中,創建指定文件(目錄)的父路徑,而不是全路徑
f.mkdir();//只會創建 Xia,但是前提得自己創建 E:/Zuo/You,否則不會創建,
/**
* --------------------------序列化----------------------
*/
Serializable :
//序列化
java.io.Serializable;//實現這個接口的,在實例化的時候,就會同步封裝邏輯
transient :
//如果序列化的時候,不想所有的數據都序列化,就在該數據前面加上:transient處理,就不會參與序列化
如 :
transient int age; //這個數據就不會被序列化
serialVersionUID :
序列化後,jvm會給對象文件和class文件都生成一個相同的serialVersionUID編號,這個編號是唯一的,如果對象文件(數據)和class(邏輯)文件的serialVersionUID編號對應不上,就會報錯,如果序列化之後,沒有更改class類文件對應的類裏面的數據,就不會出現這種問題,但是如果改了,就不行了
所以,這個serialVersionUID編碼,可以指定,指定之後,就算我改了class文件對應的類的數據,也能對應的上,也能讀取出來
static final long serialVersionUID = 1L;//這樣,不管更改沒更改,每次生成的serialVersionUID編號,都會是1,就不會出現對應不上去這種錯誤
//對象對應的文件 是保存的數據
//類對象的class文件 是保存的邏輯
//序列化就是把 對象 保存到 硬盤 中,
User u1 = new User("aaa");//既然是序列化,那麼這個User類必須實現與java.io.Serializable;(Serializable)這個接口
往指定地方(硬盤)存儲對象文件的,叫序列化
從指定文件中(硬盤),讀取對象文件的叫,反序列化
ObjectOutputStream :
//序列化
需要有個實現Serializable接口的類,和往指定地方(硬盤)存放這個對象文件的類,也就是ObjectOutputStream類(這個類現用先寫都行)
writerObject();//輸出對象流的方法 , 把指定的對象,添加到指定的文件中
flush();//磕兩下,輸出流都有的方法
//往指定地方(硬盤)存儲對象文件的,叫序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("./xv_lie_hua"));//創建對象輸出流 並把東西保存到指定的文件("./xv_lie_hua")
oos.writeObject(u1);//這裏就是把u1這個對象,輸出到上面指定的文件中("./xv_lie_hua"),沒有會創建
oos.flush();//磕兩下
oos.close();//關閉資源
ObjectInputStream :
//反序列化
//反序列化需要:
對象文件,對象對應的class文件,反序列化類文件(這個類現寫的都行)
readObject();//輸入對象流的方法 , 讀出指定的對象文件
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./xv_lie_hua"));//創建對象輸入流,把指定的對象文件,輸入到當前頁面,
Object o = ois.readObject();//讀取裏面的對象,並賦值給用Object聲明的 o 變量
System.out.println( o );//輸出o變量,就是輸出了讀取的對象
ois.close();//關閉資源
}