Java—IO（学习至二哥的Java进阶之路）

深入了解 Java IO：各种流的分类与实际应用 | 二哥的Java进阶之路 (javabetter.cn)

流

指的是一连串的数据（字符或者字节），以一种以先进先出的方式发送消息的通道。

流的特性：

• 先进先出：最先写入输出流的数据最先被输入流读取到。

• 顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）。

• 只具有读或者只具有写的功能：每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。

流的传输方式：

• UTF-8 编码下，一个英文字母（不分大小写）为一个字节，一个中文汉字为三个字节；

• 在 Unicode 编码中，一个英文字母为一个字节，一个中文汉字为两个字节。

字节流

• 字节（byte）是计算机中用来表示存储容量的一个计量单位，通常情况下，一个字节有 8 位（bit）。

• 字节流用来处理二进制文件，比如说图片、MP3 、视频等等。

字符流

• 字符（char）可以是计算机中使用的字母、数字、和符号，比如说 A 1 $ 这些。

• 字符流用来处理文本文件，文本文件可以看作是一种特殊的二进制文件，只不过经过了编码，便于人们阅读。

IO类

inputStream

int read() //用于顺序读取数据
int read(byte b[], int pos, int len) //从pos位置开始读取数据，读取长度为len然后放入到b数组中
long skip(long n) //跳过指定长度的字节数
int available() //返回可读的字节数
void close() //关闭流资源

ouputSream

void wirte(int b) //写入一个字节的数据
void write(byte b[], int pos, int len) //将数组b中从pos位置开始写入数据，长度为len
void flush() //强制刷新，将缓冲区中的数据写入到文件中
void close() //关闭流资源

Reader

int read() //读取单个字符数据
int read(char cbuf[], int pos, int len) //从pos位置开始读取数据，读取长度为len然后放入到cbuf数组中
long skip(long n) //跳过指定长度的字符数
int ready() //用于标志缓冲区是否是可读状态
void close() //关闭流资源

Writer

void wirte(int c) //用于顺序读取数据
void write(char b[], int pos, int len) //将数组b中从pos位置开始写入数据，长度为len
void flush() //强制刷新，将缓冲区中的数据写入到文件中
void close() //关闭流资源

示例：

FileInputStream和FileOutputStream的示例

• FileInputStream和FileOutputStream的示例

• outputStream = new FileOutputStream(fileName2);第二个参数为true的时候，指定追加写入

package com.cj.filestream;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
/**
 * 读取一个文件的示例
 * 写入一个文件的示例
 */
public class InputOutputFile {
    /**
     * 读取文件
     */
    public static void readFile() throws IOException {
        FileInputStream fileInputStream = null;
        try {
            //声明一个int变量用于存储读取到的字节
            int b;
            //创建一个字节输入流，读取文件
            fileInputStream = new FileInputStream("file1.txt");
            //循环获取文件中的数据
            b = (char)fileInputStream.read();
            while(b != -1){
                System.out.println(b);
                b = (char)fileInputStream.read();
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
            System.out.println("文件读取异常");
        }
        catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取数据输出异常...");
        }finally {
            fileInputStream.close();
        }
    }
​
    /**
     * 将fileName1写入到fileName2中
     * @param fileName1
     * @param fileName2
     */
    public static Boolean writeFile(String fileName1, String fileName2) throws IOException {
        //读取文件fileName1
        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream(fileName1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件读取异常" + fileName1);
            return false;
        }
​
        //创建一个文件输出流，用于存放读取的文件信息
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(fileName2);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件读取异常" + fileName2);
            return false;
        }
        //使用文件输出流的write方法将信息写入fileName2中
        try {
            int temp = inputStream.read();
            // temp == -1 的时候数据读取结束
            while(temp != -1){
                outputStream.write(temp);
                temp = inputStream.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写入异常...");
            return false;
        }finally {
            inputStream.close();
            outputStream.close();
        }
        return true;
    }
    public static void main(String[] args) throws IOException {
        Boolean flag = writeFile("file1.txt", "file2.txt");
        if(flag){
            System.out.println("文件写入成功...");
        }else{
            System.out.println("文件写入失败...");
        }
    }
}

Reader和Writer的示例

• Reader和Writer的示例

• writer = new FileWriter(file2, true); 第二个参数可以省略，用于指定是否追加写入

package com.cj.fileReadWrite;
​
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
​
public class fileReadWrite {
    /**
     * 通过文件流读取数据
     * @param filename
     */
    public static void readFile(String filename) throws IOException {
        FileReader fileReader = null;
        try {
            //创建一个FileReader对象用于读取文件到流中
            fileReader = new FileReader(filename);
            //定义一个int变量存储读取的数据
            int temp = fileReader.read();
            while(temp != -1){
                System.out.println((char)temp);
                temp = fileReader.read();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件读取异常..." + filename);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("数据获取异常...");
        }finally {
            //关闭资源
            fileReader.close();
        }
    }
​
    /**
     *将file1的数据写入到file2中
     * @param file1
     * @param file2
     * @return
     */
    public static Boolean writeFile(String file1, String file2) throws IOException {
        //读取file1
        FileReader reader = null;
        try {
            reader = new FileReader(file1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件读取异常..." + file1);
            return false;
        }
        //写入file2
        FileWriter writer = null;
        try {
            writer = new FileWriter(file2, true);
            //创建一个int变量存储读取数据
            int temp = reader.read();
            while(temp != -1){
                writer.write(temp);
                temp = reader.read();
            }
​
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件读取异常..." + file2);
            return false;
        }catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写入异常..."+ file2);
            return false;
        } finally {
            reader.close();
            writer.close();
        }
        return true;
    }
    public static void main(String[] args) throws IOException {
        readFile("file1.txt");
        Boolean flag = writeFile("file1.txt", "file3.txt");
        if(flag){
            System.out.println("文件写入成功...");
        }else{
            System.out.println("文件写入失败...");
        }
    }
}