20220809 第一组 于芮 IO流实践与应用（第二十八天）

 

小白成长记——第二十八天

 

   今天的主要学习内容是IO流的实践与应用，主要学习了字符输入流，字符输出流，字节输入流，字节输出流这几种的使用，还有一些实践案例，IO流也是java基础的重要组成部分，对接下来的学习也有重要的作用，并且与前面的知识联系也比较多，但是并没有多线程那么难以理解，总体来说，掌握的应该还行，来看一下今天的学习笔记吧！

IO流（输入输出流）
1.按照流向分
输入流：从磁盘上读取数据到内存（读）
输出流：从内存写出数据到硬盘上（写）
一个文件在传输过程中经历过多次拷贝，IO的性能本身就很低
2. 按照操作单元分
字节流：一个字节的操作（二进制操作），可以操作任意类型的文件
字符流：一个字符的操作（一个字符是两个字节），主要用来处理文本文件,例如.txt,.java,.py,.xml,.html,.js,性能高
3.按照角色划分
节点流：直接操作一个特定的IO设备
处理流：在节点流的基础上，做进一步的处理，
file类不能操作文件的内容

java中常用的流
字节输入流：inputstream->fileinputstream->bufferinputstream(缓冲流)->objectinputstream（操作对象）
字节输出流：outputstream->fileoutputstream->bufferoutputstream(缓冲流)->objectoutputstream（操作对象）
字符输入流：reader->filereader->bufferreader(缓冲流)
字符输出流：writer->filewriter->bufferwriter(缓冲流)

流的具体使用
输入流：往内存中读取数据
开始读文件册操作，read方法（），返回值int，当返回值是-1，说明文件读取到了末尾，读取文件是否结束的标记
字节输入流：
1.创建一个fileinputstream
2.定义一个标记用来控制输入流的读取
3.循环读取，如果读取到了-1，说明读取到了文件的末尾，循环结束
4.关闭资源.close（封装工具类）--重要

当一个流读完之后，默认调用Mark和reset方法来进行记录和重置，这个就已经重置到了上次读完的位置
所以就无法再次读取内容，并不是读完一次之后就关闭了流

字节输出流：
fileoutputstream构造器
boolean append，如果出入TRUE，则代表在原有基础上追加，不覆盖
如果传入false，或者不传，覆盖原有内容
写的操作，如果目标文件不存在，会自动创建

字符流：

字符处理流（用的最多）
缓冲流（处理流）
外层流，内层流：关闭了外层的流，内层的流会随之关闭。

序列化与反序列化（操作对象）
序列化：将对象写入到IO流中（将内存模型的对象变成字节数字），可以进行存储和运输
反序列化：从IO流中恢复对象，将存储在硬盘上或者从网络中接收的数据恢复成对象模型
使用场景：所有可在网络上传输的对象都必须是可序列化的，否则会报错，所有保存在硬盘上的对象也必须要可序列化的。
序列化版本号：反序列化必须有class文件，但随着项目的升级，class文件也会升级，序列化要保证升级前后的兼容性
版本号可以自由指定，但是不能不指定，如果不指定，JVM会根据类信息自己计算一个版本号，所以无法匹配，会报错
不指定版本号，不利于JVM的移植，可能class文件没有改，但是不同的JVM计算规则不同，导致无法序列化
如果只修改了方法，反序列化不受影响，无需修改版本号
如果修改了的静态变量static，瞬态变量transient，反序列化也不受影响，无需修改版本号

总结
1.所有需要网络传输的对象都需要实现序列化接口
2.对象的类名，实例变量都会被序列化，方法，类变量，transient变量不会被序列化
3.如果想让某个变量不被序列化。可以用transient修饰
4.序列化对象的引用类型成员变量，也必须是可序列化的，否者会报错
5.反序列化是必须有序列化对象的class文件
6.同一个对象被序列化多次，只有第一次序列化为二进制，以后都只是保存序列化的版本号
* 7.建议所有可序列化的类加上版本号，方便项目升级。

properties（读取属性文件）

 

      今天的实例主要是一些操作文件的读取操作，利用几种方式完成输入输出的操作，接下来看一下代码吧！

package H0809;

import org.junit.Test;

import java.io.*;
import java.util.Objects;

public class Ch02 {

    @Test
    public void test1() {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("f:/indel");
            int read;
            byte[] buf = new byte[1024];
            while ((read = inputStream.read(buf)) != -1) {
                System.out.println(new String(buf));
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            //IOUtil.closeIO(inputStream,null);
           /* try {
                if(Objects.nonNull(inputStream)){
                    //关闭流
                    inputStream.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }*/
        }
    }
    @Test
    public void test2(){
        InputStream inputStream=null;
        try {
            inputStream=new FileInputStream("f:/indeal");
            //开始读的操作，read方法，返回值是int，当返回值是-1时，说明文件读取到了末尾
            //读取文件是否结束的标记
            int  read;
            //循环读取
            while((read=inputStream.read())!=-1){
                System.out.println(read+"");
            }
            System.out.println();
            System.out.println("读取完毕，再读一次。。");
            //循环读取
            while ((read=inputStream.read())!=-1){
                System.out.println(read+"");
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                //关闭流
                inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    @ Test
    public void test3(){
        OutputStream outputStream=null;
        try {
            outputStream= new FileOutputStream("f:/ideal");
            outputStream.write("\r\n".getBytes());
            outputStream.write("hahahahha".getBytes());
            System.out.println("写出成功");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
           // IOUtil.closeIO(null,outputStream);
        }

    }
    @Test
    public  void test03(){
        InputStream inputStream=null;
        OutputStream outputStream=null;
        try {
            inputStream=new FileInputStream("f:/ideal");
            outputStream=new FileOutputStream("f:/ideal");
            byte[]buf=new byte[3];
            int len;
            //循环读进来
            while((len=inputStream.read(buf))!=-1){
                //写出去
                outputStream.write(buf,0,len);
            }
            System.out.println("文件复制完毕");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //            IOUtil.closeIO(inputStream,outputStream)
            try {
                if(Objects.nonNull(outputStream)){
                    outputStream.close();
                    int i = 10/0;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            try {

package H0809;

import java.io.*;

public class Copyfile {
    public static void main(String[] args) throws IOException {
        InputStream inputStream=new FileInputStream("f:/ideal");
        OutputStream outputStream=new FileOutputStream("f:/ideal");
        byte[]buf=new byte[3];
        int len;
        while((len=inputStream.read(buf))!=-1){
            outputStream.write(buf,0,len);
        }
        System.out.println("文件复制完成");
    }
}

 

                if(Objects.nonNull(inputStream)){
                    inputStream.close();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

    }
}