第十三章 I/O流

File類

File對象包含了文件中的所有字節數據，以及文件的其他詳細信息。

創建File對象

//File對象包含了文件中的所有字節數據，以及文件的其他詳細信息
File file;
//使用絕對路徑創建文件
file = new File("d:/myFile/a/test.txt");
//通過父文件對象創建
file = new File(new File("d:/myFile"), "a/test.txt");
file = new File(new File("d:/myFile/a"),"test.txt");
//通過父文件路徑創建
file = new File("d:/myFile", "a/test.txt");

常見的File的操作

創建、重命名、刪除、複製、剪切、黏貼

File對象的方法

exists 判斷文件是否已經存在

getAbsolutePath 獲取文件的絕對路徑

isFile 是否是單個的文件

isDirectory 是否是文件夾

listFiles 獲取文件夾中的子文件

createNewFile 創建新文件

mkdir 創建文件夾

delete 刪除

renameTo 重命名

獲取文件的文件名

file.getName();

獲取文件的父文件路徑

file.getParent();

獲取文件的長度（字節數）

file.length();

獲取文件所在盤符的剩餘字節大小

file.getFreeSpace();

獲取文件所在盤符的總大小

file.getTotalSpace();

獲取文件所在盤符的可用空間

file.getUsableSpace();

是否是可執行文件

file.canExecute()

是否可讀

file.canRead();

是否可寫

file.canWrite();

文件最後一次修改的時間

file.lastModified();
//返回long型
long time = file.lastModified();
Date date = new Date(time);

是否是隱藏文件

file.isHidden();

獲取文件中的子文件

File[] files = file.listFile();

獲取當前操作系統的所有盤符

File[] disks = File.listRoots();

刪除文件

可以用於文件和文件夾，如果是文件夾，並且該文件夾有子文件，則不能刪除，要刪除必須清空文件夾的子文件

file.delete()

操作

查看所有文件的方法

/**
* 查看所有文件的方法
*/
public void showFiles(String path){
	//根據路徑獲得文件
	File file = new File(path);
	//判斷文件是否存在
	if(file.exists()){
		System.out.println(file.getAbsolutePath());
		//判斷是否是文件夾
		if(file.isDirectory()){
		    //如果是文件夾，則獲取文件夾中的子文件
	    	File[] files = file.listFiles();
		    if(files != null){
			    //遍歷子文件
			    for(File childFile : files){
			    	//遞歸查看
			    	showFiles(childFile.getAbsolutePath());
			    }    
		    }
		}	
     }
}

根據文件類型查找顯示文件

     /**
	 * 根據文件類型查找顯示文件
	 * @param path
	 * @param type
	 */
	public void showFiles(String path, String type){
		//根據路徑獲得文件
		File file = new File(path);
		//判斷文件是否存在
		if(file.exists()){
			//判斷文件是否是文件
			if(file.isFile()){
				//如果是文件就要判斷文件的後綴名是否和查找的文件類型匹配
				if(validateFile(file.getName())){
					//獲取文件的後綴名
					String fileType = file.getName().substring(file.getName().lastIndexOf(".")+1);
					//判斷後綴名是否和查找文件匹配
					if(fileType.equalsIgnoreCase(type)){
						//打印顯示文件 
						System.out.println(file.getAbsolutePath());
					}
				}
				
			}
			//如果是文件夾遞歸查找
			else{
				//如果是文件夾，則獲取文件夾中的子文件
				File[] files = file.listFiles();
				if(files != null){
					//遍歷子文件
					for(File childFile : files){
						//遞歸查看
						showFiles(childFile.getAbsolutePath(),type);
					}
				}
			}
		}
		
	}
	
	/**
	 * 驗證文件是否是一個合法文件
	 * @return
	 */
	public boolean validateFile(String fileName){
		if(fileName.indexOf(".") != -1){
			return true;
		}
		return false;
	}

創建單個文件的方法

     /**
	 * 創建單個文件的方法
	 * @param fileName 新建的文件名
	 * @param path 創建的位置
	 */
	public void createFile(String fileName, String path){
		//根據父文件路徑創建File對象
		File parentFile = new File(path);
		//判斷父文件是否存在
		if(parentFile.exists()){
			//判斷父文件是否是文件夾
			if(parentFile.isDirectory()){
				//構建File對象
				File file = new File(path, fileName);
				//判斷要新建的文件是否存在
				if(!file.exists()){
					//創建
					try {
						file.createNewFile();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				else{
					JOptionPane.showMessageDialog(null, "該文件已經存在！");
				}
			}	
		}
		else{
			JOptionPane.showMessageDialog(null, "文件夾不存在！");
		}
		
		
	}

創建文件夾的方法

     /**
	 * 創建文件夾的方法
	 */
	public void createDirectory(String fileName, String path){
		//new File("").mkdir();
	}
	
	/**
	 * 對文件進行重命名的方法
	 * @param source 要修改的源文件路徑
	 * @param fileName 文件的新命名（不包含後綴名）
	 */
	public void reNameFile(String source, String fileName){
		File sourceFile = new File(source);
		//判斷源文件是否存在
		if(sourceFile.exists()){
			//判斷源文件是否有後綴名
			if(validateFile(sourceFile.getName())){
				//獲取源文件的後綴名
				String type = sourceFile.getName().substring(sourceFile.getName().lastIndexOf("."));
				//根據源文件的路徑以及後綴名創建新命名的文件對象
				File file = new File(sourceFile.getParent(),fileName+type);
				////判斷新的文件名是否存在
				if(!file.exists()){
					//重命名
					sourceFile.renameTo(file);
				}
			}	
		}
	}

刪除文件的方法

     /**
	 * 刪除文件的方法
	 */
	public void deleteFile(String path){
		File file = new File(path);
//		//刪除文件,可以用於文件和文件夾
//		//如果是文件夾，並且該文件夾中有子文件，則不能刪除
//		//如有以上情況則必須清空文件夾中的子文件
//		file.delete();
		
		//判斷文件是否存在
		if(file.exists()){
			//判斷文件是否是文件夾
			if(file.isDirectory()){
				//如果是文件夾獲取子文件
				File[] files = file.listFiles();
				if(files != null){
					//遞歸刪除
					for(File childFile : files){
						deleteFile(childFile.getAbsolutePath());
					}
				}
				
			}
			//無論是否是文件夾都應刪除當前文件
			file.delete();
		}
	}

IO流

InputStream 所有輸入流的基類是一個抽象類

OutputStream 所有輸出流的基類也是一個抽象類

常用的實現類

FileInputStream FileOutputStream

BufferedInputStream BufferedOutputStream

需要通過抽象的實例類才能對文件進行流的讀寫

讀寫

通過輸入流的read方法讀取文件流的字節信息

將每次讀取到的信息通過輸出流寫入到新的文件中

int data;
while((data = input.read()) != -1){
    output.write(data);
}

JAVA中IO流的分類

1、字節流

以單字節的方式進行讀取

2、字符流

以單字符的方式進行讀取

字符流在讀取文本信息時效率高於字節流

字符流由字節流衍生而來，因此必須藉助於字節流實現

字符流不能對單字節構成的文件進行讀寫，如視頻圖片

字符流

Reader 字符輸入流的基類抽象類

Writer 字符輸出類的基類抽象類

InputStreamReader OutputStreamWriter

BufferedReader BufferedWriter

1、使用字節流讀寫文件中的字節數據

//數據流不能對文件夾進行讀寫
FileInputStream fis = new FileInputStream(new File("d:/a.txt"));
//每次讀取一個字節，因此通過循環反覆讀取字節
int data;
while((data = fis.read()) != -1){
     system.out.println(data);
}
fis.close();

2、使用輸出流將字節數據寫入文件

//創建輸出流的時候如果文件不存在，則會自動創建文件，如果文件存在則將默認覆蓋文件
//第二個參數表示是否追加數據，默認爲false
FileOutputStream fos = new FileOutputStream(new File("d:/b.txt"),true);
//寫入數據
fos.write(66);
fos.write(67);
//清空緩衝流
fos.flush();
fos.close();

（優）3、使用緩衝流優化

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("d:/flash.exe")));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("d:/test.exe")));
int len;
byte[] buffer = new byte[1024];
while((len = bis.read(buffer)) != -1){
    bos.write(buffer, 0, len);
}
bis.close();
bos.flush();
bos.close();

（優）4、自定義緩衝流

FileInputStream fis = new FileInputStream(new File("d:/flash.exe"));
FileOutputStream fos = new FileOutputStream(new File("d:/test.exe"));
//讀取長度
int len;
//緩衝數組
byte[] buffer = new byte[1024];
//每次讀取都將字節寫入緩衝區
while((len = fis.read(buffer)) != -1){
	//將緩衝區中的數據寫入文件
	fos.write(buffer,0,len);
}
	fis.close();
	fos.flush();
	fos.close();

字符流

字符流只適合讀取純文本的File文件，字符流的構建依賴於字節流

使用字符流讀寫文本

try {
	InputStreamReader reader = new InputStreamReader(new FileInputStream(new File("d:/a.txt")));
	char[] buffer = new char[1024];
	StringBuffer str = new StringBuffer();
	int len;
	while((len = reader.read(buffer)) != -1){
		str.append(buffer);
	}
	reader.close();
	System.out.println(str);
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	}

使用字符緩衝流

InputStreamReader是字節流到字符緩衝流的橋樑

try {
	BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/a.txt"))));
	String s;
	//一次讀取一行
	while((s = reader.readLine()) != null){
		System.out.println(s);
	}
	reader.close();
        } catch (FileNotFoundException e) {			                                    
             e.printStackTrace();
	} catch (IOException e) {
	     e.printStackTrace();
    }

try {
	BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("d:/b.txt"))));
	//使用輸出流寫入數據
	writer.write("這是我新建的文本\r\n");
	//換行
	//writer.newLine();
	writer.write("又一段新的內容");
	writer.flush();
	writer.close();
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	}

自定義鍵盤接受

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

序列化及反序列化 ObjectInputStream ObjectOutputStream

序列化的對象要使用 Serializable接口

import java.io.Serializable;
public class User implements Serializable{
	private int userId;
	private String name;
	public User(int userId, String name) {
		super();
		this.userId = userId;
		this.name = name;
	}
	public int getUserId() {
		return userId;
	}
	public void setUserId(int userId) {
		this.userId = userId;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

添加兩個實例對象（user）到 list 集合裏

		User user1 = new User(1001, "tom");
		User user2 = new User(1002, "jack");
		
		ArrayList<User> list = new ArrayList<User>();
		list.add(user1);
		list.add(user2);

進行序列化保存

		try {
			ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream(new File("d:/users.data")));
			//將對象通過輸出流進行序列化保存
			//序列化對象必須實現序列化接口
			output.writeObject(list);
			output.flush();
			output.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

反序列化讀取文件

try {
			ObjectInputStream input = new ObjectInputStream(new FileInputStream(new File("d:/users.data")));
			ArrayList<User> list = (ArrayList<User>) input.readObject();
			input.close();
			for(User user : list){
				System.out.println(user.getUserId()+"\t"+user.getName());
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

土豆的小祕密

發佈了46 篇原創文章 · 獲贊 2 · 訪問量 1萬+

私信關注

第十三章 I/O流

工作中用到的腳本合集

24-5-18 X

第十四章網絡編程

第三章表單和框架

第一章 Html的基本標籤

第二章數據表管理

第十二章線程

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結