javaIO(2)--处理流

最新推荐文章于 2024-10-29 16:28:27 发布

zxy7857

最新推荐文章于 2024-10-29 16:28:27 发布

阅读量238

点赞数

文章标签： java jvm servlet

本文链接：https://blog.csdn.net/zxyccm/article/details/127156359

版权

节点流和处理流

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

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

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

处理流

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("保存配置文件成功~");
    }
}