• IO流（二）

    IO流-字符流

    文件字符输入流-读字符数据进来

    字节流:适合复制文件等，不适合读写文本文件

    字符流:适合读写文本文件内容

    FileReader(文件字符输入流)
    作用:以内存为基准，可以把文件中的数据以字符的形式读入到内存中去。

    1.  
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileReader;
    5. import java.io.Reader;
    6.  
    7. public class FileReaderTest1 {
    8.     public static void main(String[] args) {
    9.         /**
    10.          * 目标：掌握文件字符输入流每次读取一个字符
    11.          */
    12.  
    13.         try (
    14.                 //1.首先创建一个文件字符输入流管道与源文件接通
    15.                 //相对路径 new FileReader 获得一个文件输入流管道 交给一个Reader类型的变量fr记住（多态的写法）
    16.                 Reader fr = new FileReader("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima01.txt"); //同时把流对象放到try后面的小括号里边去
    17.         ) {//2.读取文本文件的内容
    18.             /*int c;//用来记住每次读取的字符编号
    19.             while ((c = fr.read()) != -1) {//说明读到了这个字符     fr.read()表示去这个文件输入流里面读一个字符编号给到c
    20.                 System.out.print((char) c);//直接写c表示输出一个字符编号是不行的，要把它转成字符，强转成char，这里不要换行，会导致每输出一个字符换行
    21.             }*/
    22.             //每次读取一个字符的形式，他的性能肯定是比较差的
    23.  
    24.             //3.用字符数组，每次读取多个字符  每次读取更多字符，系统调用就会少一些，性能是更好一点的
    25.             //第一步要定义一个字符数组来装字符
    26.             char[] buffer = new char[3];//方便理解 每次读三个字符
    27.             //接着定义一个int类型的变量len
    28.             int len;//记住每次读取了多少个字符 ，因为最后一桶水有可能没有装满这个字符，一定要读多少倒多少，那就要记住每次读取了多少个字符
    29.             //接着再写一个while循环
    30.             while ((len = fr.read(buffer)) != -1) {//len = fr.read(buffer) ->把桶交给read方法  调用的read方法可以每次可以读多个字符到这个字符数组种
    31.                 //进到里面来就要把字符数组里面的字符转成字符串
    32.                 //用字符串这个构造器把字符数组扔给他，从第一个字符开始（0），读了多少由len记住就倒出多少个字符，然后打印输出
    33.                 //读取多少就倒出多少
    34.                 System.out.print(new String(buffer, 0, len));//换行去掉
    35.             }
    36.  
    37.         } catch (Exception e) {//改用EXception来拦截一切异常
    38.             e.printStackTrace();
    39.         }
    40.         //对异常进行try catch  进行资源的释放
    41.     }
    42. }

    文件字符输出流-写字符数据出去

    FileWriter(文件字符输出流)
    作用:以内存为基准，把内存中的数据以字符的形式写出到文件中去。

     

    io流每次读写一次数据，都需要进行一次系统调用，才可以把数据读写到文件里面去，每次都进行系统调用都是比较耗费系统性能的；
而文件字符输出流就优化了这个问题，当创建文件字符输出流时，会在内存中分配一块区域出来，称为缓冲区；
以后再用文件字符输出流写数据的时候，并不是把数据通过系统直接写到文件里面去，而是把数据先写到缓冲区里面去；
最后通过一种机制，把缓冲区里面的数据通过调用底层系统，在只需要写一次，就把数据全部写到文件中去，这样只需要一次系统调用，性能就会好很多。
如何通知缓冲区，把他里面的数据通过调用系统一次同步到文件里面去？
1.刷新流操作--> fw.flush()2.关闭流（包含刷新操作）fw.close()
//注意：关闭流之后就不能继续使用了，刷新流后还可以继续使用。
    1.  
    2.  
    3. import java.io.FileWriter;
    4. import java.io.IOException;
    5. import java.io.Writer;
    6.  
    7. public class FileWriterTest2 {
    8.     //io流每次读写一次数据，都需要进行一次系统调用，才可以把数据读写到文件里面去；每次都进行系统调用都是比较耗费系统性能的
    9.     //而文件字符输出流就优化了这个问题，当创建文件字符输出流时，会在内存中分配一块区域出来，称为缓冲区；
    10.     // 以后再用文件字符输出流写数据的时候，并不是把数据通过系统直接写到文件里面去，而是把数据先写到缓冲区里面去；
    11.     //最后通过一种机制，把缓冲区里面的数据通过调用底层系统，在只需要写一次，就把数据全部写到文件中去，这样只需要一次系统调用，性能就会好很多
    12.     //如何通知缓冲区，把他里面的数据通过调用系统一次同步到文件里面去？1.刷新流操作--> fw.flush()2.关闭流（包含刷新操作）fw.close()
    13.     //注意关闭流之后就不能继续使用了，刷新流后还可以继续使用。
    14.     public static void main(String[] args) {
    15.         //0.创建一个文件字符输出流管道与目标文件接通
    16.  
    17.         //是一个覆盖管道
    18.         //目标文件会自动生成，我们不需要提前去把目标文件创建出来的直接创建管道就可以了
    19.         try (//把资源放在小括号里面，用完之后会帮我进行自动释放
    20.              //Writer fw = new FileWriter("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima02.txt");
    21.              //如果做数据增加  管道创建出来的时候后面还能增加一个参数
    22.              Writer fw = new FileWriter("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima02.txt",true);//此时就变成了追加数据的管道
    23.         ) {
    24.             //1、public void write(int c):写一个字符出去
    25.             fw.write('a');
    26.             fw.write(97);
    27.             fw.write('凡');
    28.             fw.write("\r\n");//换行
    29.  
    30.             // 2、public void write(string c)写一个字符串出去
    31.             fw.write("woaini");
    32.             fw.write("我爱你");
    33.             fw.write("\r\n");
    34.             // 3、public void write(string c ,int pos int len):写字符串的一部分出去
    35.             fw.write("woxihuanni", 2, 8);
    36.             fw.write("\r\n");
    37.             // 4、public void write(char[]buffer):写一个字符数组出去
    38.             char[] buffer = {'l', 'z', 'x', 'w', 'y', 'f'};
    39.             fw.write(buffer);
    40.             fw.write("\r\n");
    41.             // 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
    42.             fw.write(buffer, 0, 3);
    43.         } catch (Exception e) {
    44.             e.printStackTrace();
    45.         }
    46.  
    47.  
    48.     }
    49. }

    字符输出流使用时的注意事项
    字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

     

    如果数据没有经过刷新和关闭操作把缓冲区挤满了，等后面在写数据的时候先会把装满了的数据自动同步一次到文件中去，然后流出空间再往里面放数据，所以不用担心。

    IO流-缓冲流

    缓冲流的作用是用来包装所谓的原始流，然后提高原始流读写数据的性能的。

    字节缓冲流

    作用：提高字节流读写数据的性能

    1.  
    2.  
    3. import java.io.*;
    4.  
    5. /**
    6.  * 目标：掌握字节缓冲流的作用
    7.  */
    8. public class BufferedInputStreamTest1 {
    9.     public static void main(String[] args) {
    10.         try (
    11.                 FileInputStream is = new FileInputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima01.txt");
    12.                 //缓冲流的思想：不在用原始的资源流
    13.                 // 1、定义一个字节缓冲输入流包装原始的字节输入流
    14.                 //InputStream bis = new BufferedInputStream(is);
    15.                 InputStream bis = new BufferedInputStream(is, 8192 * 2);
    16.                 //这里可以把底层的缓冲池搞得更大一点，可能性能更好，这里是将底层的缓冲池做到16KB，可以自己在这个地方声明制定缓冲池的大小
    17.  
    18.                 FileOutputStream os = new FileOutputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima01_bak.txt");
    19.                 //2.定义一个字节缓冲输出流包装原始的字节输出流
    20.                 OutputStream bos = new BufferedOutputStream(os);//交给一个字节输出流的变量bos 多态的写法
    21.         ) {
    22.  
    23.             /*byte[] buffer = new byte[1024];
    24.             int len;
    25.             while ((len = is.read(buffer)) != -1) {
    26.             这里就不能用is和os来进行读和写了，应该用的是包装后的缓冲流dis和dos，这样的话就会利用到8KB的缓冲池，每次读8KB，再由数组进行转移
    27.                 os.write(buffer, 0, len);
    28.             }*/
    29.             byte[] buffer = new byte[1024];
    30.             int len;
    31.             while ((len = bis.read(buffer)) != -1) {
    32.                 bos.write(buffer, 0, len);
    33.             }
    34.             System.out.println("复制完成!!");
    35.  
    36.         } catch (Exception e) {
    37.             e.printStackTrace();
    38.         }
    39.     }
    40. }


    字符缓冲流

    作用：自带8K（8192）的字符缓冲池，提高字符流读写数据的性能

    1.  
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.FileReader;
    5. import java.io.Reader;
    6.  
    7. /**
    8.  * 目的：掌握字符缓冲输入流的用法
    9.  */
    10.  
    11. public class BufferedReaderTest2 {
    12.     public static void main(String[] args) {
    13.         try (
    14.                 Reader fr = new FileReader("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima04.txt");
    15.                 // 创建一个字符缓冲输入流包装原始的字符输入流
    16.                 BufferedReader br = new BufferedReader(fr);//这里不要用多态的方式写了因为后面要用新增的特有功能：按照行读
    17.  
    18.         ) {
    19.             /*char[] buffer = new char[3];
    20.             int len;
    21.             while ((len = br.read(buffer)) != -1) {
    22.                 System.out.print(new String(buffer, 0, len));
    23.             }*/
    24.            /* System.out.println(br.readLine());
    25.             System.out.println(br.readLine());一行一行读肯定不现实，所以需要循环
    26.             System.out.println(br.readLine());
    27.             System.out.println(br.readLine());*/
    28.             String line;// 用来记住每次读取的一行数据
    29.             while((line = br.readLine()) != null){
    30.                 System.out.println(line);
    31.             }
    32.  
    33.         } catch (Exception e) {
    34.             e.printStackTrace();
    35.         }
    36.  
    37.     }
    38. }
    1.  
    2.  
    3. import java.io.BufferedWriter;
    4. import java.io.FileWriter;
    5. import java.io.Writer;
    6.  
    7. public class BufferedWriterTest3 {
    8.     public static void main(String[] args) {
    9.         try (
    10.                 //Writer fw = new FileWriter("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima02.txt");
    11.                 Writer fw = new FileWriter("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima02.txt", true);//此时就变成了追加数据的管道
    12.                 //创建一个字符缓冲输出流管道包装原始的字符缓冲输出流
    13.                 BufferedWriter bw = new BufferedWriter(fw);//因为要用新增的功能所以不用多态来写
    14.  
    15.         ) {
    16.             //1、public void write(int c):写一个字符出去
    17.             bw.write('a');
    18.             bw.write(97);
    19.             bw.write('凡');
    20.             //bw.write("\r\n");//换行
    21.             bw.newLine();//换行
    22.  
    23.             //2、public void write(string c)写一个字符串出去
    24.             bw.write("woaini");
    25.             bw.write("我爱你");
    26.             //bw.write("\r\n");
    27.             bw.newLine();//换行
    28.         } catch (Exception e) {
    29.             e.printStackTrace();
    30.         }
    31.     }
    32. }


    原始流、缓冲流的性能分析【重点】

    字节数组是越大越好，性能相对来说会越快，但大到一定程度就不明显了。（字节数组很大的时候每次装的数据多系统调用的次数少，性能肯定会好；但数组很大的时候装数据的过程慢，倒数据的过程也要慢一点，要花更多的时间装进去，也要花更多的时间倒出来；虽然字节数组大了可能对性能没法提升了）因此在开发中，如果要提高这些流的读写性能，不一定非得用缓冲流，可以用低级字节流，把这个数组弄大，性能可能就提升了，看到多少能够性能达到较好，根据自己的经验去设置。


    IO流-转换流

    引出问题:不同编码读取时会乱码

    如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文件时不会出现乱码
    如果代码编码和被读取的文本文件的编码是不一致的，使用字符流读取文本文件时就会出现乱码!


    字符输入转换流

    InputStreamReader(字符输入转换流)

    • 解决不同编码时，字符流读取文本内容乱码的问题。
    • 解决思路:先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了

    字符输出转换流

    需要控制写出去的字符使用什么字符集编码该咋整?

    • 调用String提供的getBytes方法解决?   String data="我爱你中国abc";
    • byte[] bytes = data.getBytes("GBK")    使用”字符输出转换流”实现。

    OutputStreamWriter(字符输出转换流)

    • 作用:可以控制写出去的字符使用什么字符集编码，
    • 解决思路:获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了


    IO流-打印流

     PrintStream/PrintWriter(打印流)
    作用:打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

    PrintStream和PrintWriter的区别

    • 打印数据的功能上是一模一样的:都是使用方便，性能高效(核心优势)
    • PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
    • PrintWriter继承自字符输出流Writer，因此支持写字符数据出去

    （我们用的是他的打印功能，所以两者在功能上没有什么区别）

    打印流的一种应用:输出语句的重定向。可以把输出语句的打印位置改到某个文件中去。


    IO流-数据流

     DataOutputstream(数据输出流)

    • 允许把数据和其类型一并写出去。

    DatalnputStream(数据输入流)

    • 用于读取数据输出流写出去的数据

    注意：写什么读什么，一定要对应起来！

    1. //数据输出流
    2. import java.io.DataOutputStream;
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5.  
    6. public class DataOutputStreamTest1 {
    7.     public static void main(String[] args) {
    8.  
    9.         try ( //1.创建一个数据输出流包装低级字节输出流
    10.                 DataOutputStream dos =
    11.                         new DataOutputStream(new FileOutputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima10out.txt"));
    12.  
    13.                 ){//这样我们就到到一个数据输出流了 然后就可以调用它的方法
    14.             dos.writeInt(99);
    15.             dos.writeDouble(99.9);
    16.             dos.writeBoolean(true);
    17.             //dos.writeByte(10);
    18.             dos.writeUTF("我爱你义凡");
    19.  
    20.  
    21.         } catch (Exception e) {
    22.             e.printStackTrace();
    23.         }
    24.     }
    25. }
    1. //数据输入流
    2.  
    3. import java.io.DataInputStream;
    4. import java.io.FileInputStream;
    5. import java.io.FileNotFoundException;
    6. import java.io.InputStream;
    7.  
    8. public class DataInputStreamTest2 {
    9.     public static void main(String[] args) {
    10.         try(
    11.                 DataInputStream dis =
    12.                         new DataInputStream(new FileInputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima10out.txt"));
    13.                 ) {
    14.             //System.out.println(dis.readInt());
    15.             int i = dis.readInt();
    16.             System.out.println(i);
    17.             double d = dis.readDouble();
    18.             System.out.println(d);
    19.             boolean b = dis.readBoolean();
    20.             System.out.println(b);
    21.             String rs = dis.readUTF();
    22.             System.out.println(rs);
    23.  
    24.         } catch (Exception e) {
    25.             e.printStackTrace();
    26.         }
    27.     }
    28. }


    IO流-序列化流

    对象序列化:把Java对象写入到文件中去
    对象反序列化:把文件里的Java对象读出来

    Objectoutputstream(对象字节输出流)
    可以把Java对象进行序列化:把Java对象存入到文件中去。

    注意:对象如果要参与序列化，必须实现序列化接口(java.io.Serializable)

    Objectlnputstream(对象字节输入流)
    可以把Java对象进行反序列化:把存储在文件中的Java对象读入到内存中来。

     如果要一次序列化多个对象，怎么办？
    用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可
    注意:ArrayList集合已经实现了序列化接口!

    注意:对象如果需要序列化，必须实现序列化接口。（implements Serializable）  相当于一个标记，给虚拟机程序看的，只有实现了这个接口，才允许这个对象按特定的方式存入到文件中去的虚拟就会启动装载程序把对象按照既定的格式存到文件中去。
    1.  
    2.  
    3. import java.io.Serializable;
    4.  
    5. //注意:对象如果需要序列化，必须实现序列化接口。  相当于一个标记，给虚拟机程序看的，只有实现了这个接口，才允许这个对象按特定的方式存入到文件中去的
    6. //虚拟就会启动装载程序把对象按照既定的格式存到文件中去
    7. public class User implements Serializable {
    8.     private String loginName;
    9.     private String userName;
    10.     private int age;
    11.     //transient 这个成员变量将不参与序列化
    12.     private transient String passWord;
    13.  
    14.  
    15.     public User() {
    16.     }
    17.  
    18.     public User(String loginName, String userName, int age, String passWord) {
    19.         this.loginName = loginName;
    20.         this.userName = userName;
    21.         this.age = age;
    22.         this.passWord = passWord;
    23.     }
    24.  
    25.     public String getLoginName() {
    26.         return loginName;
    27.     }
    28.  
    29.     public void setLoginName(String loginName) {
    30.         this.loginName = loginName;
    31.     }
    32.  
    33.     public String getUserName() {
    34.         return userName;
    35.     }
    36.  
    37.     public void setUserName(String userName) {
    38.         this.userName = userName;
    39.     }
    40.  
    41.     public int getAge() {
    42.         return age;
    43.     }
    44.  
    45.     public void setAge(int age) {
    46.         this.age = age;
    47.     }
    48.  
    49.     public String getPassWord() {
    50.         return passWord;
    51.     }
    52.  
    53.     public void setPassWord(String passWord) {
    54.         this.passWord = passWord;
    55.     }
    56.  
    57.     @Override
    58.     public String toString() {
    59.         return "User{" +
    60.                 "loginName='" + loginName + '\'' +
    61.                 ", userName='" + userName + '\'' +
    62.                 ", age=" + age +
    63.                 ", passWord='" + passWord + '\'' +
    64.                 '}';
    65.     }
    66. }
    1. //对象字节输出流序列化对象
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5. import java.io.ObjectOutputStream;
    6.  
    7. public class Test1ObjectOutputStream {
    8.     public static void main(String[] args) {
    9.  
    10.         //2、创建一个对象字节输出流包装原始的字节输出流
    11.         try (
    12.                 ObjectOutputStream oos =
    13.                         new ObjectOutputStream(new FileOutputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima11out.txt"));
    14.                 ){
    15.             //1.创建一个Java对象
    16.             User u = new User("admin","张三",23,"888666wyf");
    17.             //3.序列化对象到文件中去
    18.             oos.writeObject(u);
    19.             System.out.println("序列化对象成功！");//Java规定如果对某个对象进行序列化的话就必须让这个对象的类去实现一个接口Serializable
    20.  
    21.         } catch (Exception e) {
    22.             e.printStackTrace();
    23.         }
    24.  
    25.     }
    26. }
    1. //对象字节输入流反序列化对象
    2.  
    3. import java.io.*;
    4.  
    5. /**
    6.  * 目标：如何实现对象的反序列化，掌握对象字节输入流的使用
    7.  */
    8. public class Test2ObjectInputStream {
    9.     public static void main(String[] args) {
    10.         //1.必须创建一个对象字节输入流管道包装低级的字节输入流与源文件接通
    11.         try(
    12.                 ObjectInputStream ois =
    13.                         new ObjectInputStream(new FileInputStream("D:\\code\\idea-javacode\\javaseproject\\io-app2\\src\\itheima11out.txt"));
    14.                 ) {
    15.             User u = (User) ois.readObject();
    16.             //可以把文件种存储的Java对象又恢复到内存中，返回的是一个Object类型的对象
    17.             //因为存到文件中的是一个用户对象，所以用一个User来接收，强转成用户对象就可以了
    18.             System.out.println(u);
    19.         } catch (Exception e) {
    20.             e.printStackTrace();
    21.         }
    22.  
    23.     }
    24. }


    补充知识:IO框架

    什么是框架?

    • 解决某类问题，编写的一套类、接口等，可以理解成一个半成品，大多框架都是第三方研发的。
    • 好处:在框架的基础上开发，可以得到优秀的软件架构，并能提高开发效率
    • 框架的形式:一般是把类、接口等编译成class形式，再压缩成一个,jar结尾的文件发行出去

    什么是IO框架？ 

    • 封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。

     步骤：导入commons-io-2.15.1.jar框架到项目中去。

    1. 在项目中创建一个文件夹:lib
    2. 将commons-io-2.6.jar文件复制到lib文件夹
    3. 在jar文件上点右键，选择 Add as Library ->点击OK
    4. 在类中导包使用
  • 相关阅读:
    越折腾越好用的 3 款开源 APP
    Leetcode—动态规划（背包问题）
    人工智能基础_机器学习033_多项式回归升维_多项式回归代码实现_非线性数据预测_升维后的数据对非线性数据预测---人工智能工作笔记0073
    Spring Boot 中 Controller 接口参数注解全攻略与实战案例详解
    MindSpore自动微分小技巧
    简单的用Python实现一下，采集某牙视频，多个视频翻页下载
    Web模块
    【论文笔记】CrossKD: Cross-Head Knowledge Distillation for Object Detection
    我们的商城首页卡死了。。。
    SSM 高校心理测评系统
  • 原文地址：https://blog.csdn.net/weixin_59855900/article/details/136700330