javaIO(2)--处理流

节点流和处理流

  • 基本介绍

    1. 节点流可以从一个特定的数据源读写数据,如FileReader、FileWriter (底层)
    2. 处理流(包装流)是“连接”在已存在的流(节点流或处理流)之上,为程序提供更为强大的读写功能,如BufferedReader、BufferedWriter (更灵活)
  • 区别和联系

  1. 节点流是底层流/低级流,直接跟数据源相接
  2. 处理流(包装流)包装节点流,既可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出
  3. 处理流对节点流进行包装,使用了修饰器设计模式,不会直接与数据源相连
  • 处理流的功能主要体现在以下两个方面:
    • 性能的提高:主要以增加缓冲的方式来提高输入输出的效率
    • 操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使用更加灵活方便

处理流

BufferedReader、BufferedWriter:

  • 属于字符流,是按照字符来读取数据的
  • 关闭时,只需要关闭外层流即可
  • BufferedReader
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReader_ {

    public static void main(String[] args) throws IOException {

        String filePath = "E:\\Java\\javaIO\\a.txt";
        //创建对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取,效率高
        //bufferedReader.readLine()是按行读取文件
        //当返回null时,表示文件读取完毕
        while(( line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }

        //关闭流 只需要关闭BufferedReader 因为底层会自动关闭节点流
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

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

public class BufferedWriter_ {

    public static void main(String[] args) throws IOException {
        String filePath = "E:\\Java\\javaIO\\a.txt";
        
        //创建对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
        bufferedWriter.write("hello");
        bufferedWriter.write("hello");
        //插入一个与系统相关的换行
        bufferedWriter.newLine();
        bufferedWriter.write("hello");

        //关闭外层流即可,传入的new FileWriter(filePath)会在底层关闭
        bufferedWriter.close();
    }
}

  • 文件拷贝
import java.io.*;

public class BufferedCopy {

    public static void main(String[] args) {

        String srcFilePath = "E:\\Java\\javaIO\\a.txt";
        String destFilePath = "E:\\Java\\javaIO\\b.txt";
        BufferedReader br = null;
        BufferedWriter bw = null;
        String line;

        try{
            br = new BufferedReader(new FileReader(srcFilePath));
            bw = new BufferedWriter(new FileWriter(destFilePath));

            //说明:readLine方法读取一行内容,但是没有换行
            while (( line = br.readLine()) != null) {

                //每读取一行,就写入
                bw.write(line);
                //插入一个换行符
                bw.newLine();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流

            if(br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

BufferedReader、BufferedWriter是按照字符操作
不要去操作二进制文件,可能会导致文件损坏

BufferedInputStream、BufferedOutputStream

  • BufferedInputStream是字节流,在创建BufferedInputStream时,会创建一个内部缓冲区数组
  • BufferedOutputStream是字节流,实现缓冲区的输出流,可以将多个字节写入底层输出流中,而不必对每次字节写入调用底层系统
  • 使用它们可以完成二进制文件拷贝
import java.io.*;

public class BufferedCopy2 {

    public static void main(String[] args) {

        String srcFilePath = "E:\\Java\\javaIO\\a.txt";
        String destFilePath = "E:\\Java\\javaIO\\b.txt";

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

            try {
                bis = new BufferedInputStream(new FileInputStream(srcFilePath));
                bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

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

                //当返回-1时,表示文件读取完毕
                while ((readLine = bis.read(buff)) != -1) {
                    bos.write(buff, 0, readLine);
                }
                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

  • 序列化和反序列化

    1. 序列化就是在保存数据时,保存数据的值和数据类型
    2. 反序列化就是在恢复数据时,恢复数据的值和数据类型
    3. 需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,则该类必须要实现如下两个接口之一:
      • Serializable//这是一个标记接口,没有方法
      • Externalizable
  • 功能:提供了对基本类型或对象类型的序列化和反序列化的方法

    • ObjectInputStream提供 序列化功能
    • ObjectOutputStream提供 反序列化功能
  • 序列化存储数据

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

public class ObjectOutStream {

    public static void main(String[] args) throws IOException {

        //序列化后,保存的文件格式不是纯文本,而是按照它的格式来保存
        String srcFilePath = "E:\\Java\\javaIO\\a.txt";
        //创建对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(srcFilePath));
        //序列化数据到目录下
        oos.writeInt(100);//int-->Integer 实现了Serializable
        oos.writeBoolean(true);//boolean-->Boolean 实现了Serializable
        oos.writeChar('a');//char-->Character 实现了Serializable
        oos.writeDouble(9.5);//double-->Double 实现了Serializable
        oos.writeUTF("啦啦啦");//String

        //保存一个dog对象
        oos.writeObject(new dog("旺财",10));
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
}

//如果需要序列化某个类的对象,必须实现了Serializable接口
class dog implements Serializable {
    private String name;
    private int age;

    public dog(String name, int age){
        this.name = name;
        this.age = age;
    }
}
  • 反序列化恢复数据
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInput {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //指定反序列化的文件
        String filePath = "E:\\Java\\javaIO\\a.txt";
        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());

        Object o = ois.readObject();
        System.out.println("运行类型=" + o.getClass());
        System.out.println("dog信息=" + o);//底层 Object-->dog

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

    }

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

标准输入输出流

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

    public static void main(String[] args) {

        //System类 public static InputStream in = null;
        //System.in的编译类型 InputStream
        //System.in 运行类型 BufferedInputStream
        System.out.println(System.in.getClass());

        //System类 public static final PrintStream out = null;
        //编译类型 PrintStream
        //运行类型 PrintStream
        //表示标准输出 显示器
        System.out.println(System.out.getClass());

    }
}

转换流 InputStreamReader、OutputStreamWriter

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

public class InputReader {
    /**
     * 使用转换流解决中文乱码问题
     * 将字节流FileInputStream转成InputStreamReader字符流
     * @param args
     */
    public static void main(String[] args) throws IOException {

        String filePath = "E:\\Java\\javaIO\\a.txt";
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        System.out.println("读取内容=" + s);

        //关闭外层流
        br.close();
    }
}

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

public class OutputWriter {
    /**
     * 演示OutputStreamWriter使用
     * 把FileOutputStream字节流转成字符流OutputStreamWriter
     * 指定处理的编码
     * @param args
     */
    public static void main(String[] args) throws IOException {

        String filePath = "E:\\Java\\javaIO\\b.txt";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath),"gbk");
        osw.write("hello");
        osw.close();
        System.out.println("按照gbk保存文件");

    }
}

打印流 PrintStream、PrintWriter

  • 打印流只有输出流,没有输入流
import java.io.IOException;
import java.io.PrintStream;

public class Print {

    public static void main(String[] args) throws IOException {

        PrintStream out = System.out;
        //默认情况下,PrintStream输出数据的位置是标准输出即显示器
        out.println("hello");
        //因为println底层使用的是write,所以我们也可以直接调用write方法进行输入/输出
        out.write("hello".getBytes());
        out.close();

    }
}

PrintWriter pw = new PrintWriter(System.out);
pw.print("hello");
pw.close();

Properties类

  • 专门用于读写配置文件的集合类
    • 配置文件格式:
      • 键=值
    • 注意:键值对不需要有空格,值不需要用引号引起来默认类型是String
  • 常见方法:
    • load:加载配置文件的键值对到Properties对象
    • list:将数据显示到指定设备
    • getProperty(key):根据键获取值
    • setProperty(key,value):设置键值对到Properties对象
    • store:将Properties中的键值对存储到配置文件,在idea中,保存信息到配置文件,如果含有中文,会存储为unicode码
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class Properties01 {

    public static void main(String[] args) throws IOException {

        //创建对象
        Properties properties = new Properties();
        //加载指定配置文件
        properties.load(new FileReader("E:\\Java\\javaIO\\a.txt"));
        //把键值对显示到控制台
        properties.list(System.out);
        //根据key获取对应的值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");

        System.out.println("用户名= " + user);
        System.out.println("密码= " + pwd);

    }
}

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

public class Properties02 {

    public static void main(String[] args) throws IOException {

        Properties properties = new Properties();
        //创建文件
        //如果该文件没有key,就是创建
        //如果该文件有key,就是修改
        properties.setProperty("charset","utf8");
        properties.setProperty("user","tom");
        properties.setProperty("pwd","abc123");

        //将键值对存储到文件里
        properties.store(new FileOutputStream("E:\\Java\\javaIO\\a.txt"),null);
        System.out.println("保存配置文件成功~");
    }
}

你可能感兴趣的:(java,jvm,servlet)