69期-Java SE-020-IO流-1-001-002

 

### IO流

Java IO 流主要是指經過 Java 程序完成輸入、輸出的功能。所謂的輸入是指將文件以數據流的形式讀取到 Java 程序中，所謂的輸出是指經過 Java 程序將數據流寫入到文件中。

### File類

IO 流能夠實現 Java 程序對文件的讀寫操做，首先須要掌握的是 Java 如何來操做文件，經過 java.io.File 類來建立文件對象，從而完成相關操做。

File 類經常使用方法：

public File(String pathname)                                                        根據路徑建立文件對象

public String getName()                                                                獲取文件名

public String getParent()                                                                獲取文件所在的目錄

public File getParentFile()                                                                獲取文件所在目錄對應的 File 對象

public String getPath()                                                                    獲取文件路徑

public boolean exists()                                                                    判斷文件是否存在，true 表示存在，false 表示不存在

public boolean isDirectory()                                                            判斷對象是否爲目錄

public boolean isFile()                                                                      判斷對象是否爲文件

public long length()                                                                            獲取文件大小

public boolean createNewFile()                                                      根據當前對象建立新文件

public boolean delete()                                                                    刪除當前對象

public boolean mkdir()                                                                    根據當前對象建立新目錄

public boolean renameTo(File dest)                                             爲已存在的對象重命名



```java
import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        boolean flag = file.exists();
        if(flag) {
            System.out.println("文件存在");
            String fileName = file.getName();
            System.out.println("文件名："+fileName);
            long length = file.length();
            System.out.println("文件大小："+length);
            String path = file.getPath();
            System.out.println("文件路徑："+path);
            String parent = file.getParent();
            System.out.println("文件所在路徑："+parent);
            File parentFile = file.getParentFile();
            boolean flag2 = parentFile.isDirectory();
            if(flag2) {
                System.out.println("parentFile是路徑");
            }else {
                System.out.println("parentFile是文件");
            }
            boolean flag3 = parentFile.isFile();
            if(flag3) {
                System.out.println("parentFile是文件");
            }else {
                System.out.println("parentFile不是文件");
            }
        }else {
            System.out.println("文件不存在");
        }
        
        File file2 = new File("/Users/southwind/Desktop/test2.txt");
        try {
            System.out.println(file2.createNewFile());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        File file3 = new File("/Users/southwind/Desktop/test3.txt");
        System.out.println(file2.renameTo(file3));
        
        System.out.println(file2.delete());
        
    }
}
```



### 字節流

IO 流的 I 指 input，表示輸入，O 指 output，表示輸出。

流就是一組有序的數據序列，以先進先出的方式發送數據的通道，Java 中的流有不少種不一樣的分類。

- 按照方向分，能夠分爲輸入流和輸出流。
- 按照單位分，能夠分爲字節流和字符流，字節流指每次處理數據是以字節爲單位，字符流是指每次處理數據是以字符爲單位。
- 按照功能分，能夠分爲節點流和處理流。

字節流按照方向又能夠分爲輸入字節流（InputStream）和輸出字節流（OutputStream），InputSteam 是 java.io 包中的頂層父類，而且是一個抽象類。

```java
public abstract class InputStream implements Closeable
```

InputStream 經常使用方法

public abstract int read()                                                                            以字節爲單位讀取數據

public int read(byte b[])                                                                                將數據存入 byte 類型的數組中，而且返回數據長度

public byte[] readAllBytes()                                                                        將數據存入 byte 類型的數組中返回

public int read(byte b[],int off,int len)                                                        將數據存入 byte 類型的數組的指定區間中，並返回數據長度

public int available()                                                                                        返回當前數據流中未讀取的數據個數

public void close()                                                                                            關閉當前輸入流對象



```java
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class Test2 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        try {
            InputStream inputStream = new FileInputStream(file);
            int temp = 0;
            try {
                System.out.println("當前未讀取的數據個數"+inputStream.available());
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("開始讀取");
            while((temp = inputStream.read())!=-1) {
                System.out.println(temp);
                System.out.println("當前未讀取的數據個數"+inputStream.available());
            }
            inputStream.close();
            System.out.println("**********************************");
            inputStream = new FileInputStream(file);
            byte[] bytes = new byte[6];
            int length = inputStream.read(bytes);
            System.out.println("數據長度"+length);
            System.out.println("遍歷byte數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
            System.out.println("*********************************");
            inputStream = new FileInputStream(file);
            bytes = new byte[10];
            length = inputStream.read(bytes, 2, 3);
            System.out.println("數據長度"+length);
            System.out.println("遍歷byte數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
            System.out.println("**********************************");
            inputStream = new FileInputStream(file);
            bytes = inputStream.readAllBytes();
            System.out.println("遍歷 byte 數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
```



OutputStream 和 InputStream 相似，也是一個抽象父類，經常使用方法以下：

public abstract write(int b)                                                以字節爲單位寫數據

public void write(byte b[])                                                將 byte 類型數組中的數據寫出

public void write(byte b[],int off,int len)                        將 byte 類型數組中指定區間的數據寫出

public void flush()                                                                能夠強制將緩衝區的數據同步到輸出流中

public void close()                                                                關閉數據流



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

public class Test3 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test2.txt");
        try {
            OutputStream outputStream = new FileOutputStream(file);
            try {
                byte[] bytes = {105,111,99};
                outputStream.write(bytes,1,2);
                outputStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}
```



### 字符流

字符流按照流向能夠分爲輸出字符流（Writer）和輸入字符流（Reader），Reader 是一個抽象類，經常使用的方法以下：

public int read()                                                                    以字符爲單位讀取數據

public int read(char ch[])                                                    將數據讀入 char 類型數組，並返回數據長度

public abstract int read(char ch[],int off,int len)            將數據讀入 char 類型數組的指定區間，並返回數據長度

public abstract void close()                                                關閉數據流

public long transferTo(Writer out)                                    將數據直接讀入字符輸出流



```java
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Test4 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        try {
            Reader reader = new FileReader(file);
            char[] chars = new char[8];
            int length = reader.read(chars);
            System.out.println("數據長度"+length);
            System.out.println("遍歷數組");
            for(char c:chars) {
                System.out.println(c);
            }
            reader.close();
            System.out.println("************************");
            reader = new FileReader(file);
            chars = new char[8];
            length = reader.read(chars, 2, 6);
            System.out.println("數據長度"+length);
            System.out.println("遍歷數組");
            for(char c:chars) {
                System.out.println(c);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
```



輸出字符流 Writer，經常使用方法以下：

public void write(int c)                                                                以字符爲單位向外寫數據

public void write(char cha[])                                                     將 char 數組中的數據寫出

public abstract void write(char cha[],int off,int len)             將 char 數組中指定區間的數據寫出

public void write(String str)                                                        將 String 數據寫出

public void write(String str,int off,int len)                                將 String 類型指定區間的數據寫出

public abstract void flush()                                                        強制將緩衝區的數據同步到輸出流中

public abstract void close()                                                        關閉數據流

Test.java

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        boolean flag = file.exists();
        if(flag) {
            System.out.println("文件存在");
            String fileName = file.getName();
            System.out.println("文件名："+fileName);
            long length = file.length();
            System.out.println("文件大小："+length);
            String path = file.getPath();
            System.out.println("文件路徑："+path);
            String parent = file.getParent();
            System.out.println("文件所在路徑："+parent);
            File parentFile = file.getParentFile();
            boolean flag2 = parentFile.isDirectory();
            if(flag2) {
                System.out.println("parentFile是路徑");
            }else {
                System.out.println("parentFile是文件");
            }
            boolean flag3 = parentFile.isFile();
            if(flag3) {
                System.out.println("parentFile是文件");
            }else {
                System.out.println("parentFile不是文件");
            }
        }else {
            System.out.println("文件不存在");
        }
        
        File file2 = new File("/Users/southwind/Desktop/test2.txt");
        try {
            System.out.println(file2.createNewFile());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        File file3 = new File("/Users/southwind/Desktop/test3.txt");
        System.out.println(file2.renameTo(file3));
        
        System.out.println(file2.delete());
        
    }
}

 

Test2.java

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class Test2 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        try {
            InputStream inputStream = new FileInputStream(file);
            int temp = 0;
            try {
                System.out.println("當前未讀取的數據個數"+inputStream.available());
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("開始讀取");
            while((temp = inputStream.read())!=-1) {
                System.out.println(temp);
                System.out.println("當前未讀取的數據個數"+inputStream.available());
            }
            inputStream.close();
            System.out.println("**********************************");
            inputStream = new FileInputStream(file);
            byte[] bytes = new byte[6];
            int length = inputStream.read(bytes);
            System.out.println("數據長度"+length);
            System.out.println("遍歷byte數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
            System.out.println("*********************************");
            inputStream = new FileInputStream(file);
            bytes = new byte[10];
            length = inputStream.read(bytes, 2, 3);
            System.out.println("數據長度"+length);
            System.out.println("遍歷byte數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
            System.out.println("**********************************");
            inputStream = new FileInputStream(file);
            bytes = inputStream.readAllBytes();
            System.out.println("遍歷 byte 數組");
            for(byte b:bytes) {
                System.out.println(b);
            }
            inputStream.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

Test3.java

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

public class Test3 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test2.txt");
        try {
            OutputStream outputStream = new FileOutputStream(file);
            try {
                byte[] bytes = {105,111,99};
                outputStream.write(bytes,1,2);
                outputStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

 

Test4.java

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Test4 {
    public static void main(String[] args) {
        File file = new File("/Users/southwind/Desktop/test.txt");
        try {
            Reader reader = new FileReader(file);
            char[] chars = new char[8];
            int length = reader.read(chars);
            System.out.println("數據長度"+length);
            System.out.println("遍歷數組");
            for(char c:chars) {
                System.out.println(c);
            }
            reader.close();
            System.out.println("************************");
            reader = new FileReader(file);
            chars = new char[8];
            length = reader.read(chars, 2, 6);
            System.out.println("數據長度"+length);
            System.out.println("遍歷數組");
            for(char c:chars) {
                System.out.println(c);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}