雨落辰潇-文档站

Appearance

IO流 ​

File类 ​

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

构造方法

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

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

方法

exists()

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

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

isFile()

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

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

isDirectory()

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

getPath()

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

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

getAbsolutePath()

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

getName()

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

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

delete()

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

createNewFile()

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

length()

java
作用：返回文件的长度，单位为字节, 如果文件不存在，则返回 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包名，这个抽象类是表示输入字节流的所有类的超类，是抽象类。

构造方法

java
抽象类

方法

read()

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

read(byte [] date)

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

close()

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

available()

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

FileInputStream类 ​

FileInputStream类是InputStream类的子类。

构造方法

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

方法

read()

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

// 创建文件对象
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);// 强制类型转换
java
读取中文内容
// 读取中文内容时，需要注意文件内容的编码格式
// 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)

java
作用：读取文件内容
    
参数：表示每次读取一个字节数组大小的内容；
    
返回值：实际读取到字节的个数(例如5个字节),读取的内容保存在date数组中，如果读取到文件的末尾 返回值为-1;
    
示例：
java
每次读取一个字节数组大小内容
// 创建文件对象
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()

java
作用：关闭输入流资源，需要先做非空判断。
    
参数：无
    
返回值：无
    
示例：
// 创建文件读取流对象
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()

java
作用：获取可读内容长度。
    
参数：无
    
返回值：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包名，这个抽象类是表示字节输出流的所有类的超类，输出流接收输出字节并将其发送到某个接收器。是抽象类。

构造方法

java
无

方法

write()

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

close()

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

FileOutputStream类 ​

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

构造方法

java
// 直接写一个对应的文件的对象作为参数传入
// 创建文件对象
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)

java
作用：写入文件内容。
    
参数：写入单个字节 int
    
返回值：无
    
示例：
java
// 写一个字节
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);

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

write(byte[] data)

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

// 创建一个字节数组
byte [] data = {102,65,97};
// 写入
outputStream.write(data);
// 关闭流
outputStream.close();
java
// 使用字节写入流写入中文，需要把先把汉字转为字节数组
// 创建文件输入流对象
FileOutputStream outputStream = new FileOutputStream("D:\\Text file1.txt",true);

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

close()

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

字符流 ​

Reader类 ​

用于读取字符流的抽象类

构造方法

java
无

方法

read()

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

close()

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

InputStreamReader类 ​

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

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

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

构造方法

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

方法

read()

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

// 初始化 文件输入流对象
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 {

}
java

read(char[] data)

java
当参数为一个char[] char数组时，表示每次读取一个char数组；
    
作用：读取字符。
    
参数：每次读取一个字符数组 char[] data；
   
返回值：实际读取到的字符的个数，读取的内容保存在数组data中,当读取到末尾时返回值为-1
    
示例：
java
// 每次读取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()：在多个资源需要关闭的时候，需要遵循的原则是先用后关。

java
作用：关闭字符读取流。
    
参数：无
    
返回值：无
    
示例：
java
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类的子类

构造方法

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

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

方法

read()

java
作用：每次读取一个字符
    
参数：无
    
返回值：为读取内容的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)

java
作用：每次读取一个字符数组
    
参数：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()

java
作用：关闭资源
    
参数：无
    
返回值：无
    
示例：
// 定义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属于转换流。

构造方法

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

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

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

方法

String readLine()

java
作用：每次读取一行内容
    
参数：无
    
返回值：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()。

构造方法

java
抽象类 只能在本类中使用

方法

write(String str)

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

write(String str,int off,int length)

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

close()

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

flush()

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

OutputStreamWriter类 ​

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

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

java

构造方法

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

方法

write(String str)

java
作用：写入内容，直接写入字符串
    
参数：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)

java
作用：写入内容，直接写入字符串
    
参数：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()

java
作用：关闭流
    
参数：无
    
返回值：无
    
示例：
    
// 声明字节写入流对象
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()

java
作用：刷新内容，将内存中的数据刷新到硬盘上
    
参数：无
    
返回值：无
    
示例：
// 声明字节写入流对象
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();

}

指定写入流的编码格式

java
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类的子类。

  • 只能按照本地平台默认的编码格式写入文件。

构造函数

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

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

方法

write(String str)

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

flush()

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

close()

java
作用：关闭流资源
    
参数：无
    
返回值：无
    
示例：
// 声明写入文件对象
FileWriter writer = null;
// 创建对象 并且指定写入文件  如果文件不存在 将会自动创建
// 默认不写第二个参数 表示覆盖原文件内容
writer = new FileWriter("D.txt");
// 写入内容
writer.write("hello world");
writer.flush(); // 刷新缓存
writer.close(); // 关闭资源
java
// 完整案例
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方法，将缓存区中的内容，刷新到硬盘上，提高写入文件的效率。

构造方法

java
// 创建使用默认大小的输出缓冲区的缓冲字符输出流
// 参数是一个 字符写入流的子类 
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()

java
作用：换行方法
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
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)

java
作用：写入方法
    
参数：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()

java
作用：关闭流
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
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()

java
作用：刷新缓存到硬盘
    
参数：无
    
返回值：无
    
示例：
// 创建对象 以匿名对象的方法作为参数构造实例
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(); // 关闭资源
java
// 创建对象 以匿名对象的方法作为参数构造实例
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\test1.txt")));
// 写入文件 \n 和newline() 方法都可以实现换行的效果
writer.write("hello world \\n 世界你好");
writer.newLine();// 换行
writer.flush();// 刷新缓存
writer.close(); // 关闭资源

PrintWriter类 ​

将对象的格式表示打印到文本输出流，可以直接写入文件、网络流或 Servlet 响应流。常用于 Servlet 响应浏览器输出内容。

方法

println()

java
作用：将指定内容转换为字符串，并打印到输出流末尾，同时换行。
    
参数：public void println(String x)，要打印的对象或字符串，可以是任何类型（会被转换为字符串）。
    
返回值：无返回值
    
示例：
    
PrintWriter pw = new PrintWriter(System.out);
pw.println("Hello World!");
pw.println(123);
pw.println(true);
pw.flush();  // 将缓冲区内容刷新到控制台
pw.close();

数据流 ​

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

DataInputStream类 ​

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

构造方法

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

方法

read(byte[] data)

java
作用：每次读取一个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
java
// 声明字节读取流对象
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类 ​

用于写入二进制文件。

构造方法

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

方法

write(byte[] data)

java
作用：写入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);
java
// 声明字节读取流对象
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类 ​

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

构造方法

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

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

方法

readObject()

java
作用：读取二进制文件，每一次读，指针就会指向下一个对象，当读到末尾时，返回-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()

java
作用：返回可以读取而不阻塞的字节数
    
参数：
    
返回值：返回可以读取而不阻塞的字节数
    
示例：
// 创建读取流对象
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()

java
作用：关闭流
    
参数：
    
返回值：int类型
    
示例：
// 创建读取流对象
FileInputStream fileInputStream = null;
// 创建反序列化对象
ObjectInputStream objectInputStream = null;
// 创建对象
fileInputStream = new FileInputStream("D:\\Student.txt");
objectInputStream = new ObjectInputStream(fileInputStream);
// 关闭流
objectInputStream.close()
java
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);
        }
    }
}
java
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接口是一个空接口，只是相当于是一个标识，表示此类可以被序列化。

构造方法

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

方法

writeObject()

java
作用：将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);
java
// 被序列化的对象 所属的类必须实现序列化接口 Serializable接口
public class Student implements Serializable {
    ...
}

flush()

java
作用：刷新输出流
    
参数：无
    
返回值：无
    
示例：
// 创建字节写入流对象
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();
java
// 被序列化的对象 所属的类必须实现序列化接口 Serializable接口
public class Student implements Serializable {
    ...
}

close()

java
作用：关闭流
    
参数：无
    
返回值：无
    
示例：
// 创建字节写入流对象
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();

完整案例

java
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();
    }
}
java
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类的章节

示例：

java
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 +
                '}';
    }
}
java
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);
        }
    }
}

Copyright © 2024 雨落辰潇