IO流

File类

java.io.File 文件类，提供了用于操作文件、创建文件、获取文件信息等各种文件相关的方法。

构造方法

// 从父抽象路径名和子路径名字符串创建新的 File实例
File(File parent, String child) 

// 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 
File(String pathname) （常用）
    
pathname 绝对路径
File file1 = new File("C:\\User\\XXX\\Desktop\\xxx.txt")

方法

exists()

作用：判断文件或目录是否存在。
   
参数：无
    
返回值：布尔值
    
示例：
// 创建File对象
File file1 = new File("D:\\fileTest.txt");

// 文件是否存在
boolean exists = file1.exists();
System.out.println("文件是否存在 " + exists); // true

isFile()

作用：判断是否是文件形式。
   
参数：无
    
返回值：布尔值
    
示例：
// 创建File对象
File file1 = new File("D:\\fileTest.txt");

// 文件是否是文件形式
boolean file = file1.isFile();
System.out.println("是否是文件格式 " + file); // true

isDirectory()

作用：判断是否是目录。
   
参数：无
    
返回值：布尔值
    
示例：
// 是否是目录格式
boolean directory = file1.isDirectory();
System.out.println("是否是目录格式 " + directory); // false

getPath()

作用：返回此对象表示的文件的相对路径名。
   
参数：无
    
返回值：String类型
    
示例：
// 创建File对象
File file1 = new File("D:\\fileTest.txt");

// 返回文件对象的相对目录
String path = file1.getPath();
System.out.println("文件对象的相对路径 " + path); // D:\fileTest.txt

getAbsolutePath()

作用：返回此对象表示的文件的绝对路径名。
   
参数：无
    
返回值：String类型
    
示例：
// 创建File对象
File file1 = new File("D:\\fileTest.txt");    
    
// 返回文件对象的绝对目录
String path = file1.getAbsolutePath();
System.out.println("文件对象的绝对路径 " + path); // D:\fileTest.txt

getName()

作用：返回此对象表示的文件或目录的名称。
   
参数：无
    
返回值：String类型
    
示例：
// 创建File对象
File file1 = new File("D:\\fileTest.txt");

// 获取对象的文件名
String name = file1.getName();
System.out.println("文件名 " + name); // fileTest.txt

delete()

作用：删除此对象指定的文件或目录。
   
参数：
    
返回值：
    
示例：

createNewFile()

作用：创建名称的空文件，不创建文件夹。
   
参数：无
    
返回值：布尔值
    
示例：
File file2 = new File("D:\\fileTest2.txt");
// 创建文件
boolean newFile = file2.createNewFile();
System.out.println("文件是否成功创建 " + newFile); // 文件是否成功创建 true

length()

作用：返回文件的长度，单位为字节, 如果文件不存在，则返回 0L。
   
参数：无
    
返回值：long类型
    
示例：
// 创建文件
File file2 = new File("D:\\fileTest2.txt");
boolean newFile = file2.createNewFile();
long length = file2.length	();
System.out.println("文件的长度为 " + length); // 18
System.out.println("文件是否成功创建 " + newFile); // 文件是否成功创建 true

字节流

通过流来读写数据。字节流每次读取8位（一个字节），字符流每次读取16位（一个char的长度）。

一个汉字占用的字节：

UTF-16编码，每个char占用2个字节；
UTF-8编码，每个char占用3个字节；
GBK/GB2312编码，每个char占用2个字节；

InputStream类

java.io.InputStream包名，这个抽象类是表示输入字节流的所有类的超类，是抽象类。

构造方法

抽象类

方法

read()

作用：读取文件内容。抽象方法
    
参数：空时表示每次读取一个字节大小的内容；
 
返回值：
    当参数为空时，返回值为读取的文件中的内容(单个字符)ASCII码形式，
    每调用一次read方法，就会往后读取下一个字符(有一个指针，每一次读取指针就会指向下一个字符)；
    
示例：

read(byte [] date)

作用：读取文件内容
    
参数：表示每次读取一个字节数组大小的内容；
    
返回值：返回实际读取到字节的个数,读取的内容保存在date数组中，如果读取到文件的末尾 返回值为-1;
    
示例：

close()

作用：关闭输入流资源（此方法属于静态方法，使用类名访问），需要先做非空判断。抽象方法
    
参数：无
    
返回值：无
    
示例：

available()

作用：关闭输入流资源（此方法属于静态方法，使用类名访问），需要先做非空判断。抽象方法
    
参数：无
    
返回值：无
    
示例：

FileInputStream类

FileInputStream类是InputStream类的子类。

构造方法

// 创建文件读取流对象，参数是一个文件对象
FileInputStream(File file)
    
// 创建文件读取流对象，参数是文件的路径
FileInputStream(String name) 

方法

read()

作用：读取文件内容。
    
参数：空时表示每次读取一个字节大小的内容；
 
返回值：
    当参数为空时，返回值为读取的文件中的内容(单个字符)ASCII码形式，
    每调用一次read方法，就会往后读取下一个字符(有一个指针，每一次读取指针就会指向下一个字符)；
    
示例：

每次读取一个字节大小 示例

// 创建文件对象
File file1 = new File("D:\\Text file.txt");
// 创建文件读取流对象
FileInputStream inputStream = new FileInputStream(file1);
// 读取文件 每次读取一个字节大小内容
int read = inputStream.read(); // 返回一个字节大小的内容的ASCII表示
System.out.println(read);// 73
System.out.println((char) read);// 强制类型转换

读取中文内容
// 读取中文内容时，需要注意文件内容的编码格式
// GBK编码时，一个字符占2个字节;
// UTF-8编码时，一个字符占3个字节;

public static void main(String[] args) throws IOException {
    // 创建文件对象
    File file1 = new File("D:\\Text file.txt");
    // 创建文件读取流对象
    FileInputStream inputStream = null;

    try{
        // 创建输入流对象
        inputStream = new FileInputStream(file1);
        // 调用 available 方法获取可读内容长度
        int availableNum = inputStream.available();
        System.out.println("获取可读取内容长度： " + availableNum);
        // 创建字节数组，长度是获取到的可读内容长度（一次读完）
        byte[] data = new byte[availableNum];
        // 定义变量表示实际读取的字节的个数
        int readedNum = -1;
        // 循环遍历
        // 当读取到文件内容的末尾时，返回值为-1
        while((readedNum = inputStream.read(data)) != -1){ 
            // 使用String类中的构造方法将 字节数组转为 String类型
            // 第一个参数 byte数组,第二个参数 从0开始转换,第三个参数转换的数量(即读取到几个 就转换几个字节)
            System.out.println("读取字节个数：" + readedNum);
            String readedContent = new String(data,0,readedNum);
            System.out.println("读取到的内容：" + readedContent); // 打印每次读取到的内容
        }

    }catch (IOException e){
        // 打印异常堆栈信息
        e.printStackTrace();
    }finally {
        // 关闭资源
        if(inputStream != null){
            try {
                inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

read(byte[] data)

作用：读取文件内容
    
参数：表示每次读取一个字节数组大小的内容；
    
返回值：实际读取到字节的个数(例如5个字节),读取的内容保存在date数组中，如果读取到文件的末尾 返回值为-1;
    
示例：

每次读取一个字节数组大小内容
// 创建文件对象
File file1 = new File("D:\\Text file.txt");
// 创建文件读取流对象
FileInputStream inputStream = new FileInputStream(file1);

byte[] data = new byte[5];

// 定义变量表示实际读取的字节的个数
int readedNum = -1;

// 遍历 读取到的数据
// 当读取到文件内容的末尾时，返回值为-1
while((readedNum = inputStream.read(data)) != -1){ 
    // 使用String类中的构造方法将 字节数组转为 String类型
    // 第一个参数 byte数组,第二个参数 从0开始转换,第三个参数 转换的数量(即读取到几个 就转换几个字节)
    String readedContent = new String(data,0,readedLength);
    System.out.println(readedContent); // 打印每次读取到的内容
}

close()

作用：关闭输入流资源，需要先做非空判断。
    
参数：无
    
返回值：无
    
示例：
// 创建文件读取流对象
FileInputStream inputStream = null;


try{
    // 创建输入流对象
    inputStream = new FileInputStream(file1);
    ...
}catch (IOException e){
    // 打印异常堆栈信息
    e.printStackTrace();
}finally {
    // 关闭资源
    if(inputStream != null){
        try {
            inputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

available()

作用：获取可读内容长度。
    
参数：无
    
返回值：int类型，输入流可读长度
    
示例：
File file1 = new File("D:\\Text file.txt");    
FileInputStream inputStream = null;
// 创建输入流对象
inputStream = new FileInputStream(file1);
// 调用 available 方法获取可读内容长度
int availableNum = inputStream.available();

OutputStream类

java.io.OutputStream包名，这个抽象类是表示字节输出流的所有类的超类，输出流接收输出字节并将其发送到某个接收器。是抽象类。

构造方法

无

方法

write()

详见 FileOutputStream类（子类）中同名方法

close()

详见 FileOutputStream类（子类）中同名方法

FileOutputStream类

String类中的 实例方法中把 字符串转为 byte类型的数组（字节数组）

构造方法

// 直接写一个对应的文件的对象作为参数传入
// 创建文件对象
File file = new File("D:\\Text file.txt");
// 创建文件输入流对象
FileOutputStream OutputStream = new FileOutputStream(file);


// 可以传入写入文件的路径
FileOutputStream OutputStream1 = new FileOutputStream("D:\\Text file.txt");


// 传入文件的路径，同时设置一个布尔值表示是否可以在原有文件中追加内容，否则默认则是覆盖之前的内容。
FileOutputStream OutputStream2 = new FileOutputStream("D:\\Text file.txt",true);


// 如果文件不存在，则会自动创建这个文件。

方法

write(int data)

作用：写入文件内容。
    
参数：写入单个字节 int
    
返回值：无
    
示例：

// 写一个字节
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);

// 写入一个字节
outputStream.write(97); // a

write(byte[] data)

作用：写入文件内容。
    
参数：byte[] （字节数组）时，表示每次写入一个字节数组大小；
    
返回值：无
    
示例：
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);
// 关闭流
outputStream.close();

// 写入一个字节数组
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);

// 创建一个字节数组
byte [] data = {102,65,97};
// 写入
outputStream.write(data);
// 关闭流
outputStream.close();

// 使用字节写入流写入中文，需要把先把汉字转为字节数组
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);

// 创建字符传
String str = "争渡，争渡，惊起一滩鸥鹭";
// 调用 字符串实例的 getBytes方法 将字符串转为 字节数组
byte[] data = str.getBytes();
// 写入
outputStream.write(data);
// 关闭流
outputStream.close();

close()

作用：关闭文件写入流资源。
    
参数：无
    
返回值：无
    
示例：
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);
// 关闭流
outputStream.close();

字符流

Reader类

用于读取字符流的抽象类

构造方法

无

方法

read()

详见 InputStreamReader类（子类）同名方法使用

close()

详见 InputStreamReader类（子类）同名方法使用

InputStreamReader类

是Reader类的子类，字符读取流

**转换流：**InputStreamReader 可以作为参数构造BufferedReader实例，而InputStreamReader支持使用FileInputStream 字节读取流构建实例，所以 InputStreamReader属于转换流。

// 创建字节流读对象
inputStream = new FileInputStream("D:\\Test.txt");
// 创建字符流读对象(承上启下作用 又称为转换流)
inputStreamReader = new InputStreamReader(inputStream);
// 创建缓冲流对象
reader = new BufferedReader(inputStreamReader);

构造方法

// 可以指定编码格式读取文件，第一个参数是 inputStream对象，第二个参数是 字符编码
InputStreamReader(fileInputStream,"GBK"); // 常用于解决编码不一致，乱码问题
// 解决读取中文乱码问题（编码不一致）
inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");
// IDEA默认读取文件的格式为 UTF-8 格式,源文件的格式为ANSI(GBK),就会出现乱码。

方法

read()

作用：读取字符。
    
参数： 每次读取一个字符；
   
返回值：读取的内容，如果读取到文件末尾，返回值为-1
    
示例：

// 读取一个字符

// 初始化 文件输入流对象
FileInputStream fileInputStream = null;
// 初始化 字符读取流对象
InputStreamReader inputStreamReader = null;

try {
    // 创建对象
    fileInputStream = new FileInputStream("D:\\Text file.txt");
    inputStreamReader = new InputStreamReader(fileInputStream);

    // 每次读取一个字符
    int read = inputStreamReader.read();
    // 打印读取到的内容
    System.out.println("read = " + read);  // 字母I:73;汉字常：24120


}catch (IOException e){
    // 捕获异常
    e.printStackTrace();
}  finally {

}

read(char[] data)

当参数为一个char[] char数组时，表示每次读取一个char数组；
    
作用：读取字符。
    
参数：每次读取一个字符数组 char[] data；
   
返回值：实际读取到的字符的个数，读取的内容保存在数组data中,当读取到末尾时返回值为-1
    
示例：

// 每次读取char 数组长度
// 创建对象
fileInputStream = new FileInputStream("D:\\Text file.txt");
inputStreamReader = new InputStreamReader(fileInputStream);

// 创建一个长度为5的char数组
char [] data = new char[5];

// 定义变量表示实际读取字符的个数
int readedNum = -1;
// 遍历读取
while ((readedNum = inputStreamReader.read(data)) != -1){
    // 方式1：直接使用 println方法时，默认使用println方法的char数组的遍历方法
    //（当空数据时，会有上次遍历的旧数据遗留问题）
    System.out.println(data);
    // 方式2：使用String类中的构造方法，将char数组转为String类型
    String strFragment = new String(data, 0, readedNum);
    System.out.println(strFragment);// 字符片段，每5个字符遍历一次打印一行

}

close()：在多个资源需要关闭的时候，需要遵循的原则是先用后关。

作用：关闭字符读取流。
    
参数：无
    
返回值：无
    
示例：

package com.inputStreamPart;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestInputStreamReader {
    public static void main(String[] args){
        // 初始化 文件输入流对象
        FileInputStream fileInputStream = null;
        // 初始化 字符读取流对象
        InputStreamReader inputStreamReader = null;

        try {
            // 创建对象
            fileInputStream = new FileInputStream("D:\\Text file.txt");
            inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");

            // 每次读取一个字符数组
            char [] data = new char[5];
            // 初始化 实际读取字符的个数
            int readedNum = -1;
            // 遍历读取
            while ((readedNum = inputStreamReader.read(data)) != -1){
                // 方式1：直接使用 println方法时，默认使用println方法的char数组的遍历方法
                //（当空数据时，会有上次遍历的旧数据遗留问题）
                System.out.println(data);
                // 方式2：使用String类中的构造方法，将char数组转为String类型
                String strFragment = new String(data, 0, readedNum);
                System.out.println(strFragment);// 字符片段，每5个字符遍历一次打印一行

            }
        }catch (IOException e){
            // 捕获异常
            e.printStackTrace();
        }  finally {
            // 关闭资源
            try{
                // 在关闭之前做非空判断 因为如果为空 调用close方法 将出现空指针异常
                if(inputStreamReader != null){
                    inputStreamReader.close();
                }
                if(fileInputStream != null){
                    fileInputStream.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

FileReader类

FileReader类是InputStreamReader类的子类

构造方法

// 该类只能按照本地平台的字符编码来读取数据，用户不能指定其他的字符编码类型
// 可以使用它的父类InputStreamReader类来指定编码的类型

FileReader(File file)
// 构造方法 使用String类型
FileReader(String name)

方法

read()

作用：每次读取一个字符
    
参数：无
    
返回值：为读取内容的ASCII码或者Unicode编码(十进制),如果读取到末尾,则返回-1
    
示例：
    
// 定义FileReader对象
FileReader reader = null;
try{
    // 在当前目录下，创建文件
    reader = new FileReader("D:\\Test.txt");
    // 调用 read方法 读取一个字符
    int readData = reader.read();
    System.out.println("readData = " + readData); // readData = 67
}catch (IOException e){
    e.printStackTrace();
}finally {
    if (reader != null){
        // 关闭流
        try {
            reader.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

read(char [] data)

作用：每次读取一个字符数组
    
参数：char [] data
    
返回值：实际读取到字符的个数，读取到末尾，返回-1
    
示例：
    
// 定义FileReader对象
FileReader reader = null;
try{
    // 在当前目录下，创建文件
    reader = new FileReader("D:\\Test.txt");
    // 创建长度为10的char数组 用于保存读取数据
    char [] data = new char[10];
    // 定义每次读取字符的个数 初始化值为-1
    int readCount = -1;
    // 循环读取 循环条件为 读取字符个数不为-1
    while((readCount = reader.read(data)) != -1){
        // 将读取完毕的字符数组 转换为字符串
        // 第一个参数 为字符数组
        // 第二个参数 转换为字符串的起始位置
        // 第三个参数 转换个数
        System.out.println(new String(data,0,readCount));
    }

}catch (IOException e){
    e.printStackTrace();
}finally {
    if (reader != null){
        // 关闭流
        try {
            reader.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

close()

作用：关闭资源
    
参数：无
    
返回值：无
    
示例：
// 定义FileReader对象
FileReader reader = new FileReader("D:\\Test.txt");
  
if (reader != null){
    // 关闭流
    try {
        reader.close();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

BufferedReader类

缓冲区的字符读取流，也叫缓冲流，可以提高读取文件的效率。
父类是Reader类。

原理：因为读取过程是先将内容，读取到内容，等待一行读取完毕（一行有30或50个字符），再一次性加载到程序中，相当于减少了与硬盘、内存 IO的次数，所以效率更高。

**转换流：**InputStreamReader 可以作为参数构造BufferedReader实例，而InputStreamReader支持使用FileInputStream 字节读取流构建实例，所以 InputStreamReader属于转换流。

构造方法

// 可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

// 创建使用默认大小的输入缓冲区的缓冲字符输入流
BufferedReader(Reader in)

// 创建使用指定大小的输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
    
// InputStreamReader 可以作为参数构造BufferedReader实例

方法

String readLine()

作用：每次读取一行内容
    
参数：无
    
返回值：String类型
    
示例：
// 异常处理
try {
    // 创建字节流读对象
    inputStream = new FileInputStream("D:\\Test.txt");
    // 创建字符流读对象(承上启下作用 又称为转换流)
    inputStreamReader = new InputStreamReader(inputStream);
    // 创建缓冲流对象
    reader = new BufferedReader(inputStreamReader);
    // 声明读取内容返回值 因为每次读取一行 所以返回值为String类型
    String line = null;
    // 读取文件,遍历文件
    while( (line = reader.readLine()) != null){
        // 打印读取内容
        System.out.println(line);
    }
} catch (IOException e) {
    // 打印堆栈信息
    e.printStackTrace();
}finally {
    // 关闭之前做非空判断
    try {
        if (reader != null) {
            reader.close();
        }
        if (inputStreamReader != null) {
            inputStreamReader.close();
        }
        if (inputStream != null) {
            inputStream.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Writer类

用于写入字符流的抽象类。

子类必须实现的唯一方法是 write(char[]，int，int)，flush()和close()。

构造方法

抽象类 只能在本类中使用

方法

write(String str)

作用：写入内容，直接写入字符串
    
参数：字符串
    
返回值：无
    
示例：

write(String str,int off,int length)

作用：写入内容，直接写入字符串
    
参数：字符串
    
返回值：无
    
示例：

close()

作用：关闭资源
    
参数：无
    
返回值：无
    
示例：

flush()

作用：刷新内容，将内存中的内容刷新到硬盘上。
    
参数：无
    
返回值：无
    
示例：

OutputStreamWriter类

OutputStreamWriter是Writer类的子类。又叫作写入的转换流。

转化流：OutputStream类是FileWriter类的转化类

构造方法

// 参数是写字节流对象
OutputStreamWriter(OutputStream out)
    
// 参数是写字节流对象和指定的编码格式写入文件
OutputStreamWriter(OutputStream out,String charsetName)
    
// 查看默认平台的编码格式
System.getProperty("file.encoding");
// 写入的编码格式和读取的编码格式保持一致才不会出现乱码

方法

write(String str)

作用：写入内容，直接写入字符串
    
参数：String
    
返回值：无
    
示例：
// 声明字节写入流对象
FileOutputStream outputStream = null;
// 声明字符写入流对象
OutputStreamWriter writer = null;

try {
    // 创建字节写入流对象
    outputStream = new FileOutputStream("D:\\Test.txt",true);
    // 创建字符写入流对象
    writer = new OutputStreamWriter(outputStream);
    // 调用 write方法
    writer.write("遗憾早已是习惯");
    // 刷新数据到硬盘中
    writer.flush();

}catch (IOException e) {
            e.printStackTrace();
}finally {
    // 关闭流
    try {
        if (writer != null) {
            writer.close();
        }
        if(outputStream != null){
            outputStream.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

write(String str,int off,int length)

作用：写入内容，直接写入字符串
    
参数：String，字符串开始的位置，字符串结束的位置
    
返回值：无
    
示例：
// 声明字节写入流对象
FileOutputStream outputStream = null;
// 声明字符写入流对象
OutputStreamWriter writer = null;
try {
    // 创建字节写入流对象
    outputStream = new FileOutputStream("D:\\Test.txt",true);
    // 创建字符写入流对象
    writer = new OutputStreamWriter(outputStream);
    // 调用 write方法
    writer.write("遗憾早已是习惯",0,2);
    // 刷新到硬盘中
    writer.flush();

}

close()

作用：关闭流
    
参数：无
    
返回值：无
    
示例：
    
// 声明字节写入流对象
FileOutputStream outputStream = null;
// 声明字符写入流对象
OutputStreamWriter writer = null;

try {
    // 创建字节写入流对象
    outputStream = new FileOutputStream("D:\\Test.txt",true);
    // 创建字符写入流对象
    writer = new OutputStreamWriter(outputStream);
    // 调用 write方法
    writer.write("遗憾早已是习惯");
    // 刷新数据到硬盘中
    writer.flush();

}catch (IOException e) {
            e.printStackTrace();
}finally {
    // 关闭流
    try {
        if (writer != null) {
            writer.close();
        }
        if(outputStream != null){
            outputStream.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

flush()

作用：刷新内容，将内存中的数据刷新到硬盘上
    
参数：无
    
返回值：无
    
示例：
// 声明字节写入流对象
FileOutputStream outputStream = null;
// 声明字符写入流对象
OutputStreamWriter writer = null;
try {
    // 创建字节写入流对象
    outputStream = new FileOutputStream("D:\\Test.txt",true);
    // 创建字符写入流对象
    writer = new OutputStreamWriter(outputStream);
    // 调用 write方法
    writer.write("遗憾早已是习惯",0,2);
    // 刷新到硬盘中
    writer.flush();

}

指定写入流的编码格式

package com.outputStreamWrite;

import java.io.*;

public class TestOutputStreamWriter2 {
    public static void main(String[] args) {
        // 打印本地平台默认的编码格式
        System.out.println(System.getProperty("file.encoding")); // UTF-8
        // 创建字节流写入对象 如果文件不存在将自动创建
        FileOutputStream fileOutputStream = null;
        // 声明字符流写入对象
        OutputStreamWriter outputStreamWriter = null;
        // 创建字节流读对象
        FileInputStream fileInputStream = null;
        // 创建字符读取流对象
        InputStreamReader inputStreamReader = null;
        // 创建字符读取流缓存对象
        BufferedReader bufferedReader = null;

        try {
            // 创建字节流对象
            fileOutputStream = new FileOutputStream("D:\\test.txt");
            // 创建字符写入流对象
            outputStreamWriter = new OutputStreamWriter(fileOutputStream,"GBK");
            // 调用方法-写入
            outputStreamWriter.write("happy,世界");
            // 刷新缓存
            outputStreamWriter.flush();

            // -------------------------
            // 创建字节读取对象
            fileInputStream = new FileInputStream("D:\\test.txt");
            // 创建字符读取流对象
            // 因为写入的编码格式为 GBK 所以读取的编码格式也应该设置为  GBK 否则将出现乱码
            inputStreamReader = new InputStreamReader(fileInputStream,"GBK");
            // 创建字符读取流缓冲对象
            bufferedReader = new BufferedReader(inputStreamReader);
            // 调用读取流对象获取一行数据
            String str = bufferedReader.readLine();
            System.out.println(str);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 关闭资源
            if (outputStreamWriter != null){
                try {
                    // 关闭字符写入流资源
                    outputStreamWriter.close();
                    // 关闭字节写入流资源
                    fileOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

FileWriter类

FileWriter类是OutputStreamWriter类的子类。
只能按照本地平台默认的编码格式写入文件。

构造函数

// 该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型
// 给一个File对象构造一个FileWriter对象
FileWriter(File file)

// 构造一个给定文件名的FileWriter对象
FileWriter(String fileName)

方法

write(String str)

作用：写入文件
    
参数：String类型的字符串
    
返回值：无
    
示例：
// 声明写入文件对象
FileWriter writer = null;
// 创建对象 并且指定写入文件  如果文件不存在 将会自动创建
// 默认不写第二个参数 表示覆盖原文件内容
writer = new FileWriter("D.txt");
// 写入内容
writer.write("hello world");

flush()

作用：刷新内容，将内存中的数据刷新到硬盘上
    
参数：无
    
返回值：无
    
示例：
// 声明写入文件对象
FileWriter writer = null;
// 创建对象 并且指定写入文件  如果文件不存在 将会自动创建
// 默认不写第二个参数 表示覆盖原文件内容
writer = new FileWriter("D.txt");
// 写入内容
writer.write("hello world");
writer.flush(); // 刷新缓存

close()

作用：关闭流资源
    
参数：无
    
返回值：无
    
示例：
// 声明写入文件对象
FileWriter writer = null;
// 创建对象 并且指定写入文件  如果文件不存在 将会自动创建
// 默认不写第二个参数 表示覆盖原文件内容
writer = new FileWriter("D.txt");
// 写入内容
writer.write("hello world");
writer.flush(); // 刷新缓存
writer.close(); // 关闭资源

// 完整案例
package com.outputStreamWrite;

import java.io.FileWriter;
import java.io.IOException;

public class TestFileWriter {
    public static void main(String[] args) {
        // 声明写入文件对象
        FileWriter writer = null;

        try {
            // 创建对象
            writer = new FileWriter("D:\\test.txt");
            // 写入内容
            writer.write("Helle Yuluo 雨落辰潇");
            // 刷新内容
            writer.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            // 关闭资源
            try {
                if(writer != null){
                    writer.close();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedWriter类

BufferedWriter类是Writer类的子类，BufferedWrite类带有缓冲区。
BufferedWriter ：带有缓存区的字符写入流，写入的内容先保存在缓冲区，调用flush方法，将缓存区中的内容，刷新到硬盘上，提高写入文件的效率。

构造方法

// 创建使用默认大小的输出缓冲区的缓冲字符输出流
// 参数是一个 字符写入流的子类 
BufferedWriter(Writer out) 
// 以匿名方式创建 字符写入流缓存对象
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\test1.txt")));

// 以正常方式创建 字符写入流缓存对象
// 创建字节写入流对象
FileOutputStream fileOutputStream = new FileOutputStream("D:\\test1.txt");
// 创建字符写入流对象
OutputStreamWriter outPutStreamWriter = new OutputStreamWriter(fileOutputStream);
// 创建字符写入流缓存对象
BufferedWriter bufferWriter = new BufferedWriter(outPutStreamWriter);

方法

newline()

作用：换行方法
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
FileOutputStream fileOutputStream = new FileOutputStream("D:\\test1.txt");
// 创建字符写入流对象
OutputStreamWriter outPutStreamWriter = new OutputStreamWriter(fileOutputStream);
// 创建字符写入流缓存对象
BufferedWriter bufferWriter = new BufferedWriter(outPutStreamWriter);
// 写入文件 \n 和newline() 方法都可以实现换行的效果
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.newLine();// 换行

write(String str)

作用：写入方法
    
参数：String类型
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
FileOutputStream fileOutputStream = new FileOutputStream("D:\\test1.txt");
// 创建字符写入流对象
OutputStreamWriter outPutStreamWriter = new OutputStreamWriter(fileOutputStream);
// 创建字符写入流缓存对象
BufferedWriter bufferWriter = new BufferedWriter(outPutStreamWriter);
// 写入文件 \n 和newline() 方法都可以实现换行的效果
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.newLine();// 换行

close()

作用：关闭流
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
FileOutputStream fileOutputStream = new FileOutputStream("D:\\test1.txt");
// 创建字符写入流对象
OutputStreamWriter outPutStreamWriter = new OutputStreamWriter(fileOutputStream);
// 创建字符写入流缓存对象
BufferedWriter bufferWriter = new BufferedWriter(outPutStreamWriter);
// 写入文件 \n 和newline() 方法都可以实现换行的效果
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.newLine();// 换行
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.flush();// 刷新缓存
bufferWriter.close(); // 关闭资源

flush()

作用：刷新缓存到硬盘
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
FileOutputStream fileOutputStream = new FileOutputStream("D:\\test1.txt");
// 创建字符写入流对象
OutputStreamWriter outPutStreamWriter = new OutputStreamWriter(fileOutputStream);
// 创建字符写入流缓存对象
BufferedWriter bufferWriter = new BufferedWriter(outPutStreamWriter);
// 写入文件 \n 和newline() 方法都可以实现换行的效果
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.newLine();// 换行
bufferWriter.write("yuluochenxiao \n 世界你好");
bufferWriter.flush();// 刷新缓存
bufferWriter.close(); // 关闭资源

// 创建对象 以匿名对象的方法作为参数构造实例
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\test1.txt")));
// 写入文件 \n 和newline() 方法都可以实现换行的效果
writer.write("hello world \\n 世界你好");
writer.newLine();// 换行
writer.flush();// 刷新缓存
writer.close(); // 关闭资源

数据流

按照单元划分属于字节流。

DataInputStream类

用于读取二进制文件，图片，视频，音频等。

构造方法

// 创建使用指定的底层InputStream的DataInputStream
// 参数是一个字节读取流对象，使用InputStream类的子类FileInputStream类的对象
DataInputStream(InputStream in) 

方法

read(byte[] data)

作用：每次读取一个byte数组长度数据
    
参数：byte[] data：字节数组，读取到的数据保存在data参数中。
    
返回值：从包含的输入流中读取一些字节数 int
    
示例：
// 创建字节读取流对象
fileInputStream = new FileInputStream("D:\\test.png");
dataInputStream = new DataInputStream(fileInputStream);

//  定义byte数组 长度为此文件的可读字节数
byte [] data = new byte[fileInputStream.available()];
// 读取二进制文件,内容保存在byte数组中
int read = dataInputStream.read(data);
System.out.println("read = " + read); // 642452

// 声明字节读取流对象
FileInputStream fileInputStream = null;
// 声明数据流读取流对象
DataInputStream dataInputStream = null;

// 声明字节写入流对象
FileOutputStream fileOutputStream = null;
// 声明数据写入流对象
DataOutputStream dataOutputStream = null;
try {
    // 创建字节读取流对象
    fileInputStream = new FileInputStream("D:\\test.png");
    dataInputStream = new DataInputStream(fileInputStream);

    // 创建字节写入流对象
    fileOutputStream = new FileOutputStream("D:\\test2.png");
    dataOutputStream = new DataOutputStream(fileOutputStream);

    //  定义byte数组 长度为此文件的可读字节数
    byte [] data = new byte[fileInputStream.available()];
    // 读取二进制文件,内容保存在byte数组中
    int read = dataInputStream.read(data);
    System.out.println("read = " + read); // 642452

    // 写入二进制文件
    dataOutputStream.write(data);

} catch (IOException e) {
    e.printStackTrace();
}finally {
    // 关闭资源
    try {
        dataOutputStream.close();
        fileOutputStream.close();
        dataInputStream.close();
        fileInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

DataOutputStream类

用于写入二进制文件。

构造方法

// 创建一个新的数据输出流，以将数据写入指定的底层输出流
DataOutputStream(OutputStream out) 

方法

write(byte[] data)

作用：写入byte数组长度内容
    
参数：byte[] data，写入的数据是data参数中的数据
    
返回值：无
    
示例：
    
// 创建字节读取流对象
fileInputStream = new FileInputStream("D:\\test.png");
dataInputStream = new DataInputStream(fileInputStream);

//  定义byte数组 长度为此文件的可读字节数
byte [] data = new byte[fileInputStream.available()];
// 读取二进制文件,内容保存在byte数组中
int read = dataInputStream.read(data);
System.out.println("read = " + read); // 642452
// 写入二进制文件
dataOutputStream.write(data);

// 声明字节读取流对象
FileInputStream fileInputStream = null;
// 声明数据流读取流对象
DataInputStream dataInputStream = null;

// 声明字节写入流对象
FileOutputStream fileOutputStream = null;
// 声明数据写入流对象
DataOutputStream dataOutputStream = null;
try {
    // 创建字节读取流对象
    fileInputStream = new FileInputStream("D:\\test.png");
    dataInputStream = new DataInputStream(fileInputStream);

    // 创建字节写入流对象
    fileOutputStream = new FileOutputStream("D:\\test2.png");
    dataOutputStream = new DataOutputStream(fileOutputStream);

    //  定义byte数组 长度为此文件的可读字节数
    byte [] data = new byte[fileInputStream.available()];
    // 读取二进制文件,内容保存在byte数组中
    int read = dataInputStream.read(data);
    System.out.println("read = " + read); // 642452

    // 写入二进制文件
    dataOutputStream.write(data);

} catch (IOException e) {
    e.printStackTrace();
}finally {
    // 关闭资源
    try {
        dataOutputStream.close();
        fileOutputStream.close();
        dataInputStream.close();
        fileInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

对象流

序列化是指将对象保存在二进制文件中。
反序列化是指将保存有对象的二进制文件读取出来，生成新的对象。
被序列化的对象所属的类，必须实现Serializable接口。
对象流按照单元划分属于字节流。
transient关键字修饰的类的对象属性不会被序列化（永久保存）
static 关键字修饰的类的对象属性不会被序列化（永久保存）

Serializable接口是一个空接口，只是相当于是一个标识，表示此类可以被序列化。

ObjectInputStream类

反序列化，负责读取文件，生成新对象。

构造方法

// 完全重新实现ObjectInputStream的子类提供一种方法
protected  ObjectInputStream()

// 创建从指定的InputStream读取的ObjectInputStream
ObjectInputStream(InputStream in) 

方法

readObject()

作用：读取二进制文件，每一次读，指针就会指向下一个对象，当读到末尾时，返回-1
    
参数：无
    
返回值：Object类型对象
    
示例：

// 创建读取流对象
FileInputStream fileInputStream = null;
// 创建反序列化对象
ObjectInputStream objectInputStream = null;    

// 创建对象
fileInputStream = new FileInputStream("D:\\Student.txt");
objectInputStream = new ObjectInputStream(fileInputStream);
// 调用方法
Object obj1 = objectInputStream.readObject(); 
System.out.println(obj1); // Student{name='Sakuna', age=24}

available()

作用：返回可以读取而不阻塞的字节数
    
参数：
    
返回值：返回可以读取而不阻塞的字节数
    
示例：
// 创建读取流对象
FileInputStream fileInputStream = null;
// 创建反序列化对象
ObjectInputStream objectInputStream = null;
// 创建对象
fileInputStream = new FileInputStream("D:\\Student.txt");
objectInputStream = new ObjectInputStream(fileInputStream);
while(fileInputStream.available() > 0){
    Object o = objectInputStream.readObject(); // 每次读取一个对象
    System.out.println("o = " + o); // 打印
}

close()

作用：关闭流
    
参数：
    
返回值：int类型
    
示例：
// 创建读取流对象
FileInputStream fileInputStream = null;
// 创建反序列化对象
ObjectInputStream objectInputStream = null;
// 创建对象
fileInputStream = new FileInputStream("D:\\Student.txt");
objectInputStream = new ObjectInputStream(fileInputStream);
// 关闭流
objectInputStream.close()

package com.outputStreamWrite;

import java.io.*;

public class TestObjectInputStream {
    public static void main(String[] args) {
        // 创建Student类对象
        Student stu1 = new Student("Sakuna",24);
        Student stu2 = new Student("Aqua",24);
        Student stu3 = new Student("Yousa",24);

        // 创建字节写入流对象
        FileOutputStream fileOutputStream = null;
        // 创建序列化对象
        ObjectOutputStream objectOutputStream = null;

        // 创建读取流对象
        FileInputStream fileInputStream = null;
        // 创建反序列化对象
        ObjectInputStream objectInputStream = null;

        try {
            // 创建对象
            fileOutputStream = new FileOutputStream("D:\\Student.txt");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            // 写入对象
            objectOutputStream.writeObject(stu1);
            objectOutputStream.writeObject(stu2);
            objectOutputStream.writeObject(stu3);
            objectOutputStream.flush();
            // 关闭流
            objectOutputStream.close();

            // 创建对象
            fileInputStream = new FileInputStream("D:\\Student.txt");
            objectInputStream = new ObjectInputStream(fileInputStream);
            // 调用方法
            // Object obj1 = objectInputStream.readObject();
            // System.out.println(obj1); // Student{name='Sakuna', age=24}
            Object obj1 = objectInputStream.readObject();
            // 使用强制类型转换
            if (obj1 instanceof Student){
                // 强制类型转换
                Student stu = (Student) obj1;
                System.out.println(stu.getName());
                System.out.println(stu.getAge());
            }
            // 遍历对象
            // 判断可读字节数 大于0 表示文件中还有内容 继续读取
            while(fileInputStream.available() > 0){
                Object o = objectInputStream.readObject(); // 每次读取一个对象
                System.out.println("o = " + o); // 打印
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

package com.outputStreamWrite;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

ObjectOutputStream类

序列化，负责写入对象。把对象以二进制的形式进行保存到文件中。

被序列化的对象所属的类，必须实现Serializable接口。

Serializable接口是一个空接口，只是相当于是一个标识，表示此类可以被序列化。

构造方法

// 创建对象写入流对象，参数是字节写入流对象
ObjectOutputStream(OutputStream out) 

方法

writeObject()

作用：将Object类对象写入到文件中
    
参数：类对象
    
返回值：无
    
示例：
// 创建字节写入流对象
FileOutputStream fileOutputStream = null;
// 创建序列化对象
ObjectOutputStream objectOutputStream = null;
Student stu1 = new Student("Sakuna",24);
// 创建对象
fileOutputStream = new FileOutputStream("D:\\Student.txt");
objectOutputStream = new ObjectOutputStream(fileOutputStream);
// 写入对象
objectOutputStream.writeObject(stu1);

// 被序列化的对象 所属的类必须实现序列化接口 Serializable接口
public class Student implements Serializable {
    ...
}

flush()

作用：刷新输出流
    
参数：无
    
返回值：无
    
示例：
// 创建字节写入流对象
FileOutputStream fileOutputStream = null;
// 创建序列化对象
ObjectOutputStream objectOutputStream = null;
Student stu1 = new Student("Sakuna",24);
// 创建对象
fileOutputStream = new FileOutputStream("D:\\Student.txt");
objectOutputStream = new ObjectOutputStream(fileOutputStream);
// 写入对象
objectOutputStream.writeObject(stu1);
// 刷新对象
objectOutputStream.flush();
// 关闭流
objectOutputStream.close();

// 被序列化的对象 所属的类必须实现序列化接口 Serializable接口
public class Student implements Serializable {
    ...
}

close()

作用：关闭流
    
参数：无
    
返回值：无
    
示例：
// 创建字节写入流对象
FileOutputStream fileOutputStream = null;
// 创建序列化对象
ObjectOutputStream objectOutputStream = null;
Student stu1 = new Student("Sakuna",24);
// 创建对象
fileOutputStream = new FileOutputStream("D:\\Student.txt");
objectOutputStream = new ObjectOutputStream(fileOutputStream);
// 写入对象
objectOutputStream.writeObject(stu1);
// 刷新对象
objectOutputStream.flush();
// 关闭流
objectOutputStream.close();

完整案例

public static void main(String[] args) {
    // 创建Student类对象
    Student stu1 = new Student("Sakuna",24);
    Student stu2 = new Student("Aqua",24);
    Student stu3 = new Student("Yousa",24);

    // 创建字节写入流对象
    FileOutputStream fileOutputStream = null;
    // 创建序列化对象
    ObjectOutputStream objectOutputStream = null;


    try {
        // 创建对象
        fileOutputStream = new FileOutputStream("D:\\Student.txt");
        objectOutputStream = new ObjectOutputStream(fileOutputStream);
        // 写入对象
        objectOutputStream.writeObject(stu1);
        objectOutputStream.writeObject(stu2);
        objectOutputStream.writeObject(stu3);

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

package com.outputStreamWrite;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

transient关键字

如果不希望对象中某个属性被序列化，可以使用transient关键字修饰。

结合对象流序列化ObjectOutputStream类的章节

示例：

package com.outputStreamWrite;

import java.io.Serializable;

public class Student implements Serializable {
    // 设置 transient 关键字，让反序列化时忽略该属性
    private transient String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.outputStreamWrite;

import java.io.*;

public class TestObjectInputStream {
    public static void main(String[] args) {
        // 创建Student类对象
        Student stu1 = new Student("Sakuna",24);
        Student stu2 = new Student("Aqua",24);
        Student stu3 = new Student("Yousa",24);

        // 创建字节写入流对象
        FileOutputStream fileOutputStream = null;
        // 创建序列化对象
        ObjectOutputStream objectOutputStream = null;

        // 创建读取流对象
        FileInputStream fileInputStream = null;
        // 创建反序列化对象
        ObjectInputStream objectInputStream = null;

        try {
            // 创建对象
            fileOutputStream = new FileOutputStream("D:\\Student.txt");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            // 写入对象
            objectOutputStream.writeObject(stu1);
            objectOutputStream.writeObject(stu2);
            objectOutputStream.writeObject(stu3);
            objectOutputStream.flush();
            // 关闭流
            objectOutputStream.close();

            // 创建对象
            fileInputStream = new FileInputStream("D:\\Student.txt");
            objectInputStream = new ObjectInputStream(fileInputStream);
            // 调用方法
            // Object obj1 = objectInputStream.readObject();
            // System.out.println(obj1); // Student{name='Sakuna', age=24}
            Object obj1 = objectInputStream.readObject(); // 每次调用指针向后移动一个元素
            // 使用强制类型转换
            if (obj1 instanceof Student){
                // 强制类型转换
                Student stu = (Student) obj1;
                System.out.println(stu.getName());
                System.out.println(stu.getAge());
            }
            // 遍历对象
            // 判断可读字节数 大于0 表示文件中还有内容 继续读取
            while(fileInputStream.available() > 0){
                Object o = objectInputStream.readObject(); // 每次读取一个对象
                System.out.println("o = " + o); // 打印
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

File类​

字节流​

InputStream类​

FileInputStream类​

OutputStream类​

FileOutputStream类​

字符流​

Reader类​

InputStreamReader类​

FileReader类​

BufferedReader类​

Writer类​

OutputStreamWriter类​

FileWriter类​

BufferedWriter类​

数据流​

DataInputStream类​

DataOutputStream类​

对象流​

ObjectInputStream类​

ObjectOutputStream类​

transient关键字​

File类

字节流

InputStream类

FileInputStream类

OutputStream类

FileOutputStream类

字符流

Reader类

InputStreamReader类

FileReader类

BufferedReader类

Writer类

OutputStreamWriter类

FileWriter类

BufferedWriter类

数据流

DataInputStream类

DataOutputStream类

对象流

ObjectInputStream类

ObjectOutputStream类

transient关键字