JAVA进阶教学之（IO流）
生活随笔
收集整理的這篇文章主要介紹了
JAVA进阶教学之（IO流）
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
目錄
1、什么是IO流
2、流的分類
3、流的四大家族首領
4、java.io.*包下需要掌握的16個流
5、FileInputStream的實用方法
6、FileOutputStream的方法
7、文件復制/拷貝
8、FileReader的使用
9、FileWriter的使用
10、復制普通文本文件
11、BufferedReader帶有緩沖區的字符輸入流
12、節點流和包裝流
13、帶有緩沖區的字符輸出流
14、DataOutputStream和DataInputStream數據流
15、PrintStream標準輸出流
16、File類
17、練習目錄拷貝
?
?
1、什么是IO流
I：Input 例如：從硬盤中讀取數據進入CPU的內存
O：Output 例如：從CPU的內存讀取數據進入硬盤
流：在管道（pipe line）中產生的一種計算模式
IO流：以內存為參照物，完成硬盤文件的讀和寫
?
2、流的分類
按流的方向分類：
按讀取方式分類：
- 萬能字節流，所有文件都是字節構成，例如：流?一次讀取一個字節byte，等同于一次讀取8個二進制
- 方便字符流，普通文本文件是由字符構成，例如：流 一次讀取一個字符，且只能讀取純文本文件.txt，連word文件都無法讀取（普通文本文件指的是能用記事本編輯器打開的文件，并不是都是.txt文件）
?
舉例子：
?
萬能字節流：
假設文件file1.txt，采用字節流讀取
a中國bccc
第一次讀：一個字節，正好讀到 'a'
第二次讀：一個字節，正好讀到 '中' 字符的一半
第三次讀：一個字節，正好讀到 '中' 字符的另外一半
?
方便字符流：
假設文件file2.txt，采用字符流讀取
a中國bccc
第一次讀：一個字符，正好識別讀到 'a
第二次讀：一個字符，正好識別讀到 '中'?
第三次讀：一個字符，正好識別讀到 '國'
?
疑惑：java中的英文字符a不是應該占用兩個字節嗎？為什么讀取的時候讀一個字節就可以將英文字符a讀出來，因為file1.txt屬于windows操作系統的內容，在這個文件中，只是windows操作系統的普通文件
?
JAVA所有流都是在java.io.*這個包內
主要研究怎么new流對象，調用流對象的哪個方法是讀，哪個方法是寫
?
?
3、流的四大家族首領
java.io.InputStream? ? 字節輸入流
java.io.OutputStream? 字節輸出流
?
java.io.Reader? 字符輸入流
java.io.Writer? ? 字符輸出流
?
規律：
Stream結尾的類包就是代表字節流，Reader結尾的類包就是代表字符流
四大家族的首領都是抽象類（abstract class）
四大家族的首領都實現了：java.io.Closeable接口，都有close( )方法，都是可關閉的
流的本質是在管道內流通，就占用較多的系統資源，需要養成用完流之后進行關閉流的操作的習慣 ，強行刷新清空管道中剩余未輸出的數據，沒有flush( )可能會導致數據丟失
四大家族的首領都實現了：java.io.Flushable接口，都有flush( )方法，都是可刷新的
?
?
4、java.io.*包下需要掌握的16個流
?
文件流：
java.io.FileInputStream? （掌握）
java.io.FileOutputStream??（掌握）
java.io.FileReader
java.io.FileWriter
轉換流：（將字節流轉換成字符流）
java.io.InputStreamReader
java.io.OutPutStreamWriter
緩沖流：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferInputStream
java.io.BufferedOutputStream
數據流：
java.io.DataInputStream
java.io.DataOutputStream
標準流：
java.io.PrintWriter? ?（掌握）
java.io.PrintStream? ?（掌握）
對象流：
java.io.ObjectInputStream? ?（掌握）
java.io.ObjectOutputStream? ?（掌握）
?
?
5、FileInputStream的實用方法
?
代碼演示（從一個文件中逐個讀出內容）：
步驟一：新建一個文件123.txt ，復制文件路徑（文件內容abc中）
步驟二：讀出文件內容
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest01 {public static void main(String[] args) {FileInputStream fileInputStream = null;try {//創建文件字節輸入流對象//采用絕對路徑的方式：idea工具會自動把路徑的單斜杠/ 轉換成//雙斜杠fileInputStream=new FileInputStream("D:\\2021-2022課件\\123.txt");//第一次開始讀，每次只讀一個字節int readData=fileInputStream.read();//看看到底讀到什么東西//這個read()方法的返回值是：讀取到的“字節”本身System.out.println(readData);//97//第二次讀int readData2=fileInputStream.read();System.out.println(readData2);//98//第三次讀int readData3=fileInputStream.read();System.out.println(readData3);//99//第四次讀//讀‘中’的1個字節int readData4=fileInputStream.read();System.out.println(readData4);//214//第五次讀//讀‘中’的另一個字節int readData5=fileInputStream.read();System.out.println(readData5);//208//第六次讀//如果讀取的是空，則返回-1int readData6=fileInputStream.read();System.out.println(readData6);//-1//第七次讀//如果讀取的是空，則返回-1int readData7=fileInputStream.read();System.out.println(readData7);//-1} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {//在finally語句塊中確保流一定要關閉//關閉流的前提是：流不是空，避免空指針異常if(fileInputStream!=null){try {fileInputStream.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
?
代碼演示（從一個文件中循環讀出內容）：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest02 {public static void main(String[] args) {FileInputStream f=null;try {f=new FileInputStream("D:\\2021-2022課件\\123.txt");//循環輸出讀取的數據int readData=0;while ((readData=f.read())!=-1){System.out.println(readData);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }97 98 99 214 208?
?
?
代碼演示（將字節數組byte[ ]讀進內存）：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest02 {public static void main(String[] args) {FileInputStream f=null;try {//123.txt存儲的是abcdeff=new FileInputStream("D:\\2021-2022課件\\123.txt");//定義一個byte數組,此數組一次可以存儲4個字節byte[] b=new byte[4];//與read()的不同之處在于取的不是“字節”本身，而是 數量//第一次讀int readData2=f.read(b);System.out.println(readData2);//4//原則：需要將‘讀’的字節數組‘全部’轉換成字符串類型輸出System.out.println(new String(b));//abcd//實際上：需要將‘讀’的字節數組‘部分’讀多少轉換多少System.out.println(new String(b,0,readData2));//abcd//第二次讀int readData3=f.read(b);System.out.println(readData3);//2System.out.println(new String(b));//efcd//讀多少轉換多少System.out.println(new String(b,0,readData3));//ef//第三次讀//讀不到任何數據的時候返回-1int readData4=f.read(b);System.out.println(readData4);//-1//循環輸出讀取的數據int readData=0;while ((readData=f.read())!=-1){System.out.println(readData);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }示意圖：
?
?
?
代碼演示（將字節數組byte[ ]讀進內存，進階循環輸出）：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest03 {public static void main(String[] args) {FileInputStream f=null;try {//123.txt存儲的是abcdeff=new FileInputStream("D:\\2021-2022課件\\123.txt");byte[] b=new byte[4];int readCount=0;while ((readCount=f.read(b))!=-1){System.out.print(new String(b,0,readCount));//abcdef}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
?
代碼演示（int available() 返回流當前剩余沒有被讀到的字節數量）：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest04 {public static void main(String[] args) {FileInputStream f=null;try {//123.txt存儲的是abcdeff=new FileInputStream("D:\\2021-2022課件\\123.txt");//讀1個字節int readByte=f.read();//還剩下可以讀的字節數量System.out.println("還剩下可以讀的字節數量:"+f.available());//5} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} } package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest04 {public static void main(String[] args) {FileInputStream f=null;try {//123.txt存儲的是abcdeff=new FileInputStream("D:\\2021-2022課件\\123.txt");// //讀1個字節 // int readByte=f.read(); // // //還剩下可以讀的字節數量 // System.out.println("還剩下可以讀的字節數量:"+f.available()); ////這個方法的作用：自動獲取剩余的字節數量，例如：一個文件中本來有6個字節，我們就需要給一個6個字節大小的字節數組去存儲，而f.available()就幫我們自動擴容到這個長度byte[] b=new byte[f.available()];int readByte2=f.read(b);//執行一次即可將文件中的abcdef全部傳遞到字節數組中//缺點：不適合大文件，因為byte[] 數組不可以存儲大量數據System.out.println(new String(b));//abcdef} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
?
代碼演示（skip跳過幾個字節不讀取）：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class FileInputStreamTest05 {public static void main(String[] args) {FileInputStream f=null;try {//abcdeff=new FileInputStream("D:\\2021-2022課件\\123.txt");//skip 跳過幾個字節不讀取f.skip(3);System.out.println(f.read());//100 直接跳到d} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
?
6、FileOutputStream的方法
?
代碼演示（將內存中的數據寫出到文件中）：
package com.lbj.javase.io;import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;public class FileOutputStreamTest06 {public static void main(String[] args) {FileOutputStream f=null;try {//321.txt 文件不存在的時候會自動新建一個新的文件//但是這種方式請謹慎使用，會使得原文件 ！清空！ 然后重寫寫入//f=new FileOutputStream("D:\\2021-2022課件\\321.txt");//以追加的方式在文件末尾寫入，不會清空原文件內容f=new FileOutputStream("D:\\2021-2022課件\\321.txt",true);//開始寫一個byte[]數組byte[] bytes={97,98,99};//將byte[] 數組全部寫入321.txt中f.write(bytes);//將byte[] 的一部分寫出f.write(bytes,0,2);String s="我是一個中國人";//將字符串變成字符byte[] b=s.getBytes();//寫入321.txt中f.write(b);//寫完之后，最后一定要刷新f.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
7、文件復制/拷貝
?
代碼演示：
package com.lbj.javase.io;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;public class CopyTest01 {public static void main(String[] args) {FileInputStream fis=null;FileOutputStream fos=null;try {//創建一個輸入流對象fis=new FileInputStream("D:\\2021-2022課件\\123.txt");//創建一個輸出流對象fos=new FileOutputStream("D:\\2021-2022課件\\321.txt");//核心：一邊讀，一邊寫byte[] bytes=new byte[1024*1024];//一次最多拷貝1MB//int readCount=0;while ((readCount=fis.read(bytes))!=-1){fos.write(bytes,0,readCount);}//刷新，輸出流最后要刷新fos.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fos!=null){//分開try，不要一起try//一起try的時候，其中一個出現異常，可能會影響到另一個流的關閉try {fos.close();} catch (IOException e) {e.printStackTrace();}try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
8、FileReader的使用
FileReader是文件字符輸入流，負責讀操作，文件只讀取字符，且只能讀取普通文本文件
代碼演示：
package com.lbj.javase.io;import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException;public class FileReaderTest01 {public static void main(String[] args) {FileReader f=null;try {//創建文件輸入流//123.txt里的字符為abcdeff=new FileReader("D:\\2021-2022課件\\123.txt");//開始讀,一次只讀2個字符char[] chars=new char[2];//往char數組中讀 // int readCount=0; // while((readCount=f.read(chars))!=-1){ // System.out.println(new String(chars,0,readCount));//ab cd ef // }//同上，一次只讀一個字符f.read(chars);for (char c:chars) {System.out.println(c);//a b}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
9、FileWriter的使用
FileWriter是文件字符輸出流，負責寫操作，文件只輸出字符，且只能輸出普通文本文件
代碼演示：
package com.lbj.javase.io;import java.io.FileWriter; import java.io.IOException;public class FileWriterTest01 {public static void main(String[] args) {FileWriter f=null;try {//創建文件輸出流對象//123.txt的內容為abcdef//加了true這個參數后就不會清空f=new FileWriter("D:\\2021-2022課件\\123.txt",true);//開始寫char[] chars={'g','h','i'};//沒加append：true參數前，會對文件進行清空f.write(chars);//先清空，然后寫出ghif.write("ccc");//不清空，然后寫出ghiccc//刷新f.flush();} catch (IOException e) {e.printStackTrace();} finally {if(f!=null){try {f.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
10、復制普通文本文件
代碼演示（字符文本之間的復制）：
package com.lbj.javase.io;import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException;public class CopyTest02 {public static void main(String[] args) {FileReader fr=null;FileWriter fw=null;try {//創建讀對象//abcdeffr=new FileReader("D:\\2021-2022課件\\123.txt");//創建寫對象//aaafw=new FileWriter("D:\\2021-2022課件\\321.txt",true);//一邊讀一邊寫char[] chars=new char[1024*512];//1MBint readCount=0;while ((readCount= fr.read(chars))!=-1){fw.write(chars,0,readCount);}//結果：aaaabcdef//刷新fw.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {//分別拋異常if(fr!=null){try {fr.close();} catch (IOException e) {e.printStackTrace();}}if(fw!=null){try {fw.close();} catch (IOException e) {e.printStackTrace();}}}} }?
?
?
11、BufferedReader帶有緩沖區的字符輸入流
使用這個流的時候不需要自定義char數組，或者說不需要自定義byte數組，自帶緩沖
?
當一個流的構造方法中需要一個流的時候，這個被傳進來的流叫做：節點流外部負責包裝的這個流，叫做：包裝流，還有一個名字叫做：處理流像當前這個程序來說：FileReader就是一個節點流，BufferedReader就是一個包裝流關閉流的時候只需要關閉最外層就行（查看源碼得知）
?
代碼演示：
package com.lbj.javase.io;import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException;public class BufferedReaderTest01 {public static void main(String[] args) throws Exception {//內容為：abcdef//// cccFileReader fi=new FileReader("D:\\2021-2022課件\\123.txt");//當一個流的構造方法中需要一個流的時候，這個被傳進來的流叫做：節點流//外部負責包裝的這個流，叫做：包裝流，還有一個名字叫做：處理流//像當前這個程序來說：FileReader就是一個節點流，BufferedReader就是一個包裝流BufferedReader br=new BufferedReader(fi); /*//讀第一行String firstLine=br.readLine();System.out.println(firstLine);//abcdef//讀第二行String secondLine=br.readLine();System.out.println(secondLine);//空的一行，不返回任何值//讀第三行String thirdLine=br.readLine();System.out.println(thirdLine);//ccc//讀第四行String fourLine=br.readLine();System.out.println(fourLine);//如果是最后一行，返回null*///因此可以用循環,br.readLine()方法讀取一個文本行，但不帶換行符String s=null;while ((s=br.readLine())!=null){System.out.print(s);}//結果：//abcdefccc//關閉流//對于包裝流來說，只需要關閉最外層流就行，里面的節點流會自動關閉br.close();} }?
?
?
12、節點流和包裝流
節點流和包裝流是相對而言的，在不同的位置，節點流和包裝流會發生變化
代碼演示：
package com.lbj.javase.io;import java.io.*;public class BufferReaderTest02 {public static void main(String[] args) throws Exception{//FileInputStream屬于字節流FileInputStream fis=new FileInputStream("D:\\2021-2022課件\\123.txt");//InputStreamReader屬于包裝流//在這里fis是節點流，isr是包裝流//通過轉換流轉換,將字節流轉換成字符流InputStreamReader isr=new InputStreamReader(fis);//這個構造方法只能傳遞一個字符流，不能傳遞字節流//解決：使用轉換流//在這里isr是節點流，br是包裝流BufferedReader br=new BufferedReader(isr);//循環String line=null;while ((line=br.readLine())!=null){System.out.println(line);}//關閉最外層br.close();} }?
?
?
13、帶有緩沖區的字符輸出流
代碼演示：
package com.lbj.javase.io;import java.io.BufferedWriter; import java.io.FileOutputStream; import java.io.OutputStreamWriter;public class BufferedWriterTest {public static void main(String[] args) throws Exception{//創建一個字節輸出流FileOutputStream fos=new FileOutputStream("D:\\2021-2022課件\\123.txt",true);//創建一個轉換流OutputStreamWriter osw=new OutputStreamWriter(fos);//帶緩沖區的字符輸出流BufferedWriter bw=new BufferedWriter(osw);//開始寫，如果不在字節輸出流的位置添加true,寫的時候會把之前的內容清空bw.write("ddd");bw.write("eee");//刷新bw.flush();//關閉最外層bw.close();} }?
?
14、DataOutputStream和DataInputStream數據流
java.io.DataOutputStream ：數據專屬的流
作用：可以將數據連同數據類型一并寫入文件
注意：這個文件不是普通文本文檔（換句話來說就是這個文件用記事本編輯器打不開）
代碼演示：
package com.lbj.javase.io;import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream;public class DataOutputStreamTest01 {public static void main(String[] args) throws Exception {//創建字節輸出流FileOutputStream fos=new FileOutputStream("D:\\2021-2022課件\\321",true);//創建數據專屬的字節輸出流DataOutputStream dos=new DataOutputStream(fos);//寫數據byte b=100;short s=200;boolean x=true;//寫//把數據以及數據的類型一并寫入到文件中，相當于加密，并且嚴格規定順序dos.writeByte(b);dos.writeShort(s);dos.writeBoolean(x);//刷新dos.flush();//關閉最外層dos.close();} }?
?
DataInputStream ：數據字節輸入流
DataOutputStream ：寫的文件，只能使用DataInputStream去讀，并且讀的時候需要提前知道寫入的順序，讀的順序要和寫的順序一致，才可以正常取出數據
代碼演示：
?
?
?
?
15、PrintStream標準輸出流
java.io.PrintStream：標準的字節輸出流，默認輸出到控制臺，還可以改變輸出方向
代碼演示：
package com.lbj.javase.io;import java.io.FileOutputStream; import java.io.PrintStream;public class PrintStreamTest01 {public static void main(String[] args) throws Exception{//聯合起來System.out.println("helloworld");//拆分開//System.out返回值類型是PrintStreamPrintStream ps=System.out;ps.println("hello");ps.println("world");//標準輸出流不需要手動close()關閉//可以改變標準輸出流的輸出方向嗎？可以//標準輸出流不再指向控制臺，指向123.txt文件FileOutputStream fos=new FileOutputStream("D:\\2021-2022課件\\123.txt");PrintStream ps2=new PrintStream(fos);//修改輸出方向，將輸出方向修改到123.txt文件System.setOut(ps2);//再輸出System.out.println("hello");System.out.println("world"); //打印到123.txt文件中了} }?
日志工具：
可以用來打印日志，以后開發必不可少
代碼演示（自定義一個日志工具類）：
package com.lbj.javase.io;import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.PrintStream; import java.text.SimpleDateFormat; import java.util.Date;/*** 自定義日志工具類*/ public class Logger {public static void log(String msg){try {//創建字節輸出流，指向一個日志文件FileOutputStream fos=new FileOutputStream("log.txt",true);//創建標準輸出流PrintStream out=new PrintStream(fos);//改變輸出位置System.setOut(out);//獲取當前時間Date nowTime=new Date();//規定時間格式SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");//轉換格式String s=sdf.format(nowTime);//輸出到log.txt文件中System.out.println(s+":"+msg);} catch (FileNotFoundException e) {e.printStackTrace();}} }測試類：
package com.lbj.javase.io;public class LoggerTest {public static void main(String[] args) {Logger.log("用戶正在進行登錄，驗證失敗");Logger.log("這是日志記錄工具噢");} }測試結果：
2021-04-22 21:36:15 340:用戶正在進行登錄，驗證失敗
2021-04-22 21:36:15 372:這是日志記錄工具噢
?
?
?
16、File類
File有可能是目錄，也有可能是文件，或者是路徑名
1、File類和四大家族沒有關系（看繼承結構得知），所以File類不能完成文件的“讀”和“寫”
2、File只是一個路徑名的抽象表示形式
代碼演示（File類中常用的方法）：
package com.lbj.javase.io;import java.io.File; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Date;/*** @author LBJ* @version V1.0* @Package com.lbj.javase.io* @date 2021/4/25 23:21* @Copyright 公司*/ public class FileTest01 {public static void main(String[] args) throws IOException {//這個路徑下是沒有file文件File f=new File("D:\\2021-2022課件\\file");//判斷是否存在file文件System.out.println(f.exists());//false// //判斷是否存在file文件，如果沒有此文件，則在此路徑下創建file文件 // if(!f.exists()){ // f.createNewFile(); // }//判斷是否存在file文件夾，如果沒有此文件夾，則在此路徑下創建file文件夾 // if(!f.exists()){ // f.mkdir(); // }//判斷是否存在file"多重文件夾"，如果沒有，則創建,注意是mkdirs()不是mkdir() // File f2=new File("D:\\2021-2022課件\\file\\a\\b\\c"); // if(!f2.exists()){ // f2.mkdirs(); // }//獲取文件的父路徑File f3=new File("D:\\2021-2022課件\\123.txt");String parent=f3.getParent();System.out.println(parent);//D:\2021-2022課件//另一種形式，以File類型的形式File paren1=f3.getParentFile();System.out.println(paren1);//D:\2021-2022課件//獲取文件的絕對路徑File parent3=f3.getAbsoluteFile();System.out.println(parent3);//D:\2021-2022課件\123.txt//獲取文件名System.out.println(f3.getName());//判斷是否是一個目錄System.out.println(f3.isDirectory());//判斷是否是一個文件System.out.println(f3.isFile());//獲取文件最后一次修改時間（返回值是毫秒）long haoMiao=f3.lastModified();System.out.println(haoMiao);//1619097200422//將總毫秒數轉換成 日期Date time=new Date(haoMiao);SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");String strTime=sdf.format(time);System.out.println(strTime);//2021-04-22 21:13:20 422//獲取文件大小System.out.println(f3.length());//14字節//File中的listFiles方法，可以獲取當前目錄下的所有子文件，返回的是FIle類型的數組File[] files=f.listFiles();//foreachfor (File file:files) {//獲取當前目錄下的所有子的絕對路徑System.out.println(file.getAbsoluteFile());//D:\2021-2022課件\file\a//獲取當前目錄下的所以子目錄名字System.out.println(file.getName());//a}} }?
?
?
17、練習目錄拷貝
代碼演示（）：
package com.lbj.javase.io.ioTest01;import java.io.*;public class CopyAll {public static void main(String[] args) {//拷貝源File srcFile=new File("拷貝源路徑");//拷貝目標File destFile=new File("拷貝目標路徑");//調用方法拷貝copyDir(srcFile,destFile);}/*** 拷貝目錄方法* @param srcFile 拷貝源* @param destFile 拷貝目標*/private static void copyDir(File srcFile,File destFile){if(srcFile.isFile()){//srcFile如果是一個文件的話，遞歸結束//判斷是文件的時候 需要拷貝FileInputStream in=null;FileOutputStream out=null;try {in=new FileInputStream(srcFile);//拼接新的一個路徑，涉及大量的字符串 拼接 操作 String path=(destFile.getAbsolutePath().endsWith("\\")?destFile.getAbsolutePath(): destFile.getAbsolutePath()+"\\")+srcFile.getAbsolutePath().substring(3);out=new FileOutputStream(path);//一邊讀一邊寫byte[] bytes=new byte[1024*1024];int readCount=0;while((readCount=in.read(bytes))!=-1){out.write(bytes,0,readCount);}out.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(in!=null){try {in.close();} catch (IOException e) {e.printStackTrace();}}if(out!=null){try {out.close();} catch (IOException e) {e.printStackTrace();}}}return;}//將拷貝源的子目錄存放到File[]數組中File[] files=srcFile.listFiles();for (File f:files) {//測試：獲取所有文件的絕對路徑//System.out.println(f.getAbsoluteFile());if(f.isDirectory()){//源目錄路徑String srcDir=f.getAbsolutePath();//關鍵在于目標目錄的路徑String destDir=(destFile.getAbsolutePath().endsWith("\\")?destFile.getAbsolutePath(): destFile.getAbsolutePath()+"\\")+srcDir.substring(3);//以多重目錄的形式建目錄File newFile=new File(destDir);if(!newFile.exists()){newFile.mkdirs();}}//遞歸調用copyDir(f,destFile);}} }?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
總結
以上是生活随笔為你收集整理的JAVA进阶教学之（IO流）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python对象的三个属性_Python
- 下一篇： java 图片分段上传_java 分段读