Java 进阶：Java File & IO—2

关注

原创最新推荐文章于 2026-07-18 08:48:43 发布 946 阅读 AI 写同款· GEO 优化 ›

Ubuntu 12.04下Postfix部署与生产级配置实战邮件传输代理（MTA）是Linux系统基础通信设施的核心组件，其原理涉及网络协议栈、进程权限隔离、日志审计与服务依赖管理。Postfix以配置简洁、行为可预测、日志语义清晰著称，成为理解传统系统服务调度机制的理想入口。在老旧但不可替代的生产环境中——如工业网关、SCADA前置机或金融终端——MTA的稳定运行直接关系到告警通知、日志归档与运维可观测性。本文聚焦Postfix在已终止支持的Ubuntu 12.04平台上的完整落地路径，涵盖归档源切换、GPG密钥修复、ABI兼容性规避、七步核心参数调优及telne 阅读详情

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        writeUTF();
    }

   //转换流对象OutputStreamWriter写文本，采用UTF-8编码表写入
    public static void writeUTF()throws IOException{
        //创建字节输出流，绑定文件
        FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
        //创建转换流对象，构造方法保证字节输出流，并指定编码表是UTF-8
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8"); //GBK可以不写
        osw.write("你好");
        osw.close(); //使用close()连刷新带关闭
    }
}

2. InputStreamReader 类

（1）概述

java.io.InputStreamReader继承 Reader；是 字符输入流，读取文本文件
字节流向字符的桥梁，将 字节流 转为 字符流
读取的方法：read() 读取1个字符，读取字符数组

（2）构造方法

InputStreamReader(InputStream in)：接收所有的 字节输入流

可以传递的字节输入流： FileInputStream

InputStreamReader(InputStream in,String charsetName): 传递编码表的名字

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        readUTF();
    }

    //转换流,InputSteamReader读取文本，采用UTF-8编码表,读取文件utf
    public static void readUTF()throws IOException{
        //创建字节输入流,传递文本文件
        FileInputStream fis = new FileInputStream("c:\\utf.txt");
        //创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        char[] ch = new char[1024];
        int len = isr.read(ch);
        System.out.println(new String(ch,0,len));
        isr.close();
    }
}

###3. 转换流子类父类的区别

继承关系
OutputStreamWriter 的子类: FileWriter
InputStreamReader 的子类：FileReader
区别
OutputStreamWriter 和 InputStreamReader 是字符和字节的桥梁：也可以称之为字符转换流。字符转换流原理：字节流 + 编码表
FileWriter 和 FileReader：作为子类，仅作为操作字符文件的便捷类存在。当操作的字符文件，使用的是默认编码表时可以不用父类，而直接用子类就完成操作了，简化了代码。
以下三句话功能相同

InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”));//默认字符集。
InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),“GBK”);//指定GBK字符集。
FileReader fr = new FileReader(“a.txt”);

注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流。什么时候用子类呢？
条件：1、操作的是文件。2、使用默认编码。

二、字节缓冲流

1. 概述

可提高IO流的读写速度
分为字节缓冲流与字符缓冲流

2. 字节输出缓冲流 BufferedOutputStream

java.io.BufferedOuputStream作用: 提高原有输出流的写入效率
BufferedOuputStream 继承 OutputStream
方法：写入 write 字节,字节数组
构造方法：BufferedOuputStream(OuputStream out)：可以传递任意的字节输出流，传递的是哪个字节流，就对哪个字节流提高效率

public class BufferedOutputStreamDemo {
    public static void main(String[] args)throws IOException {
        //创建字节输出流,绑定文件
        //FileOutputStream fos = new FileOutputStream("c:\\buffer.txt");

        //创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
        BufferedOutputStream bos = new
                BufferedOutputStream(new FileOutputStream("c:\\buffer.txt"));

        bos.write(55);
        byte[] bytes = "HelloWorld".getBytes();
        bos.write(bytes);
        bos.write(bytes, 3, 2);

        bos.close();
    }
}

3. 字节输入缓冲流 BufferedInputStream

BufferedInputStream，继承 InputStream ,标准的字节输入流
读取方法： read() ，单个字节，字节数组
构造方法: BufferedInputStream(InputStream in)：可以传递任意的字节输入流，传递是谁，就提高谁的效率
可以传递的字节输入流 FileInputStream

public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException{
        //创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
        BufferedInputStream bis = new
                BufferedInputStream(new FileInputStream("c:\\buffer.txt"));
        byte[] bytes = new byte[1024];
        int len = 0 ;
        while((len = bis.read(bytes))!=-1){
            System.out.print(new String(bytes,0,len));
        }
        bis.close();
    }
}

4. 四种文件复制方式的效率比较

结论：
字节流读写单个字节：125250 毫秒
字节流读写字节数组：193 毫秒
字节流缓冲区流读写单个字节：1210 毫秒
字节流缓冲区流读写字节数组：73 毫秒
代码

public class Copy {
    public static void main(String[] args)throws IOException {
        long s = System.currentTimeMillis();
        copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
    /*
     * 方法,实现文件复制
     *  4. 字节流缓冲区流读写字节数组
     */
    public static void copy_4(File src,File desc)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
        int len = 0 ;
        byte[] bytes = new byte[1024];
        while((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
    /*
     * 方法,实现文件复制
     *  3. 字节流缓冲区流读写单个字节
     */
    public static void copy_3(File src,File desc)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
        int len = 0 ;
        while((len = bis.read())!=-1){
            bos.write(len);
        }
        bos.close();
        bis.close();
    }

    /*
     * 方法,实现文件复制
     *  2. 字节流读写字节数组
     */
    public static void copy_2(File src,File desc)throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(desc);
        int len = 0 ;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fos.close();
        fis.close();
    }

    /*
     * 方法,实现文件复制
     *  1. 字节流读写单个字节
     */
    public static void copy_1(File src,File desc)throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(desc);
        int len = 0 ;
        while((len = fis.read())!=-1){
            fos.write(len);
        }
        fos.close();
        fis.close();
    }
}

三、字符缓冲流

1. 字符输出缓冲流 BufferedWriter

java.io.BufferedWriter继承 Writer
写入方法： write () ，单个字符,字符数组,字符串
构造方法：BufferedWriter(Writer w)：传递任意字符输出流，传递谁，就高效谁
能传递的字符输出流： FileWriter, OutputStreamWriter

public class BufferedWrierDemo {
    public static void main(String[] args) throws IOException{
        //创建字符输出流,封装文件
        FileWriter fw = new FileWriter("c:\\buffer.txt");
        BufferedWriter bfw = new BufferedWriter(fw);

        bfw.write(100);
        bfw.flush();
        bfw.write("你好".toCharArray());
        bfw.flush();

        bfw.write("你好");
        bfw.flush();

        bfw.write("我好好");
        bfw.flush();

        bfw.write("大家都好");
        bfw.flush();

        bfw.close();
    }
}

2. 字符输出缓冲流 BufferedWriter—特有方法 newLine

void newLine()：写换行
newLine()：文本中换行, \r\n也是文本换行
方法具有平台无关性

windows \r\n ； Linux \n

newLine()运行结果和操作系统是相互关联的
JVM: 安装的是 Windows 版本，newLine()写的就是 \r\n；安装的是 Linux 版本，newLine() 写的就是**\n**

3.字符输入流缓冲流 BufferedReader

（1）概述

java.io.BufferedReader继承 Reader，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
读取功能： read()，单个字符,字符数组
构造方法：BufferedReader(Reader r)：可以任意的字符输入流，有：FileReaderInputStreamReader

（2）BufferedReader 自己的功能

String readLine(): 读取文本行 \r\n ，读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

获取内容的方法一般都有返回值
int：没有返回的都是负数
引用类型：找不到返回 null
boolean：找不到返回 false

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        int lineNumber = 0;
        //创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
        BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
        //调用缓冲流的方法 readLine()读取文本行
        //循环读取文本行, 结束条件 readLine()返回null
        String line = null;
        while((line = bfr.readLine())!=null){
            lineNumber++;
            System.out.println(lineNumber+"  "+line);
        }
        bfr.close();
    }
}

4. 字符流缓冲区流复制文本文件

/*
 *  使用缓冲区流对象,复制文本文件
 *  数据源  BufferedReader+FileReader 读取
 *  数据目的 BufferedWriter+FileWriter 写入
 *  读取文本行, 读一行,写一行,写换行
 */
public class Copy_1 {
    public static void main(String[] args) throws IOException{
        BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));   
        BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
        //读取文本行, 读一行,写一行,写换行
        String line = null;
        while((line = bfr.readLine())!=null){
            bfw.write(line);
            bfw.newLine();
            bfw.flush();
        }
        bfw.close();
        bfr.close();
    }
}

四、序列化流与反序列化流

1. 概述

对象的序列化：对象中的数据，以流的形式，写入到文件中保存过程称为写出对象，ObjectOutputStream将对象写道文件中，实现序列化
对象的反序列化：在文件中，以流的形式，将对象读出来，读取对象，ObjectInputStream将文件对象读取出来

2. 实现

ObjectOutputStream：写对象,实现序列化
- 构造方法:ObjectOutputStream(OutputSteam out)：传递任意的字节输出流
- void writeObject(Object obj)：写出对象
ObjectInputStream：读取对象,实现反序列化
- 构造方法：ObjectInputStream(InputStream in)：传递任意的 字节输入流,输入流封装文件,必须是序列化的文件
Object readObject()： 读取对象

//定义类
public class Person implements Serializable{
   //省略
    }               
}

 public class ObjectStreamDemo {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        writeObject();
        readObject();
    }

    //ObjectOutputStream
    public static void writeObject() throws IOException{
        //创建字节输出流,封装文件
        FileOutputStream fos = new FileOutputStream("c:\\person.txt");
        //创建写出对象的序列化流的对象,构造方法传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Person p = new Person("lisi",25);
        //调用序列化流的方法writeObject,写出对象
        oos.writeObject(p);
        oos.close();

    //ObjectInputStream
    public static void readObject() throws IOException, ClassNotFoundException{
        FileInputStream fis = new FileInputStream("c:\\person.txt");
        //创建反序列化流,构造方法中,传递字节输入流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //调用反序列化流的方法 readObject()读取对象
        Object obj =ois.readObject();
        System.out.println(obj);
        ois.close();
    }
}

3. 细节

（1）transient 瞬态关键字

作用：被 transient修饰的属性不会被序列化
transient关键字只能修饰成员变量

（2）静态不能序列化

原因：序列化是把对象数据进行持久化存储；静态的东西不属于对象，而属于类

（3）Serializable 接口

作用：给需要序列化的类上加标记。该标记中没有任何抽象方法；只有实现了 Serializable接口的类的对象才能被序列化

4. 序列化中的序列号冲突问题

问题产生：当一个类实现Serializable接口后，创建对象并将对象写入文件，之后更改了源代码 (比如：将成员变量的修饰符有private改成public)，再次从文件中读取对象时会报异常
原因：一旦修改了源码，重新编译产生class文件，会根据类的成员重新计算序列号，这样新编译的class文件中的序列号，与原来文件中的序列号就不同了
解决：需要做一个终身不变的序列号! 需要在序列化中自定义序列号

private static final long serialVersionUID = 1478652478456L;
// 这样每次编译类时生成的 serialVersionUID 值都是固定的
//类自定义了序列号,编译器就不会计算序列号

五、打印流

1. 概述

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.

2. 打印流根据流的分类

字节打印流 PrintStream
字符打印流 PrintWriter

3. 方法

void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作

4. 特点

此流不负责数据源，只负责数据目的
可以操作任意类型的数据。（boolean， int， long， float， double）
打印流,可以开启自动刷新功能
满足两个条件：
- 使用特定的构造方法，打开打印流的自动刷新，输出的数据目的必须是流对象：OutputStreamWriter
- 必须调用 println，printf，format三个方法中的一个,启用自动刷新
为其他输出流，添加功能
永远不会抛出 IOException，但是可能抛出别的异常

5. 构造方法

就是打印流的输出目的端
PrintStream构造方法
- 接收File类型,接收字符串文件名,接收字节输出流OutputStream
PrintWriter构造方法
- 接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer

6. 打印字符数组

println数组，只有打印字符数组时是打印内容，其余均打印数组的地址
因为api中定义了打印字符数组的方法，其底层是在遍历数组中的元素，而其他打印数组的方法，都是将数组对象编程Object，其底层再将对象编程String，调用了 String s = String.valueOf(x);方法

7. 利用打印流，完成文本文件的复制

/*
 * 打印流实现文本复制
 * 读取数据源  BufferedReader+File 读取文本行
 * 写入数据目的 PrintWriter+println 自动刷新
 */
public class PrintWriterDemo1 {
    public static void main(String[] args) throws IOException{
        BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
        PrintWriter pw = new PrintWriter(new FileWriter("d:\\a.txt"),true);
        String line = null;
        while((line = bfr.readLine())!=null){
            pw.println(line);
        }
        pw.close();
        bfr.close();
    }
}

六、标准输入、输出流

1. 概述

标准输入流： System.in默认指键盘输入
标准输出流： System.out向显示器输出

2. 继承关系

PrintStream extends FilterOutputStream
FilterOutputStream extends OutputStream

3. 案例

public class StandardIO {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s;
        // 标准输入流的read方法，读取键盘数据的时候，当当前没有键盘输入数据的时候
        // read会阻塞当前线程，使得不能结束，只有自定义协议，才能结束标准输入流
        while((s = br.readLine()) != null) {
            //自定协议，当用户输入886结束接收用户输入
            if("886".equals(s)) {
                break;
            }
            System.out.println("输出：" + s);
        }
        br.close();
    }
}

七、IO流总结

字节流
- 字节输入流 InputStream
  - FileInputStream 操作文件的字节输入流
  - BufferedInputStream高效的字节输入流
  - ObjectInputStream 反序列化流
- 字节输出流 OutputStram
  - FileOutputStream 操作文件的字节输出流
  - BufferedOutputStream 高效的字节输出流
  - ObjectOuputStream 序列化流
  - PrintStream 字节打印流
字符流
- 字符输入流 Reader
  - FileReader 操作文件的字符输入流
  - BufferedReader 高效的字符输入流
  - InputStreamReader 输入操作的转换流(把字节流封装成字符流)
- 字符输出流 Writer
  - FileWriter 操作文件的字符输出流
  - BufferedWriter 高效的字符输出流
  - OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)
  - PrintWriter 字符打印流
方法：
- 读数据方法：
  - read() 一次读一个字节或字符的方法
  - read(byte[] char[]) 一次读一个数组数据的方法
  - readLine() 一次读一行字符串的方法(BufferedReader类特有方法)
  - readObject() 从流中读取对象(ObjectInputStream特有方法)
- 写数据方法：
  - write(int) 一次写一个字节或字符到文件中
  - write(byte[] char[]) 一次写一个数组数据到文件中
  - write(String) 一次写一个字符串内容到文件中
  - writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)
  - newLine() 写一个换行符号(BufferedWriter类特有方法)
向文件中写入数据的过程
1，创建输出流对象
2，写数据到文件
3，关闭输出流
从文件中读数据的过程
1，创建输入流对象
2，从文件中读数据
3，关闭输入流
文件复制的过程
1，创建输入流（数据源）
2，创建输出流（目的地）
3，从输入流中读数据
4，通过输出流，把数据写入目的地
5，关闭流

File类

方法
获取文件名称 getName()
获取文件绝对路径 getAbsolutePath()
获取文件大小 length()
获取当前文件夹中所有File对象 File[] listFiles()
判断是否为文件 isFile()
判断是否为文件夹 isDirectory()
创建文件夹 mkdir() mkdirs()
创建文件 createNewFile()
异常
- try…catch…finally捕获处理异常
- throws 声明异常
- throw 抛出异常对象
异常的分类
- 编译期异常 Exception
- 运行期异常 RuntimeException
注意：
- 编译期异常，必须处理，不然无法编译通过
- 运行期异常，程序运行过程中，产生的异常信息
实现文件内容的自动追加
- 构造方法
  - FileOutputStream(File file, boolean append)
  - FileOutputStream(String fileName, boolean append)
  - FileWriter(File, boolean append)
  - FileWriter(String fileName, boolean append)
实现文件内容的自动刷新
- 构造方法
  - PrintStream(OutputStream out, boolean autoFlush)
  - PrintWriter(OutputStream out, boolean autoFlush)
  - PrintWriter(Writer out, boolean autoFlush)