IO流3 – pidanxia’ s Blog

节点流和处理流：

节点流：可以从一个特定的数据源读写数据，如FileReader、FileWriter
处理流(也叫包装流)是”链接”在已存在的流(节点流或处理流)之上，为程序提供更为强大的读写功能，也更加灵活，如BufferedReader、BufferWrier

区别和联系：

节点流是底层流/低级流，直接跟数据源相接
处理流包装节点流，既可以消除不同节点流的现实差异，也可以提供更方便的方法来完成输入输出
处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接于数据源相连

处理流的功能主要体现在以下两个方面：

性能的提高：主要以增加缓冲的方式来提高输入输出的效率
操作的边界：处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据，使用更加灵活方便

处理流：BufferedReader 和 BufferrdWriter

BufferedReader 和 BufferrdWriter属于字符流，使按照字符来读取数据的，关闭处理流时，只需要关闭外层流即可

BufferedReader类：

BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类

例1：BufferedReader

    public static void main(String[] args) {

        String filePath = "e:\\a.java";
        //创建BufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));   
        //读取
        String line;    //按行读取
        /*
            1、bufferedReader.leadLine() 是按行读取文件
            2、当返回null时，表示文件读取完毕
        */

        while ((line = bufferedReader.leadLine()) != null) {
            System.out.print(line);
        }

        //关闭流，注意：只需要关闭BufferedReader，因为底层回自动关闭节点流
        bufferReader.close();

    }

例2：BufferedWriter

    public static void main(String[] args) {
        String filePath = "e:\\ok.txt";
        //创建BufferedWriter
        BufferedWriter bufferedWriter = new BufferrdWriter(new FileWriter(filePath));
        //                                              (new FileWriter(filePath,true)),追加
        bufferrdWriter.writer("hello,bufferedWriter");
        bufferrdWriter.newLine();   //插入一个和系统相关的换行
        bufferrdWriter.writer("hello,bufferedWriter");
        bufferrdWriter.newLine();   //插入一个和系统相关的换行
        bufferrdWriter.writer("hello,bufferedWriter");
        //关闭外层流即可，传入的FileWriter(filePath)会自动关闭
        bufferedWriter.close();
    }

Buffered拷贝：

public static void main(String[] args) {

    //BufferedReader 和 BufferrdWriter是按照字符操作的，
    //不要操作 二进制文件(声音，视频，doc，pdf)，可能会造成文件损坏

    String srcFilePath = "e:\\a.java";
    String destFilePath = "e:\\a2.java";

    BufferedReader br = null;
    bufferrdWriter bw = null;

    String line;

    //try-catch
    br = new BufferedReader(new FileReader(srcFilePath));
    bw = new BufferrdWriter(new FileWriter(destFilePath));

    while ((line = br.readLine()) != null) {
        //每读取一行，就写入
        bw.writer(line);
        //插入换行符
        bw.newLine();
    }
    System.out.print("拷贝完成~");

    //try-catch
    finally{

        //try-catch
        //关闭流
        if (br != nill) {
            br.close()；
        }

        if (bw != nill) {
            bw.close()；
        }
        //try-catch

    }
}

BufferedInputStream 和 BufferedOutputStream:

BufferedInputStream 是字节流，在创建BufferedInputStream时，会创建一个内部缓冲区数组
BufferedOutputStream 是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统

字节处理流拷贝文件：

public static void main(String[] args) {
    String srcFilePath = "e:\\Kaola.jpg";
    String destFilePath = "e:\\hsp.avi";

    //创建BufferedInputStream对象 和 BufferedOutputStream对象
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;

    //try-catch
    bis = new BufferedInputStream(new FileInputStream(srcFilePath));
    bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

    //循环读取文件，并写入到destFilePath
    byte[] buff = new byte[1024];
    int readLen = 0;

    //当返回-1时，表示文件读取完毕
    while ((readLen = bis.read(buff)) != -1) {
        bos.writer(buff, 0, readLen);
    }
    //try-catch
    finally{

        //try-catch
        //关闭外层处理流即可，底层会关闭节点流
        if (bis != null) {
            bis.close();
        }
        if (bos != null) {
            bos.close();
        }
        //try-catch

    }
}

对象处理流：

对象流：ObjectInputStream 和 ObjectOutputStream

需求：

将int num = 100 这个int数据保存到文件中，注意不是100数字，而是 int 100，并且，能够从文件中直接恢复int 100
将 Dog dog = new Dog(“大狗”,3) 这个dog对象保存到文件中，并且能够从文件恢复
上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作

序列化和反序列化：

序列化就是在保存数据时，保存数据的值和数据类型
反序列化就是在恢复数据时，恢复数据的值和数据类型
需要让某个对象支持序列化机制，则必须让其他类是可序列化的，为了让某个类是可序列化的，

该类必须实现如下两个接口之一：
- SerializableSerializable //这是一个标记接口,没有方法，一般都用这个
- Externalizable //该接口有方法需要实现

基本介绍：

功能：提供了对基本类型或对象类型的序列化和反序列化的方法
ObjectOutputStream 提供序列化功能
ObjectInputStream 提供反序列化功能

例：

使用ObjectOutputStream序列化基本数据类型和一个Dog对象(name,age)，并保存到data.dat文件中

    public static void main(String[] args) {
        //序列化后，保存的文件格式不是纯文本，而是按照他的格式来保存
        String filePath = "e:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 e:\\data.dat
        oos.writeInt(100);  //int->Integer(实现了 Serializable)
        oos.writeBoolean(true); //boolean -> Boolean(实现了Serializable)
        oos.writeChar("a"); //char->Character (实现了 Serializable)
        oos.writeDouble(9.5);   //doubel->Double(实现了 Serializable)
        oos.writeUTF("UTF UTF");//String

        //保存一个dog对象
        oos.writeObject(new Dog("旺财",10));

        oos.close();
        System.out.print("数据保存完毕(序列化形式)");

    }

    //如果需要序列化某个类的对象，必须实现Serializable接口
    class Dog implements Serializable{
        private String name;
        private int age;
        /*
            构造器、get、set、重写toString
        */
    }

例2：

使用ObjectInputStream读取data.dat并反序列化恢复数据

    public static void main(String[] args) {
        //指定序列化的文件
        String filePath = "e:\\data.dat";

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));

        //读取
        /*
            1、读取(但序列化)的顺序需要和保存数据(序列化)的顺序一致
            2、否则会出现异常
        */
        System.out.print(ois.readInt());
        System.out.print(ois.readBoolean());
        System.out.print(ois.readChar());
        System.out.print(ois.readDouble());
        System.out.print(ois.readUTF());

        //dog的编译类型是Object，运行类型是Dog
        Object dog = ois.readObject();
        System.out.print("运行类型 = " + dog.getClass());
        System.out.print("dog信息 = " + dog); //底层 Object->Dog

        //如果我们希望调用Dog方法，需要向下转型
        //需要我们将Dog类的定义，拷贝到可以引用的位置
        //把dog类单独出来，然后导包
        Dog dog2 = (Dog)dog;
        System.out.print(dog2.getName());

        //关闭外层流即可，底层会关闭FileInputStream流
        ois.close();

    }

注意事项和细节说明：

读写顺序要一致
要求实现序列化或反序列化对象，需要实现Serializable
序列化的类中建议添加SerialVersionUID，为了提高版本的兼容性
序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
序列化对象时，要求里面属性的类型也需要实现序列化接口
序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

如：

        public class Dog implements Serializable{
            private String name;
            private int age;
            //SerialVersionUID 序列化的版本号，可以提高兼容性
            private static final long serialVersionUID = 1L;
        }

标准输入输出流：

		类型	默认设备
System.in	标准输入	InputStream	键盘
System.out	标准输出	PrintStream	显示器

System.in：

System类的 public final static InputStream in = null;

System.in 的编译类型：InputStream

System.in 的运行类型：BufferedInputStream

System.out：

System.out public final static PrintStream out = null;

System.out 编译类型：PrintStream

System.out 运行类型：PrintStream

转换流:

InputStreamReader 和 OutputStreamWriter

public static void main(String[] args) {
    //读取 e:\\a.txt 文件到程序
    /*
        1、创建字符输入流 BufferedReader(处理流)
        2、使用BufferedReader 对象读取 a.txt
        3、默认情况下，读取文件是按照UTF-8编码
    */

    String filePath = "e:\\a.txt";
    BufferedReader br = new BufferedReader(new FileReader(filePath));

    String s = br.readLine();
    System.out.print("读取到的内容：" + s);    //如果不是按照UTF-8编码，可能会出现乱码
    br.close();
}

InputStreamReader:

InputStreamReader:Reader的子类，可以将InputStream(字节流)包装称Reader(字符流)
OutputStreamWriter:Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流)
当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流
可以在使用时指定编码格式(比如 utf-8,gbk,gb2312,ISO8859-1等)

案例1：

编程将字节流FileInputStream 包装成(转换成)字符流InputStreamReader,对文件进行读取(按照 utf-8/gbk格式)，进而再包装成BufferedReader

    public static void main(String[] args) {
        String filePath = "e:\\a.txt";
        //1、把FileInputStream 转成InputStreamReader
        //2、指定编码gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk")
        //3、把InputStreamReader传入BufferedReader
        BufferedReader br = new BufferedReader(isr);
        //将2 和 3 合在一起
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
        //4、读取
        String s = br.readLine();
        System.out.print("读取内容 = " + s);
        //5、关闭外层流
        br.close();
    }

案例2：

编程将字节流FileOutputStream 包装成(转换成)字符流OutputStreamWriter,对文件进行写入(按照gbk格式，可以指定成其他，比如utf-8)

    public static void main(String[] args) {
        String filePath = "e:\\hsp.txt";
        String charSet = "gbk";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath),charSet);
        osw.write("hi~~~");
        osw.close();
        System.out.print("按照 " + charSet + "保存文件成功~");
    }

打印流：

只有输出流，没有输入流

PrintStream 和 PrintWriter

PrintStream：

public static void main(String[] args) {
    PrintStream out = System.out;
    //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
    /*
            public void print(String s){
                if(s == null){
                    s = "null"
                }
                write(s)
            }
    */
    out.print("john,hello");
    //因为print底层使用的是writer，所以我们可以直接调用writer进行打印/输出
    out.write("hello~~".getBytes());

    out.close();

    //修改打印流输出的位置/设备
    //1、修改到 e:\\f1.txt
    //2、就会输出到 e:\\f1.txt
    System.setOut(new PrintStream("e:\\f1.txt"));
    System.out.print("hello~~~~~~~");
}

PrintWriter：

public static void main(String[] args) {
    // PrintWriter printWriter = new PrintWriter(System.out);
    PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
    printWriter.print("hi~北京~");
    printWriter.close();
}

Properties类：

专门用于读写配置文件的集合类

配置文件的格式：

键=值

注意：键值对不需要有空格，值不需要用引号引起来。默认类型是String
Properties的常见方法：

load：加载配置文件的键值对到Properties对象

list：将数据显示到指定设备

getProperty(key)：根据获取值

setProperty(key,value)：设置键值对到Properties对象

store：将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

public static void main(String[] args) {
    //使用Properties类来读取mysql.properties文件
    //1、创建Properties对象
    Properties properties = new Properties();
    //2、加载指定配置文件
    properties.load(new FileReader("src\\mysql.properties"));
    //3、把K-V显示到控制台
    properties.list(System.out);
    //4、根据key获取对应的值
    String user = properties.getProperty("user");
    String pwd = properties.getProperty("pwd");
    System.out.print("用户名=" + user);
    System.out.print("密码是=" + pwd);
}

案例：

使用Properties类完成对mysql.properties的读取
使用Properties类添加key-val到新文件 mysql2.properties中
使用Properties类完成对mtsql.properties的读取，并修改某个key-val
public static void main(String[] args) {
//使用Properties类来创建配置文件，修改配置文件内容
Properties properties = new Properties();
//创建
//1、如果该文件没有key，就是创建
//2、如果该文件有key，就是修改
properties.setProperty(“charset”,”utf-8″);
properties.setProperty(“user”,”汤姆”); //注意保存时，是中文的 unicode码
properties.setProperty(“pwd”,”abc111″);
```
//将k-v存储文件中即可
properties.store(new FileOutputStream("src\\mysql2.properties"),null);  //null表示没有注释，也可以"XXX"写注释
System.out.print("保存配置文件成功~~");
```
}

皮蛋侠

一个有梦想的程序员~~

节点流和处理流：

区别和联系：

处理流的功能主要体现在以下两个方面：

处理流：BufferedReader 和 BufferrdWriter

BufferedReader类：

例1：BufferedReader

例2：BufferedWriter

Buffered拷贝：

BufferedInputStream 和 BufferedOutputStream:

字节处理流拷贝文件：

对象处理流：

序列化和反序列化：

基本介绍：

例：

例2：

注意事项和细节说明：

如：

标准输入输出流：

System.in：

System.out：

转换流:

InputStreamReader:

案例1：

案例2：

打印流：

PrintStream：

PrintWriter：

Properties类：

案例：

发送评论编辑评论

节点流和处理流：

区别和联系：

处理流的功能主要体现在以下两个方面：

处理流：BufferedReader 和 BufferrdWriter

BufferedReader类：

例1：BufferedReader

例2：BufferedWriter

Buffered拷贝：

BufferedInputStream 和 BufferedOutputStream:

字节处理流拷贝文件：

对象处理流：

序列化和反序列化：

基本介绍：

例：

例2：

注意事项和细节说明：

如：

标准输入输出流：

System.in：

System.out：

转换流:

InputStreamReader:

案例1：

案例2：

打印流：

PrintStream：

PrintWriter：

Properties类：

案例：

发送评论 编辑评论

推荐文章

发送评论编辑评论