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)

Java 进阶：Java File & IO—2

目录

一、转换流

1. OutputStreamWriter 类

（1） 概述

（2） 构造方法

2. InputStreamReader 类

（1） 概述

（2） 构造方法

二、字节缓冲流

1. 概述

2. 字节输出缓冲流 BufferedOutputStream

3. 字节输入缓冲流 BufferedInputStream

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

三、字符缓冲流

1. 字符输出缓冲流 BufferedWriter

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

3.字符输入流缓冲流 BufferedReader

（1）概述

（2）BufferedReader 自己的功能

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

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

1. 概述

2. 实现

3. 细节

（1）transient 瞬态关键字

（2）静态不能序列化

（3）Serializable 接口

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

五、打印流

1. 概述

2. 打印流根据流的分类

3. 方法

4. 特点

5. 构造方法

6. 打印字符数组

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

六、标准输入、输出流

1. 概述

2. 继承关系

3. 案例

七、IO流总结

猜你喜欢

（1）概述

（2）构造方法

（1）概述

（2）构造方法