20200329

RandomAccessFile

java中唯一一個用於雙向操作的類：

1. RandomAccessFile(File,String->r/rw)
2. int read()/

檔案指標：

通過指標就可以在檔案的任意位置讀或者寫:

1. getfilePointer()獲取檔案指標所在的位置
2. seek(long)將檔案指標設定到指定位置
3. skipBytes(long)將檔案向後移動多少位元組

FileOutputStream

1. FileOutputStream(String)給定具體操作的檔案地址
2. FileOutputStream(File)給定具體操作的檔案
3. FileOutputStream(String,boolean)boolean表示是否追加true表示追加
4. FileOutputStream(File,boolean)

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Am01 {
    public static void main(String[] args) {
        File file=new File("file/fos.txt");
        if (!file.exists()){
            try{
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try(
                FileOutputStream fos=new FileOutputStream(file,true);
                ) {
            fos.write('A');
            fos.write("fjhfdbsjfbj".getBytes());
            fos.write("snfjsdjfsfds".getBytes(),6,7);
            System.out.println("寫出完畢");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

1. Write(int)寫該整數第八位
2. write(byte[])將整個位元組寫入的檔案中
3. write(byte[],off,lenth)將位元組陣列中的內容從指定位置開始寫，寫length個

        if(!file.exists()){
            System.out.println("檔案不存在");
            return;
        }
        try(
                FileInputStream fis=new FileInputStream(file);
                ) {
            int i=fis.read();
            //讀取一個位元組
            System.out.println((char)i);
            byte[]bs=new byte[1024];

           /* int k=fis.read(bs);
            System.out.println(new String(bs,0,k));
            //嘗試讀取bs長度的資料，返回值表示實際讀取到的位元組量*/

            int j=fis.read(bs,5,10);
            //嘗試讀取length個位元組，返回值表示實際讀取到的位元組量
            System.out.println(new String(bs,5,j));

        } catch (Exception e) {
            e.printStackTrace();
        }
 

FileInputStream

• FileInputStream

BufferedOutputStream/BufferedInputStream

1. 帶有緩衝區的流
2. 程式中維護一個緩衝區
3. 降低了寫檔案操作的頻率
4. 提高了寫操作的效率

• BufferedOutputStream

1. BufferedOutputStream（outputStream） 先寫入緩衝區，當緩衝區慢之後在通過包裝的底層流將內容寫出的檔案
2. write(int)
3. write(byte[])
4. write(byte[],off,length)
5. flush()手動清理緩衝區，再呼叫close（）方法時會先呼叫flush()方法再關閉流

import java.io.*;

public class Am02 {
    public static void main(String[] args) {
        File file=new File("src/Am/fos.txt");
        if (!file.exists()){
            try{
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try(
                FileOutputStream fos=new FileOutputStream(file,true);
                BufferedOutputStream bos=new BufferedOutputStream(fos);
                ) {
            bos.write("sjdfskajdfjsgdfjsd".getBytes());
           // bos.flush();//將緩衝區中的內容全部寫到檔案，並清空緩衝區
            System.out.println("寫出完畢");
        //    bos.close();//先清空緩衝區，再關閉流
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• BufferedInputStream

1. BufferedInputStream（InputStream）
2. read()
3. read(byte[])
4. read(byte,off,length)

import java.io.*;

public class Am02 {
    public static void main(String[] args) {
        File file=new File("src/Am/fos.txt");
        if (!file.exists()){
           return;
        }
        try(
                FileInputStream fos=new FileInputStream(file);
                BufferedInputStream bos=new BufferedInputStream(fos);
                ) {
           byte[]bs=new byte[1024];
           int i=bos.read(bs);
            System.out.println(new String(bs,0,i));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ObjectInputStream/ObjectOutputStream

• 物件流
• ObjectOutputStream

1. 寫物件到檔案中
2. 物件所屬類實現Serializable(序列化介面)
3. 只要類實現序列化介面--》編譯器就會自動新增一個方法--〉將物件轉為位元組陣列

• 持久化：將資料保留下來，將記憶體中的資料轉移到磁碟中

• 序列化：將物件轉為位元組陣列

• 反序列化：將位元組陣列轉為物件

• ObjectInputStream

1. 將檔案中的物件讀到程式中
2. 將位元組陣列轉為物件--》反序列化
3. readObject()

• Reader/writer抽象類，所有字元流的父類--》char為單位

• InputStream/OutputStream-->抽象類，所有位元組流的父類--〉byte為單位

• InputStreamReader/OutputStreamWriter轉換流--》java中唯一一組可以將位元組流轉為字元流

• OutputStreamWriter

1. OutputStreamWriter(OutputStream)
2. write(int):寫低十六位
3. write(char[])
4. write(String)
5. write(char[],off,length)
6. write(String,off,length)

import java.io.*;

public class Pm01 {
    public static void main(String[] args) {
        File file=new File("fos.txt");
        if (!file.exists()){
            try{
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try (
                FileOutputStream fos=new FileOutputStream(file);
                OutputStreamWriter oesw=new OutputStreamWriter(fos,"GBk");
                ){
            oesw.write('中');
            oesw.write("kdjhfshjdfkshdfksks".toCharArray(),3,3);
            oesw.write("hbdsfjhdfah",3,3);
            System.out.println("寫出完畢");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• InputStreamReader