io流复习+代码演示

前置知识：

序列化和反序列化

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

IO流的三种分类

　　第一种：输入流和输出流
　　　　按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。
　　　　输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。
　　　　输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类

　　第二种：字节流和字符流
　　　　字节流和字符流的用法几乎完全一样，区别在于字节流和字符流所操作的数据单元不同。
　　　　字节流操作的数据单元是8位字节，由InputStream和OutputStream作为基类。
　　　　字符流操作的数据单元是16位的字符，由Reader和Writer作为基类

　　第三种：节点流和处理流
　　　　按照流的角色来分，可以分为节点流和处理流。
　　　　节点流：可以从向一个特定的IO设备（如磁盘、网络）读/写数据的流。也被称为低级流。
　　　　处理流：用于对一个已存在的流进行连接或封装，通过封装后的流来实现数据读/写功能。也称为高级流

节点流和处理流的区别和联系
　　　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();
            }
        }
    }
}