io流复习

2023-10-27 22:39:16

前置知识：

序列化和反序列化

　　1.序列化就是在保存数据时，保存数据的值和数据类型
　　2.反序列化就是在恢复数据时，恢复数据的值和数据类型
　　3.需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该
　　类必须实现如下两个接口之一:
　　 Serializable //这是一个标记接口，没有方法
　　 Externalizable //该接口有方法需要实现，因此我们一般实现上面的Serializable接口

节点流和处理流

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

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

　　　常见的处理流BufferedReader和BufferedWriter

　　　在关闭处理流时，只关闭外层流即可

一、字节流

字节流通常用来处理二进制文件，视频，音频，图片　　

1、inputStream

　　1.1、FileInputStream

/**
 * FileInputStream使用（文件-->程序）
 */
public class FileInputStream_ {
    public static void main(String[] args) {
      //  readFile01();
        readFile02();
    }

    //单个字节的读取，效率比较低
   public static void readFile01(){
        String filePath="D://a.txt";
       int readData=0;
       FileInputStream fileInputStream=null;
       try {
           //创建FileInputStream对象，用于读取 文件
           fileInputStream = new FileInputStream(filePath);
           //一个字节一个字节的读，读取的数据存储在readData里，如果返回-1,则代表读取完毕
           while ((readData = fileInputStream.read())!=-1){
               System.out.print((char) readData);//转成char输出
           }
       } catch (IOException e) {
           e.printStackTrace();
       }finally {
           //关闭文件流释放资源
           try {
               fileInputStream.close();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }

    public static void readFile02(){
        String filePath="D://a.txt";
        int readLen=0;
        FileInputStream fileInputStream=null;
        //添加一个Byte容量设置为10数组
        byte[] bytes = new byte[9];
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多10个字节的数据到字节数组。
            //如果返回-1,则代表读取完毕
            //如果读取正常返回实际读取的字节数
            while ((readLen=fileInputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭文件流释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　1.2、ObjectInputStream（对象反序列化）

　　　　注意先进行 ObjectOutputStream 序列化到 D:\a.dat 文件中然后才进行的反序列化

public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //指定反序列化的文件
        String filePath="D:\\a.dat";

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

        //读取
        //反序列的顺序需要和保存的数据的顺序一致,否则会出现异常
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());
        Object dog = objectInputStream.readObject();
        System.out.println("运行类型："+dog.getClass());
        System.out.println("dog信息:"+dog);//底层 Object-->Dog

        //关闭外层流即可
        objectInputStream.close();
    }
}

可以看到输出：

2、OutputStream

　　2.1、FileOutputStream

public class FileOutputStream_ {
    public static void main(String[] args) {
            writeFile();
    }
    /**
     * 使用FileOutputStream将数据写入文件中
     * 如果数据不存在，则自动创建该文件
     */
    public static void writeFile(){
        String filePath="D:\\a.txt";
        FileOutputStream fileOutputStream=null;
        try {
            //得到FileOutputStream对象
            //1、这种创建方式，写入的内容是覆盖原来的文件中的内容
            //2、在构造器中添加 true 为追加填写
            fileOutputStream = new FileOutputStream(filePath,true);

            //写入一个字节
            // fileOutputStream.write('a');   fileOutputStream.write(97);

            //写入字符串   str.getBytes()字符串转为字节数组
            String str="hollow";
            //fileOutputStream.write(str.getBytes());

            //也可以指定字节数组中的起始位置，末尾位置
            fileOutputStream.write(str.getBytes(),0,str.length());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　2.2、ObjectOutputStream（对象序列化）　　

/**
 * ObjectOutputStream的使用，完成数据的序列化
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception {
        //序列化后，保存的格式，不是纯文本，而是按照他的格式来保存
        String filePath = "D:\\a.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));

        //序列化数据到 D:\a.bat
        objectOutputStream.write(100);//int-->Integer(实现了Serializable)
        objectOutputStream.writeBoolean(true);//boolean-->Boolean(实现了Serializable)
        objectOutputStream.writeChar('a');//chat-->Character(实现了Serializable)
        objectOutputStream.writeDouble(1.1);//double-->Double(实现了Serializable)
        objectOutputStream.writeUTF("阿龙学习");//String

        //保存一个对象
        objectOutputStream.writeObject(new Dog("旺财",5));
        objectOutputStream.close();
        System.out.println("序列化数据保存完毕");
    }
}
//lombok插件
@Data
@AllArgsConstructor
@NoArgsConstructor
//要实现Serializable接口才能够进行序列化
class Dog implements Serializable {
    private String name;
    private int age;
}

　　2.3、PrintStream（字节打印流）　　

/**
 * PrintStream字节打印流
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        // System.out 就是 PrintStream
        PrintStream out = System.out;
        //在默认情况下，默认打印的是标准输出（即 显示器）
        out.println("你好");
        //因为底层使用的是write,所以可以直接调用write进行打印/输出
        out.write("hello，你好！".getBytes(StandardCharsets.UTF_8));
        //关闭流。
        out.close();
        //我们可以修改打印输出流的位置/设备
        //修改成"D:\\a.txt"
        //这句话将会输出到D:\a.txt
        System.setOut(new PrintStream("D:\\a.txt"));
        System.out.println("这句话将会输出到D:\\a.txt");
    }
}

二、字符流

　　通常用来处理文本文件，更高效。

1、Reader

　　1.1、FileReader　

public class FileReader_ {
    public static void main(String[] args) {
        String filePath="d:\\a.txt";
        FileReader fileReader=null;
        int data= 0;
        char[] chars = new char[10];
        //1、创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取，使用read(chars),返回的是实际读取到的字符数
            //如果返回-1则表示读到文件结尾
           while ((data = fileReader.read(chars))!=-1){
               System.out.print(new String(chars,0,data));
           }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　1.2、BufferedReader

　　　　BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类（BufferedWriter也是一样的操作）

public class BufferedReader_ {
    public static void main(String[] args) throws Exception {  //异常也可以try catch
        String filePath = "D:\\a.txt";

        //创建bufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取，效率高
        //1.bufferedReader.readLine() 按行读取文件
        //2.当返回为空时，表示文件读取完毕。
         while ((line = bufferedReader.readLine())!=null){
             System.out.println(line);
         }
         //关闭流，只需要关闭外层的流，即bufferedReader,因为底层会自动的去关闭节点流 FileReader
         bufferedReader.close();
    }
}

　　1.3、InputStreamReader(转换流，并可以指定编码格式读取)

/**
 * InputStreamReader  转换流解决中文乱码问题
 * 将字节流 FileInputStream 转换成字符流 InputStreamReader, 指定编码 gbk/utf-8
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\a.txt";
        //把 new FileInputStream(filePath) 转成 InputStreamReader 同时指定了编码 utf-8
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath), StandardCharsets.UTF_8);
        //把 InputStreamReader 传入 BufferedReader
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String readLine;
        while(( readLine = bufferedReader.readLine())!=null){
            System.out.println(readLine);
        }
        bufferedReader.close();
    }
}

2、Writer

　　2.1、FileWriter

注意：FileWriter使用后，必须要关闭(close)或刷新(flush)流, 否则写入不到指定的文件!

public class FileWriter_ {
    public static void main(String[] args) {
        String filePath="D:\\a.txt";
        FileWriter fileWriter=null;
        String str="哈哈哈哈哈哈哈哈哈";
        try {
            fileWriter = new FileWriter(filePath,true);//true为追加，不写则覆盖
            //fileWriter.write(str);
            fileWriter.write(str,0,2);//指定str的某一部分
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　2.2、BufferedWriter

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath="D:\\a.txt";
        //创建BufferedWriter
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));//追加要在节点流中进行设置
        bufferedWriter.write("红红火火恍恍惚惚红红火火恍恍惚惚吼吼吼1");
        //插入一个换行
        bufferedWriter.newLine();
        bufferedWriter.write("红红火火恍恍惚惚红红火火恍恍惚惚吼吼吼2");
        //插入一个换行
        bufferedWriter.newLine();
        bufferedWriter.write("红红火火恍恍惚惚红红火火恍恍惚惚吼吼吼3");

        //关闭外层流即可
        bufferedWriter.close();
    }

}

　　2.3、OutputStreamWriter（转换流，并可以指定编码格式写入）

/**
 * 将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,
 * 对文件进行写入(按照gbk格式，可以指定其他，比如utf-8/utf8)
 */
public class InputStreamWriter_ {
    public static void main(String[] args) throws IOException {//异常直接进行的抛出，也可以try catch
        String filePath = "D:\\a.txt";
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(filePath), "gbk");
        outputStreamWriter.write("gbk格式的编码");
        //关闭流
        outputStreamWriter.close();
    }
}

　　2.4、PrintWriter(字符打印流)

public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        //创建PrintWriter对象
        PrintWriter printWriter = new PrintWriter(new FileWriter("D:\\a.txt"));
        //将会打印到 D:\a.txt
        printWriter.println("哈喽你好 ");
        printWriter.close(); //flush + 关闭流
    }
}

三、Properties类　

　　load:加载配置文件的键值对到Properties对象
　　list:将数据显示到指定设备
　　getProperty(key):根据键获取值
　　setProperty(key,value):设置键值对到Properties对象
　　store:将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果
　　含有中文，会存储为unicode码

　　1、Properties读取数据　　　

public class Properties_read {
    public static void main(String[] args) throws IOException {
        //使用Properties读取ycl.properties文件
        Properties properties = new Properties();
        //加载指定的配置文件
        properties.load(new FileReader("src/main/resources/ycl.properties"));
        //键值对显示到控制台
        properties.list(System.out);
        //根据key 获取对应的值
        String id = properties.getProperty("id");
        System.out.println("id是："+id);
    }
}

　　2、Properties写入数据

public class Properties_writer {
    public static void main(String[] args) throws IOException {
        //使用Properties类， 创建配置文件，修改配置文件内容
        Properties properties = new Properties();

        //设置内容
　　　　 //如果该文件没有对应的key,就是创建
　　　　 //如果该文件有对应的key，就是修改
        properties.setProperty("charset","utf-8");
        properties.setProperty("username","小刚");//中文保存的是unicode码
        properties.setProperty("pwd","123567894");

        //将k-v 存储至文件
        properties.store(new FileOutputStream("D:\\a.data"),null);
        System.out.println("保存成功");
    }
}

四、copy练习

　　1、字节流copy练习

public class FileCopy {
    public static void main(String[] args) {
            copy();
    }
    public static void copy(){
        String resourcePath="D:\\壁纸\\1.jpg";
        String targetPath="D:\\壁纸\\3.jpg";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        int readLen=0;
        try {
            fileInputStream = new FileInputStream(resourcePath);
            fileOutputStream=new FileOutputStream(targetPath);
            //定义一个数组提高效率
            byte[] bytes = new byte[1024];
            while ((readLen=fileInputStream.read(bytes))!=-1){
                //边读边写
                fileOutputStream.write(bytes,0,readLen);//必须用这个参数，否则出现文件损失
            }
            System.out.println("copy完成");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　2、缓冲字符流copy文本练习

　　　　BufferedReader和BufferedWriter 是按照字符操作的，不要去操作二进制文件（声音、视频、doc、pdf、图片等等），拷贝后的文件可能会造成文件损坏

public class Buffered_copy {
    public static void main(String[] args) {
        //源文件路径
        String resourcePath = "D:\\a.txt";
        //目标文件的路径
        String targetPath = "D:\\b.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            //创建bufferedReader、bufferedWriter
            bufferedReader = new BufferedReader(new FileReader(resourcePath));
            bufferedWriter = new BufferedWriter(new FileWriter(targetPath,true));//true表示追加写入
            String line;
            //readLine() 读取一行内容，但是没有换行
            while ((line = bufferedReader.readLine()) != null) {
                //每读取一行就写入
                bufferedWriter.write(line);
                //插入换行
                bufferedWriter.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流
                if (bufferedReader!=null){
                    bufferedReader.close();
                }
                if (bufferedWriter!=null){
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

　　3、缓冲字节流copy二进制文件（copy文本文件一样可以）　

/**
 * BufferedInputStream、BufferedOutputStream的使用
 */
public class Buffered_copy02 {
    public static void main(String[] args) {
        String resourcePath = "D:\\壁纸\\2.jpg";
        String targetPath = "D:\\壁纸\\4.jpg";
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            //创建对象
            bufferedInputStream = new BufferedInputStream(new FileInputStream(resourcePath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(targetPath));
            int readLen;
            byte[] buf = new byte[1024];
            //返回读取到的长度,当返回-1时，就表示文件读取完毕
            while ((readLen = bufferedInputStream.read(buf))!=-1){
                bufferedOutputStream.write(buf,0,readLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭外层处理流即可，底层会自动关闭节点流
                if (bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if (bufferedOutputStream!=null){
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

码农公寓

前置知识：

序列化和反序列化

节点流和处理流

一、字节流

1、inputStream

1.1、FileInputStream

1.2、ObjectInputStream（对象反序列化）

2、OutputStream

2.1、FileOutputStream

2.2、ObjectOutputStream（对象序列化）

2.3、PrintStream（字节打印流）

二、字符流

1、Reader

1.1、FileReader

1.2、BufferedReader

1.3、InputStreamReader(转换流，并可以指定编码格式读取)

2、Writer

2.1、FileWriter

2.2、BufferedWriter

2.3、OutputStreamWriter（转换流，并可以指定编码格式写入）

2.4、PrintWriter(字符打印流)

三、Properties类

1、Properties读取数据

2、Properties写入数据

四、copy练习

1、字节流copy练习

2、缓冲字符流copy文本练习

3、缓冲字节流copy二进制文件（copy文本文件一样可以）

相关文章

　　1.1、FileInputStream

　　1.2、ObjectInputStream（对象反序列化）

　　2.1、FileOutputStream

　　2.2、ObjectOutputStream（对象序列化）　　

　　2.3、PrintStream（字节打印流）　　

　　1.1、FileReader　

　　1.2、BufferedReader

　　1.3、InputStreamReader(转换流，并可以指定编码格式读取)

　　2.1、FileWriter

　　2.2、BufferedWriter

　　2.3、OutputStreamWriter（转换流，并可以指定编码格式写入）

　　2.4、PrintWriter(字符打印流)

三、Properties类　

　　1、Properties读取数据　　　

　　2、Properties写入数据

　　1、字节流copy练习

　　2、缓冲字符流copy文本练习

　　3、缓冲字节流copy二进制文件（copy文本文件一样可以）　