S01-19 JavaSE-File类和IO流

[TOC]

文件

什么是文件

保存数据的载体（如文档、图片、视频等）

文件流

流：数据在程序（内存）和文件（磁盘）之间的传输路径
输入流：数据从文件到程序（读操作）
输出流：数据从程序到文件（写操作）

常用的文件操作

创建文件对象的三种方式

java

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;

/**
 * 演示创建文件
 * @author 韩顺平
 * @version 1.0
 */
public class FileCreate {
    // 方式1：new File(String pathname)
    @Test
    public void create01() {
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 方式2：new File(File parent, String child)
    @Test
    public void create02() {
        File parentFile = new File("e:\\");
        String fileName = "news2.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 方式3：new File(String parent, String child)
    @Test
    public void create03() {
        String parentPath = "e:\\";
        String fileName = "news3.txt";
        File file = new File(parentPath, fileName);
        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

获取文件相关信息

java

package com.hspedu.file;

import org.junit.jupiter.api.Test;
import java.io.File;

/**
 * 获取文件信息
 * @author 韩顺平
 * @version 1.0
 */
public class FileInformation {
    @Test
    public void info() {
        File file = new File("e:\\news1.txt");
        System.out.println("文件名字=" + file.getName());
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());
        System.out.println("文件是否存在=" + file.exists());
        System.out.println("是不是一个文件=" + file.isFile());
        System.out.println("是不是一个目录=" + file.isDirectory());
    }
}

目录操作和文件删除

方法	功能
`mkdir()`	创建一级目录
`mkdirs()`	创建多级目录
`delete()`	删除空目录或文件

IO 流原理及分类

IO 流原理

处理数据传输（读/写文件、网络通讯等）
java.io 包提供各类流类和接口

流的分类

分类方式	类型	说明
操作单位	字节流	操作二进制文件（8bit），基类 `InputStream`/`OutputStream`
	字符流	操作文本文件（按字符），基类 `Reader`/`Writer`
数据流方向	输入流	数据从文件到程序
	输出流	数据从程序到文件
流的角色	节点流	直接操作数据源（如 `FileInputStream`）
	处理流	包装节点流，增强功能（如 `BufferedInputStream`）

抽象基类对比

抽象基类	字节流	字符流
输入流	`InputStream`	`Reader`
输出流	`OutputStream`	`Writer`

常用 IO 流类

FileInputStream 应用（读文件）

java

package com.hspedu.inputstream_;

import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * FileInputStream 使用示例
 * @author 韩顺平
 * @version 1.0
 */
public class FileInputStream_ {
    // 单个字节读取（效率低）
    @Test
    public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(filePath);
            // 读取到 -1 表示结束
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char) readData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流，释放资源
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 字节数组读取（效率高）
    @Test
    public void readFile02() {
        String filePath = "e:\\hello.txt";
        byte[] buf = new byte[8]; // 一次读取 8 个字节
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(filePath);
            while ((readLen = fileInputStream.read(buf)) != -1) {
                // 转换为字符串输出（0 到 readLen 字节）
                System.out.print(new String(buf, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutputStream 应用（写文件）

java

package com.hspedu.outputstream_;

import org.junit.jupiter.api.Test;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * FileOutputStream 使用示例
 * @author 韩顺平
 * @version 1.0
 */
public class FileOutputStream01 {
    @Test
    public void writeFile() {
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            // 方式1：覆盖写入（false 可省略）
            // fileOutputStream = new FileOutputStream(filePath);
            // 方式2：追加写入
            fileOutputStream = new FileOutputStream(filePath, true);

            // 写入单个字节
            // fileOutputStream.write('H');

            // 写入字符串
            String str = "hsp,world!";
            // 写入整个字符串
            // fileOutputStream.write(str.getBytes());
            // 写入前 3 个字符
            fileOutputStream.write(str.getBytes(), 0, 3);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件拷贝（字节流应用）

java

package com.hspedu.outputstream_;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 文件拷贝示例（图片/音乐等二进制文件）
 * @author 韩顺平
 * @version 1.0
 */
public class FileCopy {
    public static void main(String[] args) {
        String srcFilePath = "e:\\Koala.jpg"; // 源文件路径
        String destFilePath = "e:\\Koala3.jpg"; // 目标文件路径

        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);

            byte[] buf = new byte[1024]; // 缓冲区，提高效率
            int readLen = 0;

            // 一边读，一边写
            while ((readLen = fileInputStream.read(buf)) != -1) {
                fileOutputStream.write(buf, 0, readLen);
            }

            System.out.println("拷贝 ok~");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileReader 和 FileWriter

FileReader 和 FileWriter 介绍

顶层接口	相关类继承关系
AutoCloseable	Closeable -> Reader/Writer；Closeable -> InputStream/OutputStream
Readable	Reader
Appendable	Writer
Flushable	Writer
具体实现类	Reader -> InputStreamReader -> FileReader；Writer -> OutputStreamWriter -> FileWriter

FileReader 相关方法

new FileReader(File/String)：创建FileReader对象
read()：每次读取单个字符，返回该字符；到文件末尾返回-1
read(char[])：批量读取多个字符到数组，返回读取到的字符数；到文件末尾返回-1

相关API：

new String(char[])：将char[]转换成String
new String(char[], off, len)：将char[]的指定部分转换成String

FileWriter 常用方法

new FileWriter(File/String)：覆盖模式，流指针在首端
new FileWriter(File/String, true)：追加模式，流指针在尾端
write(int)：写入单个字符
write(char[])：写入指定数组
write(char[], off, len)：写入指定数组的指定部分
write(String)：写入整个字符串
write(String, off, len)：写入字符串的指定部分

相关API：

String.toCharArray()：将String转换成char[]

注意：FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定的文件！

FileReader 和 FileWriter 应用案例

案例1：使用FileReader读取文件

java

package com.hspedu.reader_;

import org.junit.jupiter.api.Test;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileReader_ {
    public static void main(String[] args) {
    }

    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            // 1. 创建FileReader对象
            fileReader = new FileReader(filePath);
            // 循环读取，单个字符读取
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 字符数组读取文件
     */
    @Test
    public void readFile02() {
        System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int readLen = 0;
        char[] buf = new char[8]; // 缓冲区
        try {
            // 1. 创建FileReader对象
            fileReader = new FileReader(filePath);
            // 循环读取，返回实际读取到的字符数
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

案例2：使用FileWriter写入文件

java

package com.hspedu.writer_;

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

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileWriter_ {
    public static void main(String[] args) {
        String filePath = "e:\\note.txt";
        FileWriter fileWriter = null;
        char[] chars = {'a', 'b', 'c'};
        try {
            // 创建FileWriter对象（默认覆盖模式）
            fileWriter = new FileWriter(filePath);
            
            // 3) 写入单个字符
            fileWriter.write('H');
            
            // 4) 写入指定数组
            fileWriter.write(chars);
            
            // 5) 写入指定数组的指定部分
            fileWriter.write("韩顺平教育".toCharArray(), 0, 3);
            
            // 6) 写入整个字符串
            fileWriter.write(" 你好北京~");
            fileWriter.write("风雨之后,定见彩虹");
            
            // 7) 写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 必须关闭或刷新才能写入文件
                if (fileWriter != null) {
                    fileWriter.close(); // close() 包含 flush()
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序结束");
    }
}

节点流和处理流

基本介绍

节点流：直接从特定数据源读写数据（如FileReader、FileWriter、FileInputStream等）
- 示意图：文件 ↔ 节点流 ↔ 程序
处理流（包装流）：连接在已存在的流（节点流或处理流）之上，提供更强大的读写功能
- 示意图：文件/其他数据源 ↔ 节点流 ↔ 处理流 ↔ 程序

节点流和处理流一览图

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
抽象基类	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

节点流和处理流的区别和联系

节点流是底层流/低级流，直接与数据源相接
处理流包装节点流，消除不同节点流的实现差异，提供更便捷的方法
处理流使用修饰器设计模式，不直接与数据源相连

处理流的功能

性能提高：通过增加缓冲提高输入输出效率
操作便捷：提供批量读写等便捷方法

处理流-BufferedReader 和 BufferedWriter

特点

字符流，按字符读取数据
关闭时只需关闭外层处理流，底层会自动关闭节点流

应用案例1：使用BufferedReader读取文本文件

java

package com.hspedu.reader_;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示BufferedReader使用
 */
public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\a.java";
        // 创建BufferedReader（包装FileReader）
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        
        String line;
        // 按行读取，返回null表示文件结束
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        
        // 只需要关闭外层流
        bufferedReader.close();
    }
}

应用案例2：使用BufferedWriter写入文件

java

package com.hspedu.writer_;

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

/**
 * @author 韩顺平
 * @version 1.0
 * 演示BufferedWriter的使用
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\ok.txt";
        // 创建BufferedWriter（追加模式：new FileWriter(filePath, true)）
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        
        bufferedWriter.write("hello, 韩顺平教育!");
        bufferedWriter.newLine(); // 插入系统相关的换行符
        bufferedWriter.write("hello2,!");
        bufferedWriter.newLine();
        bufferedWriter.write("hello3,!");
        bufferedWriter.newLine();
        
        // 关闭外层流
        bufferedWriter.close();
    }
}

应用案例3：使用BufferedReader和BufferedWriter拷贝文本文件

java

package com.hspedu.writer_;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 文本文件拷贝（字符流）
 */
public class BufferedCopy_ {
    public static void main(String[] args) {
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a2.java";
        
        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;
        
        try {
            br = new BufferedReader(new FileReader(srcFilePath));
            bw = new BufferedWriter(new FileWriter(destFilePath));
            
            // 按行读取并写入
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine(); // 补充换行符
            }
            System.out.println("拷贝完毕...");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            try {
                if (br != null) br.close();
                if (bw != null) bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：字符流不能操作二进制文件（声音、视频、doc、pdf等），否则会导致文件损坏

处理流-BufferedInputStream 和 BufferedOutputStream

介绍

BufferedInputStream：字节流，创建时会创建内部缓冲区数组，提高字节读取效率
BufferedOutputStream：字节流，实现缓冲的输出流，批量写入字节到底层输出流

应用案例：拷贝二进制文件（图片/音乐/视频等）

java

package com.hspedu.outputstream_;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 二进制文件拷贝（字节缓冲流）
 */
public class BufferedCopy02 {
    public static void main(String[] args) {
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\hsp.jpg";
        
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        
        try {
            // 包装节点流
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
            
            byte[] buff = new byte[1024];
            int readLen = 0;
            // 循环读取并写入
            while ((readLen = bis.read(buff)) != -1) {
                bos.write(buff, 0, readLen);
            }
            System.out.println("文件拷贝完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭外层流
            try {
                if (bis != null) bis.close();
                if (bos != null) bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

对象流-ObjectInputStream 和 ObjectOutputStream

核心概念

序列化：保存数据时，同时保存数据的值和数据类型
反序列化：恢复数据时，同时恢复数据的值和数据类型
实现序列化：类必须实现 Serializable（标记接口，无方法）或 Externalizable（需实现方法）

应用案例1：序列化数据（基本类型+对象）

java

package com.hspedu.outputstream_;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示对象序列化
 */
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception {
        String filePath = "e:\\data.dat";
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        
        // 序列化基本类型
        oos.writeInt(100);
        oos.writeBoolean(true);
        oos.writeChar('a');
        oos.writeDouble(9.5);
        oos.writeUTF("韩顺平教育");
        
        // 序列化对象
        oos.writeObject(new Dog("旺财", 10, "日本", "白色"));
        
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
}

// 实现Serializable接口
class Dog implements Serializable {
    private String name;
    private int age;
    private String country;
    private String color;
    
    public Dog(String name, int age, String country, String color) {
        this.name = name;
        this.age = age;
        this.country = country;
        this.color = color;
    }
    
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

应用案例2：反序列化数据

java

package com.hspedu.inputstream_;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示对象反序列化
 */
public class ObjectInStream_ {
    public static void main(String[] args) throws Exception {
        String filePath = "e:\\data.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        
        // 反序列化（读取顺序必须与序列化顺序一致）
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());
        System.out.println(ois.readObject());
        
        ois.close();
        System.out.println("以反序列化的方式读取(恢复)ok~");
    }
}

注意事项和细节

读写顺序必须一致
序列化对象必须实现 Serializable 接口
建议添加 SerialVersionUID，提高版本兼容性
static 和 transient 修饰的成员不会被序列化
对象的属性类型也必须实现序列化接口
序列化具有可继承性（父类实现，子类默认实现）

标准输入输出流

类型	对应类	默认设备
System.in	InputStream	键盘
System.out	PrintStream	显示器

应用案例

标准输出：System.out.println("Hello")
标准输入：Scanner scanner = new Scanner(System.in)

转换流-InputStreamReader 和 OutputStreamWriter

核心功能

InputStreamReader：将字节流（InputStream）转换为字符流（Reader）
OutputStreamWriter：将字节流（OutputStream）转换为字符流（Writer）
解决中文乱码问题，可指定编码格式（utf-8、gbk、gb2312等）

应用案例1：InputStreamReader 解决中文乱码

java

package com.hspedu.transformation;

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

/**
 * @author 韩顺平
 * @version 1.0
 * 转换流解决中文乱码
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\a.txt";
        // 字节流转字符流，指定编码gbk
        BufferedReader br = new BufferedReader(
                new InputStreamReader(new FileInputStream(filePath), "gbk")
        );
        
        String s = br.readLine();
        System.out.println("读取内容: " + s);
        br.close();
    }
}

应用案例2：OutputStreamWriter 指定编码写入

java

package com.hspedu.transformation;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 转换流指定编码写入
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";
        // 字节流转字符流，指定编码gbk
        OutputStreamWriter osw = new OutputStreamWriter(
                new FileOutputStream(filePath), "gbk"
        );
        
        osw.write("hello,韩顺平教育~");
        osw.close();
        System.out.println("保存成功~");
    }
}

打印流-PrintStream 和 PrintWriter

特点

只有输出流，没有输入流
PrintStream（字节流）、PrintWriter（字符流）
支持自动刷新、格式化输出

应用案例1：PrintStream

java

package com.hspedu.printstream;

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示PrintStream（字节打印流）
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        // 默认输出到显示器
        PrintStream out = System.out;
        out.print("john, hello");
        out.write("韩顺平,你好".getBytes());
        out.close();
        
        // 重定向输出到文件
        System.setOut(new PrintStream("e:\\f1.txt"));
        System.out.println("hello, 韩顺平教育~");
    }
}

应用案例2：PrintWriter

java

package com.hspedu.printstream;

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

/**
 * @author 韩顺平
 * @version 1.0
 * 演示PrintWriter（字符打印流）
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        // 输出到文件
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
        printWriter.print("hi, 北京你好~~~~");
        printWriter.close(); // 必须关闭才会写入
    }
}

Properties 类

核心功能

专门用于读写配置文件（键值对格式：key=value）
键值对无空格，值无需引号，默认类型为String

常见方法

方法名	功能说明
load(InputStream)	加载配置文件的键值对到Properties对象
list(PrintStream)	将数据显示到指定设备
getProperty(String key)	根据键获取值
setProperty(String key, String value)	设置键值对到Properties对象
store(OutputStream, String comment)	将键值对存储到配置文件（中文会转为unicode）

应用案例1：读取配置文件

java

package com.hspedu.properties_;

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

/**
 * @author 韩顺平
 * @version 1.0
 * 读取mysql.properties配置文件
 */
public class Properties02 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        // 加载配置文件
        properties.load(new FileReader("src\\mysql.properties"));
        
        // 显示所有键值对
        properties.list(System.out);
        
        // 根据键获取值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名=" + user);
        System.out.println("密码是=" + pwd);
    }
}

应用案例2：写入配置文件

java

package com.hspedu.properties_;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**
 * @author 韩顺平
 * @version 1.0
 * 写入配置文件
 */
public class Properties03 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        
        // 设置键值对（存在则修改，不存在则创建）
        properties.setProperty("charset", "utf8");
        properties.setProperty("user", "汤姆"); // 中文会转为unicode
        properties.setProperty("pwd", "888888");
        
        // 存储到文件
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
        System.out.println("保存配置文件成功~");
    }
}

本章作业

Homework01.java

java

// 需求：
// 1) 判断e盘下是否有文件夹mytemp，没有则创建
// 2) 在e:\mytemp目录下创建文件hello.txt
// 3) 若文件已存在，提示无需重复创建
// 4) 向hello.txt写入"hello,world~"
package com.hspedu.homework;

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

public class Homework01 {
    public static void main(String[] args) {
        String dirPath = "e:\\mytemp";
        File dir = new File(dirPath);
        // 创建目录
        if (!dir.exists()) {
            if (dir.mkdirs()) {
                System.out.println("目录mytemp创建成功");
            } else {
                System.out.println("目录mytemp创建失败");
                return;
            }
        }
        
        String filePath = dirPath + "\\hello.txt";
        File file = new File(filePath);
        // 创建文件并写入内容
        try {
            if (file.exists()) {
                System.out.println("文件hello.txt已存在");
            } else {
                if (file.createNewFile()) {
                    System.out.println("文件hello.txt创建成功");
                    // 写入内容
                    FileWriter fw = new FileWriter(file);
                    fw.write("hello,world~");
                    fw.close();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Homework02.java

java

// 需求：使用BufferedReader读取文本文件，为每行加上行号并输出到屏幕
// 解决中文乱码：使用转换流指定编码
package com.hspedu.homework;

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

public class Homework02 {
    public static void main(String[] args) throws IOException {
        String filePath = "e:\\a.txt";
        // 字节流转字符流，指定编码gbk
        BufferedReader br = new BufferedReader(
                new InputStreamReader(new FileInputStream(filePath), "gbk")
        );
        
        String line;
        int lineNum = 0;
        while ((line = br.readLine()) != null) {
            lineNum++;
            System.out.println(lineNum + ": " + line);
        }
        br.close();
    }
}

Homework03.java

java

// 需求：
// 1) 编写dog.properties：name=tom, age=5, color=red
// 2) 创建Dog类，读取配置文件初始化属性并输出
// 3) 将Dog对象序列化到dog.dat文件
package com.hspedu.homework;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Properties;
import java.io.IOException;

public class Homework03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\dog.properties"));
        
        // 初始化Dog对象
        String name = properties.getProperty("name");
        int age = Integer.parseInt(properties.getProperty("age"));
        String color = properties.getProperty("color");
        Dog dog = new Dog(name, age, color);
        System.out.println(dog);
        
        // 序列化Dog对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:\\dog.dat"));
        oos.writeObject(dog);
        oos.close();
        System.out.println("序列化成功");
    }
}

class Dog implements Serializable {
    private String name;
    private int age;
    private String color;
    
    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
    
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

S01-19 JavaSE-File类和IO流 ​

文件 ​

什么是文件 ​

文件流 ​

常用的文件操作 ​

创建文件对象的三种方式 ​

获取文件相关信息 ​

目录操作和文件删除 ​

IO 流原理及分类 ​

IO 流原理 ​

流的分类 ​

抽象基类对比 ​

常用 IO 流类 ​

FileInputStream 应用（读文件） ​

FileOutputStream 应用（写文件） ​

文件拷贝（字节流应用） ​

FileReader 和 FileWriter ​

FileReader 和 FileWriter 介绍 ​

FileReader 相关方法 ​

FileWriter 常用方法 ​

FileReader 和 FileWriter 应用案例 ​

案例1：使用FileReader读取文件 ​

案例2：使用FileWriter写入文件 ​

节点流和处理流 ​

基本介绍 ​

节点流和处理流一览图 ​

节点流和处理流的区别和联系 ​

处理流的功能 ​

处理流-BufferedReader 和 BufferedWriter ​

特点 ​

应用案例1：使用BufferedReader读取文本文件 ​

应用案例2：使用BufferedWriter写入文件 ​

应用案例3：使用BufferedReader和BufferedWriter拷贝文本文件 ​

处理流-BufferedInputStream 和 BufferedOutputStream ​

介绍 ​

应用案例：拷贝二进制文件（图片/音乐/视频等） ​

对象流-ObjectInputStream 和 ObjectOutputStream ​

核心概念 ​

应用案例1：序列化数据（基本类型+对象） ​

应用案例2：反序列化数据 ​

注意事项和细节 ​

标准输入输出流 ​

应用案例 ​

转换流-InputStreamReader 和 OutputStreamWriter ​

核心功能 ​

应用案例1：InputStreamReader 解决中文乱码 ​

应用案例2：OutputStreamWriter 指定编码写入 ​

打印流-PrintStream 和 PrintWriter ​

特点 ​

应用案例1：PrintStream ​

应用案例2：PrintWriter ​

Properties 类 ​

核心功能 ​

常见方法 ​

应用案例1：读取配置文件 ​

应用案例2：写入配置文件 ​

本章作业 ​

Homework01.java ​

Homework02.java ​

Homework03.java ​

S01-19 JavaSE-File类和IO流

文件

什么是文件

文件流

常用的文件操作

创建文件对象的三种方式

获取文件相关信息

目录操作和文件删除

IO 流原理及分类

IO 流原理

流的分类

抽象基类对比

常用 IO 流类

FileInputStream 应用（读文件）

FileOutputStream 应用（写文件）

文件拷贝（字节流应用）

FileReader 和 FileWriter

FileReader 和 FileWriter 介绍

FileReader 相关方法

FileWriter 常用方法

FileReader 和 FileWriter 应用案例

案例1：使用FileReader读取文件

案例2：使用FileWriter写入文件

节点流和处理流

基本介绍

节点流和处理流一览图

节点流和处理流的区别和联系

处理流的功能

处理流-BufferedReader 和 BufferedWriter

特点

应用案例1：使用BufferedReader读取文本文件

应用案例2：使用BufferedWriter写入文件

应用案例3：使用BufferedReader和BufferedWriter拷贝文本文件

处理流-BufferedInputStream 和 BufferedOutputStream

介绍

应用案例：拷贝二进制文件（图片/音乐/视频等）

对象流-ObjectInputStream 和 ObjectOutputStream

核心概念

应用案例1：序列化数据（基本类型+对象）

应用案例2：反序列化数据

注意事项和细节

标准输入输出流

应用案例

转换流-InputStreamReader 和 OutputStreamWriter

核心功能

应用案例1：InputStreamReader 解决中文乱码

应用案例2：OutputStreamWriter 指定编码写入

打印流-PrintStream 和 PrintWriter

特点

应用案例1：PrintStream

应用案例2：PrintWriter

Properties 类

核心功能

常见方法

应用案例1：读取配置文件

应用案例2：写入配置文件

本章作业

Homework01.java

Homework02.java

Homework03.java