1. File類的使用 java.io.File類：文件和文件目錄路徑的抽象表示形式，與平臺無關； File能新建、刪除、重命名文件和目錄，但File不能訪問文件內容本身。如果需要訪問文件內容本身，則需要使用輸入/輸出流； 想要在Java程式中表示一個真實存在的文件或目錄，那麼必須有一個File對象 ...
1. File類的使用
- java.io.File類：文件和文件目錄路徑的抽象表示形式，與平臺無關；
- File能新建、刪除、重命名文件和目錄，但File不能訪問文件內容本身。如果需要訪問文件內容本身，則需要使用輸入/輸出流；
- 想要在Java程式中表示一個真實存在的文件或目錄，那麼必須有一個File對象，但是Java程式中的一個File對象，可能沒有一個真實存在的文件或目錄；
- File對象可以作為參數傳遞給流的構造器。
1.1 File類的構造器
- public File(String pathname)
以pathname為路徑創建File對象，可以是 絕對路徑或者相對路徑，如果pathname是相對路徑，則預設的當前路徑在系統屬性user.dir中存儲。 - public File(String parent,String child)
以parent為父路徑，child為子路徑創建File對象； - public File(File parent,String child)
根據一個父File對象和子文件路徑創建File對象 。
1.2 File類的常用方法
File類的獲取功能
- public String getAbsolutePath()：獲取絕對路徑
- public String getPath() ：獲取路徑
- public String getName() ：獲取名稱
- public String getParent()：獲取上層文件目錄路徑。若無，返回null
- public long length() ：獲取文件長度（即：位元組數）。不能獲取目錄的長度。
- public long lastModified() ：獲取最後一次的修改時間，毫秒值
- public String[] list() ：獲取指定目錄下的所有文件或者文件目錄的名稱數組
- public File[] listFiles() ：獲取指定目錄下的所有文件或者文件目錄的File數組
File類的重命名功能
public boolean renameTo(File dest):把文件重命名為指定的文件路徑；
比如：file1.renameTo(file2)為例：
要想保證返回true,需要file1在硬碟中是存在的，且file2不能在硬碟中存在。
File 類的判斷功能
- public boolean isDirectory()：判斷是否是文件目錄
- public boolean isFile() ：判斷是否是文件
- public boolean exists() ：判斷是否存在
- public boolean canRead() ：判斷是否可讀
- public boolean canWrite() ：判斷是否可寫
- public boolean isHidden() ：判斷是否隱藏
File類的創建功能
public boolean createNewFile() ：創建文件。若文件存在，則不創建，返回false
public boolean mkdir() ：創建文件目錄。如果此文件目錄存在，就不創建了。如果此文件目錄的上層目錄不存在，也不創建。
public boolean mkdirs() ：創建文件目錄。如果上層文件目錄不存在，一併創建
註意事項：如果你創建文件或者 文件 目錄沒有 寫 盤符路徑 ， 那麼 ， 預設在項目
路徑下 。
File 類的刪除功能
- public boolean delete()：刪除文件或者文件夾
刪除註意事項：
Java中的刪除不走回收站。
要刪除一個文件目錄，請註意該文件目錄內不能包含文件或者文件目錄。
- public boolean delete()：刪除文件或者文件夾
1.3 應用舉例：文件過濾
判斷指定目錄下是否有尾碼名為.jpg的文件，如果有，就輸出該文件名稱
import org.junit.Test;
import java.io.File;
import java.io.FilenameFilter;
/**
* 判斷指定目錄下是否有尾碼名為.jpg的文件，如果有，就輸出該文件名稱
*/
public class FindJPGFileTest {
@Test
public void test1(){
File srcFile = new File("d:\\code");
String[] fileNames = srcFile.list();
for(String fileName : fileNames){
if(fileName.endsWith(".jpg")){
System.out.println(fileName);
}
}
}
@Test
public void test2(){
File srcFile = new File("d:\\code");
File[] listFiles = srcFile.listFiles();
for(File file : listFiles){
if(file.getName().endsWith(".jpg")){
System.out.println(file.getAbsolutePath());
}
}
}
/*
* File類提供了兩個文件過濾器方法
* public String[] list(FilenameFilter filter)
* public File[] listFiles(FileFilter filter)
*/
@Test
public void test3(){
File srcFile = new File("d:\\code");
File[] subFiles = srcFile.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".jpg");
}
});
for(File file : subFiles){
System.out.println(file.getAbsolutePath());
}
}
}1.4 應用舉例：遍歷指定目錄
import java.io.File;
/**
* 遍歷指定目錄所有文件名稱，包括子文件目錄中的文件。
拓展1：並計算指定目錄占用空間的大小
拓展2：刪除指定文件目錄及其下的所有文件
*/
public class ListFilesTest {
public static void main(String[] args) {
// 遞歸:文件目錄
/** 列印出指定目錄所有文件名稱，包括子文件目錄中的文件 */
// 1.創建目錄對象
File dir = new File("E:\\teach\\01_javaSE\\Java編程語言\\3_軟體");
// 2.列印目錄的子文件
printSubFile(dir);
}
public static void printSubFile(File dir) {
// 列印目錄的子文件
File[] subfiles = dir.listFiles();
for (File f : subfiles) {
if (f.isDirectory()) {// 文件目錄
printSubFile(f);
} else {// 文件
System.out.println(f.getAbsolutePath());
}
}
}
// 方式二：迴圈實現
// 列出file目錄的下級內容，僅列出一級的話
// 使用File類的String[] list()比較簡單
public void listSubFiles(File file) {
if (file.isDirectory()) {
String[] all = file.list();
for (String s : all) {
System.out.println(s);
}
} else {
System.out.println(file + "是文件！");
}
}
// 列出file目錄的下級，如果它的下級還是目錄，接著列出下級的下級，依次類推
// 建議使用File類的File[] listFiles()
public void listAllSubFiles(File file) {
if (file.isFile()) {
System.out.println(file);
} else {
File[] all = file.listFiles();
// 如果all[i]是文件，直接列印
// 如果all[i]是目錄，接著再獲取它的下一級
for (File f : all) {
listAllSubFiles(f);// 遞歸調用：自己調用自己就叫遞歸
}
}
}
// 拓展1：求指定目錄所在空間的大小
// 求任意一個目錄的總大小
public long getDirectorySize(File file) {
// file是文件，那麼直接返回file.length()
// file是目錄，把它的下一級的所有大小加起來就是它的總大小
long size = 0;
if (file.isFile()) {
size += file.length();
} else {
File[] all = file.listFiles();// 獲取file的下一級
// 累加all[i]的大小
for (File f : all) {
size += getDirectorySize(f);// f的大小;
}
}
return size;
}
// 拓展2：刪除指定的目錄
public void deleteDirectory(File file) {
// 如果file是文件，直接delete
// 如果file是目錄，先把它的下一級幹掉，然後刪除自己
if (file.isDirectory()) {
File[] all = file.listFiles();
// 迴圈刪除的是file的下一級
for (File f : all) {// f代表file的每一個下級
deleteDirectory(f);
}
}
// 刪除自己
file.delete();
}
}2. IO流的原理及分類
2.1 Java IO原理
- I/O是Input/Output的縮寫，I/O技術是非常實用的技術，用於處理設備之間的數據傳輸。如讀/寫文件，網路通訊等；
- Java程式中，對於數據的輸入/輸出操以“流（stream）”的方式進行；
- java.io包下提供了各種“流”類和介面，用以獲取不同種類的數據，並通過標準的方法輸出如或輸出數據。
2.2 流的分類
按操作數據單元不同分為：位元組流（8bit），字元流（16bit）；
按數據流的流向不同分為：輸入流、輸出流；
按流的角色的不同分為：節點流，處理流；
Java的IO流共涉及40多個類，實際上非常規則，都是從如下4個基類派生的。由這四個類派生出來的子類都是以其父類名作為尾碼；
（抽象基類） 位元組流 字元流 輸入流 InputStream Reader 輸出流 OutputStream Writer
2.3 節點流和處理流
- 節點流：直接從數據源或者目的地讀寫數據；
- 處理流：不直接連接到數據源或者目的地，而是“連接”在已存在的流（節點流或處理流）之上，通過對數據的處理為程式提供更為強大的讀寫功能。
3. 節點流（或文件流）FileReader和FileWriter
- 讀
package com.atguigu.java;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderWriterTest {
public static void main(String[] args) {
File file = new File("hello.txt");// 相較於當前功能
}
/*
將day09下的hello.txt文件內容讀入程式中，並輸出到控制台
說明點：
1. read()的理解：返回讀入的一個字元。如果達到文件末尾，返回-1
2. 異常的處理：為了保證流資源一定可以執行關閉操作。需要使用try-catch-finally處理
3. 讀入的文件一定要存在，否則就會報FileNotFoundException。
*/
@Test
public void testFileReader() {
FileReader fr = null;
try {
// 1. 實例化File類對象，指明要操作的文件
File file = new File("hello.txt"); // 相較於當前module
// 2. 提供具體的流
fr = new FileReader(file);
// 3. 數據的讀入
//read():返回讀入的一個字元。如果達到文件末尾，返回-1
//方式一：
// int data = fr.read();
// while(data != -1){
// System.out.println((char)data);
// data = fr.read();
// }
// 方式二：語法上針對方式一的修改
int data;
while((data = fr.read()) != -1){
System.out.println((char)data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 4. 關閉流
if(fr != null){
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//對read()操作升級：使用read的重載方法
@Test
public void testFileReader1() {
FileReader fr = null;
try {
// 1. File類的實例化
File file = new File("hello.txt");
// 2. FileReader流的實例化
fr = new FileReader(file);
// 3. 讀入的操作
//read(char[] cbuf):返回每次讀入cbuf數組中的字元的個數。如果達到文件末尾，返回-1
char[] cbuf = new char[5];
int len;
while((len = fr.read(cbuf)) != -1){
// 方式一：
// 錯誤的寫法
// for(int i = 0; i < cbuf.length; i++){
// System.out.print(cbuf[i]);
// }
// 正確的寫法：
// for(int i = 0; i < len; i++){
// System.out.print(cbuf[i]);
// }
// 方式二：
// 錯誤的寫法：對應方式一的錯誤寫法
// String str = new String(cbuf);
// System.out.print(str);
// 正確的寫法二：
String str= new String(cbuf, 0, len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fr != null){
// 4. 資源的關閉
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}- 寫
/*
從記憶體中寫出數據到硬碟的文件里。
說明：
1. 輸出操作，對應的File可以不存在的。並不會報異常
2.
File對應的硬碟中的文件如果不存在，在輸出的過程中，會自動創建此文件。
File對應的硬碟中的文件如果存在：
如果流使用的構造器是：FileWriter(file,false) / FileWriter(file):對原有文件的覆蓋
如果流使用的構造器是：FileWriter(file,true):不會對原有文件覆蓋，而是在原有文件基礎上追加內容
*/
@Test
public void testFileWriter() {
FileWriter fw = null;
try {
//1.提供File類的對象，指明寫出到的文件
File file = new File("hello1.txt");
//2.提供FileWriter的對象，用於數據的寫出
fw = new FileWriter(file,false);
//3.寫出的操作
fw.write("I have a dream!\n");
fw.write("you need to have a dream!");
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.流資源的關閉
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}- 讀寫
@Test
public void testFileReaderFileWriter() {
FileReader fr = null;
FileWriter fw = null;
try {
//1.創建File類的對象，指明讀入和寫出的文件
File srcFile = new File("hello.txt");
File destFile = new File("hello2.txt");
//不能使用字元流來處理圖片等位元組數據
// File srcFile = new File("愛情與友情.jpg");
// File destFile = new File("愛情與友情1.jpg");
//2.創建輸入流和輸出流的對象
fr = new FileReader(srcFile);
fw = new FileWriter(destFile);
//3.數據的讀入和寫出操作
char[] cbuf = new char[5];
int len;//記錄每次讀入到cbuf數組中的字元的個數
while((len = fr.read(cbuf)) != -1){
//每次寫出len個字元
fw.write(cbuf,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.關閉流資源
//方式一：
// try {
// if(fw != null)
// fw.close();
// } catch (IOException e) {
// e.printStackTrace();
// }finally{
// try {
// if(fr != null)
// fr.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
//方式二：
try {
if(fw != null)
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(fr != null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}4. 節點流（或文件流）FileInputStream和FileoutputStream
- 對於文本文件(.txt,.java,.c,.cpp)，使用字元流處理
- 對於非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用位元組流處理
//使用位元組流FileInputStream處理文本文件，可能出現亂碼。
@Test
public void testFileInputStream() {
FileInputStream fis = null;
try {
//1. 造文件
File file = new File("hello.txt");
//2.造流
fis = new FileInputStream(file);
//3.讀數據
byte[] buffer = new byte[5];
int len;//記錄每次讀取的位元組的個數
while((len = fis.read(buffer)) != -1){
String str = new String(buffer,0,len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null){
//4.關閉資源
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
實現對圖片的複製操作
*/
@Test
public void testFileInputOutputStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
File srcFile = new File("愛情與友情.jpg");
File destFile = new File("愛情與友情2.jpg");
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//複製的過程
byte[] buffer = new byte[5];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}5. 處理流之緩衝流
- 緩衝流：
- BufferedInputStream
- BufferedOutputStream
- BufferedReader
- BufferedWriter
- 作用；
- 提高流的讀取、寫入的速度
- 提高讀寫速度的原因：內部提供了一個緩存區；
- 處理流，就是“套接”在已有的流的基礎上。
5. 1 位元組型緩衝流實現非文本文件的複製操作
/*
實現非文本文件的複製
*/
@Test
public void BufferedStreamTest() throws FileNotFoundException {
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcFile = new File("愛情與友情.jpg");
File destFile = new File("愛情與友情3.jpg");
//2.造流
//2.1 造節點流
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造緩衝流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.複製的細節：讀取、寫入
byte[] buffer = new byte[10];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
// bos.flush();//刷新緩衝區
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.資源關閉
//要求：先關閉外層的流，再關閉內層的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//說明：關閉外層流的同時，內層流也會自動的進行關閉。關於內層流的關閉，我們可以省略.
// fos.close();
// fis.close();
}5. 2 字元型緩衝流實現文本文件的複製操作
使用BufferedReader和BufferedWriter實現文本文件的複製
*/
@Test
public void testBufferedReaderBufferedWriter(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
//創建文件和相應的流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//讀寫操作
//方式一：使用char[]數組
// char[] cbuf = new char[1024];
// int len;
// while((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
// // bw.flush();
// }
//方式二：使用String
String data;
while((data = br.readLine()) != null){
//方法一：
// bw.write(data + "\n");//data中不包含換行符
//方法二：
bw.write(data);//data中不包含換行符
bw.newLine();//提供換行的操作
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//關閉資源
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}6. 處理流之轉換流
- 轉換流提供了在位元組流和字元流之間的轉換；
- Java API提供了兩個轉換流
- InputStreamReder：將InputStream轉換為Reader；
- OutputStreamWriter：將Writer轉換為OutputStream；
- 位元組流中數據都是字元時，轉換成字元流操作更高效；
- 很多時候我們使用轉換流來處理文件亂碼問題，實現編碼和解碼的功能；
- 轉換流實現文件的讀入和寫出
import org.junit.Test;
import java.io.*;
/**
* 處理流之二：轉換流的使用
* 1.轉換流：屬於字元流
* InputStreamReader：將一個位元組的輸入流轉換為字元的輸入流
* OutputStreamWriter：將一個字元的輸出流轉換為位元組的輸出流
*
* 2.作用：提供位元組流與字元流之間的轉換
*
* 3. 解碼：位元組、位元組數組 --->字元數組、字元串
* 編碼：字元數組、字元串 ---> 位元組、位元組數組
*
*
* 4.字元集
*ASCII：美國標準信息交換碼。
用一個位元組的7位可以表示。
ISO8859-1：拉丁碼表。歐洲碼表
用一個位元組的8位表示。
GB2312：中國的中文編碼表。最多兩個位元組編碼所有字元
GBK：中國的中文編碼表升級，融合了更多的中文文字元號。最多兩個位元組編碼
Unicode：國際標準碼，融合了目前人類使用的所有字元。為每個字元分配唯一的字元碼。所有的文字都用兩個位元組來表示。
UTF-8：變長的編碼方式，可用1-4個位元組來表示一個字元。
*/
public class InputStreamReaderTest {
/*
此時處理異常的話，仍然應該使用try-catch-finally
InputStreamReader的使用，實現位元組的輸入流到字元的輸入流的轉換
*/
@Test
public void test1() throws IOException {
FileInputStream fis = new FileInputStream("dbcp.txt");
// InputStreamReader isr = new InputStreamReader(fis);//使用系統預設的字元集
//參數2指明瞭字元集，具體使用哪個字元集，取決於文件dbcp.txt保存時使用的字元集
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系統預設的字元集
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
}
/*
此時處理異常的話，仍然應該使用try-catch-finally
綜合使用InputStreamReader和OutputStreamWriter
*/
@Test
public void test2() throws Exception {
//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//2.讀寫過程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}
//3.關閉資源
isr.close();
osw.close();
}
}
7. 標準流、列印流、數據流
7.1 標準輸入流和標準輸出流
- System.in和System.out分別代表了系統標準的輸入和輸出設備
- 預設輸入設備是：鍵盤，輸出設備是：顯示器
- System.in的類型是InputStream
- System.out的類型是PrintStream，其是OutputStream的子類，FilterOutputStream 的子類
- 重定向：通過System類的setIn，setOut方法對預設設備進行改變。
- public static void setIn(InputStream in)
- public static void setOut(PrintStream out)
/*
1.標準的輸入、輸出流
1.1
System.in:標準的輸入流，預設從鍵盤輸入
System.out:標準的輸出流，預設從控制台輸出
1.2
System類的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定輸入和輸出的流。
1.3練習：
從鍵盤輸入字元串，要求將讀取到的整行字元串轉成大寫輸出。然後繼續進行輸入操作，
直至當輸入“e”或者“exit”時，退出程式。
方法一：使用Scanner實現，調用next()返回一個字元串
方法二：使用System.in實現。System.in ---> 轉換流 ---> BufferedReader的readLine()
*/
public static void main(String[] args) {
BufferedReader br = null;
try {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
while (true) {
System.out.println("請輸入字元串：");
String data = br.readLine();
if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
System.out.println("程式結束");
break;
}
String upperCase = data.toUpperCase();
System.out.println(upperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}7.2 列印流
- 實現將 基本數據類型的數據格式轉化為 字元串輸出
- 列印流：PrintStream和PrintWriter
- 提供了一系列重載的print()和println()方法，用於多種數據類型的輸出
- PrintStream和PrintWriter的輸出不會拋出IOException異常
- PrintStream和PrintWriter有自動flush功能
- PrintStream 列印的所有字元都使用平臺的預設字元編碼轉換為位元組。在需要寫入字元而不是寫入位元組的情況下，應該使用 PrintWriter 類。
- System.out返回的是PrintStream的實例
/*
2. 列印流：PrintStream 和PrintWriter
2.1 提供了一系列重載的print() 和 println()
2.2 練習：
*/
@Test
public void test2() {
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
// 創建列印輸出流,設置為自動刷新模式(寫入換行符或位元組 '\n' 時都會刷新輸出緩衝區)
ps = new PrintStream(fos, true);
if (ps != null) {// 把標準輸出流(控制台輸出)改成文件
System.setOut(ps);
}
for (int i = 0; i <= 255; i++) { // 輸出ASCII字元
System.out.print((char) i);
if (i % 50 == 0) { // 每50個數據一行
System.out.println(); // 換行
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
}7.3 數據流
- 為了方便地操作Java語言的基本數據類型和String的數據，可以使用數據流。
- 數據流有兩個類：(用於讀取和寫出基本數據類型、String類的數據）
- DataInputStream 和 DataOutputStream
- 在 分別“套接”在 InputStream 和 和 OutputStream子類的流 上
- DataInputStream 中的方法
- boolean readBoolean() byte readByte()
- char readChar() float readFloat()
- dou ble readDouble() short readShort()
- long readLong() int readInt()
- String readUTF() void readFully(byte[] b)
- DataOutputStream 中的方法
- 將上述的方法的read改為相應的write即可。
/*
3. 數據流
3.1 DataInputStream 和 DataOutputStream
3.2 作用：用於讀取或寫出基本數據類型的變數或字元串
練習：將記憶體中的字元串、基本數據類型的變數寫出到文件中。
註意：處理異常的話，仍然應該使用try-catch-finally.
*/
@Test
public void test3() throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("劉建辰");
dos.flush();//刷新操作，將記憶體中的數據寫入文件
dos.writeInt(23);
dos.flush();
dos.writeBoolean(true);
dos.flush();
dos.close();
}
/*
將文件中存儲的基本數據類型變數和字元串讀取到記憶體中，保存在變數中。
註意點：讀取不同類型的數據的順序要與當初寫入文件時，保存的數據的順序一致！
*/
@Test
public void test4() throws IOException {
//1.
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//2.
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("isMale = " + isMale);
//3.
dis.close();
}8. 對象流
8.1 對象流
- ObjectInputStream 和OjbectOutputSteam
- 用於存儲和讀取 基本數據類型數據或 對象的處理流。它的強大之處就是可以把Java中的對象寫入到數據源中，也能把對象從數據源中還原回來；
- 序列化：用ObjectOutputStream類 保存基本類型數據或對象的機制；
- 反序列化：用ObjectInputStream類 讀取基本類型數據或對象的機制；
- ObjectOutputStream和ObjectInputStream不能序列化static和transient修飾的成員變數。
import java.io.*;
/**
* 對象流的使用
* 1.ObjectInputStream 和 ObjectOutputStream
* 2.作用：用於存儲和讀取基本數據類型數據或對象的處理流。它的強大之處就是可以把Java中的對象寫入到數據源中，也能把對象從數據源中還原回來。
*/
public class ObjectInputOutputStreamTest {
/*
序列化過程：將記憶體中的java對象保存到磁碟中或通過網路傳輸出去
使用ObjectOutputStream實現
*/
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
oos.writeObject(new String("我愛北京天安門"));
oos.flush();//刷新操作
oos.writeObject(new Person("王銘",23));
oos.flush();
oos.writeObject(new Person("張學良",23,1001,new Account(5000)));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null){
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
反序列化：將磁碟文件中的對象還原為記憶體中的一個java對象
使用ObjectInputStream來實現
*/
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String) obj;
Person p = (Person) ois.readObject();
Person p1 = (Person) ois.readObject();
System.out.println(str);
System.out.println(p);
System.out.println(p1);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Person需要滿足如下的要求，方可序列化：
1.需要實現介面：Serializable
2.當前類提供一個全局常量：serialVersionUID
3.除了當前Person類需要實現Serializable介面之外，還必須保證其內部所有屬性也必須是可序列化的。（預設情況下，基本數據類型可序列化）。
8.2 對象的序列化
- 對象序列化機制允許把記憶體中的Java對象轉換成平臺無關的二進位流，從而允許把這種二進位流持久地保存在磁碟上，或通過網路將這種二進位流傳輸到另一個網路節點。//當其它程式獲取了這種二進位流，就可以恢覆成原
來的Java對象； - 序列化的好處在於可將任何實現了Serializable介面的對象轉化為 位元組數據，使其在保存和傳輸時可被還原；
- 序列化是 RMI（Remote Method Invoke – 遠程方法調用）過程的參數和返回值都必須實現的機制，而 RMI 是 JavaEE 的基礎。因此序列化機制是JavaEE 平臺的基礎；
- 如果需要讓某個對象支持序列化機制，則必須讓對象所屬的類及其屬性是可序列化的，為了讓某個類是可序列化的，該類必須實現如下兩個介面之一。否則，會拋出NotSerializableException異常
- Serializable
- Externalizable
- 凡是實現Serializable介面的類都有一個表示序列化版本標識符的靜態變數：
- private static final long serialVersionUID;
- serialVersionUID用來表明類的不同版本間的相容性。 簡言之，其目的是以序列化對象進行版本控制，有關各版本反序列化時是否相容。
- 如果類沒有顯示定義這個靜態常量，它的值是Java運行時環境根據類的內部細節自動生成的。若類的實例變數做了修改，serialVersionUID 可能發生變化。故建議，顯式聲明。
- 簡單來說，Java的序列化機制是通過在運行時判斷類的serialVersionUID來驗證版本一致性的。在進行反序列化時，JVM會把傳來的位元組流中的serialVersionUID與本地相應實體類的serialVersionUID進行比較，如果相同就認為是一致的，可以進行反序列化，否則就會出現序列化版本不一致的異常。(InvalidCastEx ception)
8.3 面試題
談談你對java.io.Serializable 介面的理解，我們知道它用於序列化，是空方法介面，還有其它認識嗎？
實現了Serializable 介面的對象，可將它們轉換成一系列位元組，並可在以後完全恢復回原來的樣子。 這一過程亦可通過網路進行。這意味著序列化機制能自動補償操作系統間的差異。在 換句話說，可以先在Windows 機器上創建一個對象，對其序列化，然後通過網路發給一臺Unix 機器，然後在那裡準確無誤地重新“裝配”。不必關心數據在不同機器上如何表示，也不必關心位元組的順序或者其他任何細節。
由於大部分作為參數的類如String 、Integer 等都實現了java.io.Serializable 的介面，也可以利用多態的性質，作為參數使介面更靈活。
9. 隨機存取文件流RandomAccessFile 類
- RandomAccessFile 聲明在java.io包下，但直接繼承於java.lang.Object類。並且它實現了DataInput、DataOutput這兩個介面，也就意味著這個類既可以讀也可以寫。
- RandomAccessFile 類支持 “隨機訪問” 的方式，程式可以直接跳到文件的任意地方來 讀、寫文件
- 支持只訪問文件的部分內容
- 可以向已存在的文件後追加內容
- RandomAccessFile 對象包含一個記錄指針，用以標示當前讀寫處的位置。RandomAccessFile 類對象可以自由移動記錄指針：
- long getFilePointer()：獲取文件記錄指針的當前位置
- void seek(long pos)：將文件記錄指針定位到 pos 位置
- 構造器
- public RandomAccessFile(File file, String mode)
- public RandomAccessFile(String name, String mode)
- 創建 RandomAccessFile 類實例需要指定一個 mode 參數，該參數指定 RandomAccessFile 的訪問模式：
- r: 以只讀方式打開
- rw ：打開以便讀取和寫入
- rwd: 打開以便讀取和 寫入；同步文件內容的更新
- rws: 打開以便讀取和 寫入； 同步文件內容和元數據 的 更新
- 如果模式為只讀r。則不會創建文件，而是會去讀取一個已經存在的文件，如果讀取的文件不存在則會出現異常。 如果模式為rw讀寫。如果文件不存在則會去創建文件，如果存在則不會創建。
import org.junit.Test;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* RandomAccessFile的使用
* 1.RandomAccessFile直接繼承於java.lang.Object類，實現了DataInput和DataOutput介面
* 2.RandomAccessFile既可以作為一個輸入流，又可以作為一個輸出流
*
* 3.如果RandomAccessFile作為輸出流時，寫出到的文件如果不存在，則在執行過程中自動創建。
* 如果寫出到的文件存在，則會對原有文件內容進行覆蓋。（預設情況下，從頭覆蓋）
*
* 4. 可以通過相關的操作，實現RandomAccessFile“插入”數據的效果
*/
public class RandomAccessFileTest {
@Test
public void test1() {
RandomAccessFile raf1 = null;
RandomAccessFile raf2 = null;
try {
//1.
raf1 = new RandomAccessFile(new File("愛情與友情.jpg"),"r");
raf2 = new RandomAccessFile(new File("愛情與友情1.jpg"),"rw");
//2.
byte[] buffer = new byte[1024];
int len;
while((len = raf1.read(buffer)) != -1){
raf2.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//3.
if(raf1 != null){
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(raf2 != null){
try {
raf2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void test2() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
raf1.seek(3);//將指針調到角標為3的位置
raf1.write("xyz".getBytes());//
raf1.close();
}
/*
使用RandomAccessFile實現數據的插入效果
*/
@Test
public void test3() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
raf1.seek(3);//將指針調到角標為3的位置
//保存指針3後面的所有數據到StringBuilder中
StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
byte[] buffer = new byte[20];
int len;
while((len = raf1.read(buffer)) != -1){
builder.append(new String(buffer,0,len)) ;
}
//調回指針，寫入“xyz”
raf1.seek(3);
raf1.write("xyz".getBytes());
//將StringBuilder中的數據寫入到文件中
raf1.write(builder.toString().getBytes());
raf1.close();
}
}
