Java IO初學

javaIO程式設計

IO體系

File

常用方法	解釋
mkdir	建立單個目錄
mkdirs	建立多個目錄
getPath	獲取檔案的路徑
length	獲取檔案的長度
getName	獲取檔名字
getParentFile	獲取檔案的上一層目錄
exists	判斷檔案是否存在
createNewFile	建立檔案
list	返回一個字串陣列命名目錄中的檔案和目錄
listFiles	返回一個抽象路徑名陣列表示用此抽象路徑名錶示的目錄中的檔案
getAbsolutePath	返回此抽象路徑名的絕對路徑名字串

檔案的建立

單檔案建立

@Test
    //檔案的建立
    public void IoFilePractise() throws IOException {
        File file = new File("D:\\file\\1.txt");
        //判斷file目錄是否存在
        if (!file.getParentFile().exists()) {
            System.out.println("D:\\file目錄不存在,立刻建立該目錄");
            file.getParentFile().mkdir();
        }
        //判斷1.txt檔案是否存在
        if 
 (!file.exists()) {
            System.out.println("1.txt檔案不存在，立刻建立該檔案");
            file.createNewFile();
        }
    }
複製程式碼

多層級檔案建立

@Test
    public void IoFilePractise3() throws IOException {
        File file=new File("D:\\file\\B\\B1\\B2\\rose.txt");
        //建立多個層級目錄
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        //建立rose.txt檔案
        if 
(!file.exists()){
            file.createNewFile();
        }
    }
複製程式碼

檔案的刪除

刪除指定的目錄和檔案，值得注意的是，如果只是刪除指定的目錄，目錄中還有其他檔案或者目錄的話，是沒辦法刪除成功的

@Test
    public void IoFilePractise1() throws IOException {
        File file = new File("D:\\file\\A\\jack.txt");
        //在上一個例子的基礎上，建立A目錄和jack.txt檔案
        file.getParentFile().mkdir();
        file.createNewFile();
        //嘗試直接刪除A目錄
        file.getParentFile().delete();
        //判斷是否刪除A目錄成功
        if (file.getParentFile().exists()) {
            System.out.println("A目錄沒有被刪除");
        } else {
            System.out.println("刪除A目錄成功");
        }
    }
複製程式碼

@Test
    //根據上面的為基礎
    public void IoFilePractise2() {
        File file = new File("D:\\file\\A\\jack.txt");
        file.delete();
        file.getParentFile().delete();
        //判斷是否刪除A目錄成功
        if (file.getParentFile().exists()) {
            System.out.println("A目錄沒有被刪除");
        } else {
            System.out.println("刪除A目錄成功");
        }
    }
複製程式碼

輸出檔案目錄

統計D盤下面所有的檔案的個數並且輸出名字，找出所有的txt檔案並且輸出和統計個數

    private static int fileNumber = 0;
    private static int txtFileNumber = 0;
    private static int directoryNumber = 0;

    @Test
    public void IoFilePractise4() {
        String filePath = "D:\\";
        findFile(filePath);
        System.out.println("檔案數：" + fileNumber);
        System.out.println("其中txt檔案數：" + txtFileNumber);
        System.out.println("檔案目錄數：" + directoryNumber);
    }

    public void findFile(String filePath) {
        File file = new File(filePath);
        //遍歷該路徑下面的所有檔案和目錄
        File[] listFile = file.listFiles();
        //如果檔案目錄下面沒有檔案遞迴停止
        if(listFile==null)return;
        //遞迴遍歷
        for (File fileTemp : listFile) {
            //如果是檔案
            if (fileTemp.isFile()) {
                fileNumber++;
                System.out.println(fileTemp.getName() + "為檔案");
                if (fileTemp.getName().endsWith(".txt")) {
                    txtFileNumber++;
                    System.out.println(fileTemp.getName() + "同時為txt檔案");
                }
            } else if (fileTemp.isDirectory()) {
                directoryNumber++;
                System.out.println(fileTemp.getName() + "為檔案目錄");
                findFile(fileTemp.getPath());
            }
        }
    }
複製程式碼

IO基本大類

子類的多數方法是繼承自父類，將父類的方法瞭解清楚，子類的使用也會迎刃而解

InputStream 類

方法	方法介紹
public abstract int read()	讀取資料
public int read(byte b[])	將讀取到的資料放在 byte 陣列中
public int read(byte b[],int off,int len)	從第 off 位置讀取 len 長度位元組的資料放到 byte 陣列中
public void close()	讀取完，關閉流，釋放資源

OutputStream 類

方法	方法介紹
public abstract void write(int b)	寫入一個位元組
public void write(byte b[])	將陣列中的所有位元組寫入
public void write(byte b[],int len)	將 byte 陣列從 off 位置開始，len 長度的位元組寫入
public void close()	關閉輸出流，流被關閉後就不能再輸出資料了

Reader 類

方法	方法介紹
public int read()	讀取單個字元
public int read(char cbuf[])	讀取字元到指定的 char 陣列中
abstract public int read(char cbuf[],int len)	從 off 位置讀取 len 長度的字元到 char 陣列中
abstract public void close()	關閉流釋放相關資源

Writer 類

方法	方法介紹
public void write(int c)	寫入一個字元
public void write(char cbuf[])	寫入一個字元陣列
abstract public void write(char cbuf[],int len)	從字元陣列的 off 位置寫入 len 數量的字元
abstract public void close()	關閉輸出流，流被關閉後就不能再輸出資料了

FileInputStream和FileOutputStream

一個位元組一個位元組的讀取

@Test
    public void FileRead() throws IOException {
        int count=0;//讀取次數
        FileInputStream fis = new FileInputStream("D:\\file\\1.txt");
        int len;
        //一個位元組一個位元組的讀取，讀完返回-1
        while ((len = fis.read()) != -1) {
            System.out.print((char)len);
            count++;
        }
        System.out.println("讀取次數:"+count);
        fis.close();
    }

複製程式碼

一次多個位元組的讀取

@Test
    public void FileRead() throws IOException {
        int count=0;//讀取次數
        FileInputStream fis = new FileInputStream("D:\\file\\1.txt");
        byte[] n=new byte[1024];
        int len;
        //一個位元組一個位元組的讀取，讀完返回-1
        while ((len = fis.read(n)) != -1) {
            //new String(byte[] bytes,int offset,int length) 通過使用平臺的預設字符集解碼指定的 byte 子陣列，構造一個新的 String
            System.out.println(new String(n,len));
            count++;
        }
        System.out.println("讀取次數:"+count);
        fis.close();
    }
複製程式碼

檔案寫入

 @Test
    public void FileWrite() throws IOException {
        //追加寫入
        FileOutputStream fos=new FileOutputStream("D:\\file\\1.txt",true);
        //寫入單個位元組
        fos.write(98);
        //寫入多個位元組
        fos.write(",Hello World!".getBytes());
        fos.close();
    }
複製程式碼

檔案拷貝

 @Test
    //1.txt的資料寫入到2.txt
    public void FileCopy() throws IOException {
        //沒有1.txt和2.txt檔案需要提前建立
        FileOutputStream fos=new FileOutputStream("D:\\file\\2.txt");
        FileInputStream fis=new FileInputStream("D:\\file\\1.txt");
        int len;
        byte[] n=new byte[1024];
        while((len=fis.read(n))!=-1){
            fos.write(n,len);
        }
        fos.close();
        fis.close();
    }
複製程式碼

BuffereInputStream和BuffereOutputStream

緩衝流拷貝

@Test
    public void FileBuffer() throws IOException {
        //裡面需要有FileInputStream和FileOutStream的物件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\file\\1.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\file\\2.txt"));
        int len;
        while((len = bis.read()) != -1){
            bos.write(len);
        }
        bos.close();
        bis.close();
    }
複製程式碼

InputStreamReader和OutputStreamWriter

帶有中文的拷貝

  @Test
    public void FileStream() throws IOException {
        //補充：一個字元在GBK編碼下佔2個位元組，即16位，在UTF-8編碼下佔三個位元組，即24位
        InputStreamReader isr=new InputStreamReader(new FileInputStream("D:\\file\\1.txt"),"GBK");
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("D:\\file\\2.txt"),"GBK");
        int len;
        char[] n=new char[1014];
        while((len= isr.read(n))!=-1){
            System.out.println(new String(n,len));
            osw.write(n,len);
        }
        isr.close();
        osw.close();
    }
複製程式碼

ObjectInputStream和ObjectOutputStream

ObjectOutputStream實際是在對流進行序列化操作，ObjectInputStream實際是在對流進行反序列化操作，要實現序列化，必須實現Serializable介面，否則是無法進行序列化和反序列化的，如果物件中的屬性加了transient和static關鍵字的話，則該屬性不會被序列化。

寫入和讀取物件

import java.io.Serializable;

public class Book implements Serializable {
    private String id;
    private String name;
    private int money;
    private transient int weight;

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ",name='" + name + '\'' +
                ",money=" + money +
                ",weight=" + weight +
                '}';
    }

    public Book(String id,String name,int money,int weight) {
        this.id = id;
        this.name = name;
        this.money = money;
        this.weight = weight;
    }
   ----- getter and setter-----
}

 @Test
    public void ObjectTest() throws IOException,ClassNotFoundException {
        //先寫入物件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\file\\1.txt",true));
        oos.writeInt(99);
        oos.writeObject(new Book("001","我的中國夢",100,45));
        oos.close();
        //再讀取物件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\file\\1.txt"));
        int readInt = ois.readInt();
        Book book = (Book) ois.readObject();
        System.out.println(readInt);
        System.out.println(book);
        ois.close();
    }
複製程式碼

結尾

作為java初學者，把IO瞭解到這個地步也就差不多了，後面可以根據興趣或者專案實際需要不斷的進行學習。我本人也是一個java菜鳥，還在上學，java基礎很差，寫部落格也主要是抱著學習的心態，如果上面有寫的不對的地方希望能夠指出。