IO流浅析一

IO流—是模型也是工具

万物皆字节---万物信息流皆是字节的规则排列---破解信息流的排列规则---进行信息的传递和重排列。
完成了信息的传输。
IO流---进行信息传输的基本操作工具。IO流实现了数据从硬件到信息的传输---硬盘内存到文件信息的互相传输。

管道模型

理解IO流前我们先来讨论一下管道运输流模型。
	管道---运输的渠道
	管道连接的源---设备
	管道运输过程中的分流、存储---风险控制/效率设备
IO流可以理解为信息世界的管道系统。不同的设备硬件、内存、文件等理解为源。缓冲区等就是信息世界抗风险和提高运输效率的设备。

IO流向分类

根据管道的运输的性质，IO流的传输都是基于输入和输出来展开的。
输入流：将信息input到源中
输出流：将信息output出源。（这里的源我们可以理解为Java中用来存放信息的地方---内存）
即输入到程序运行的内存---输入流
  从程序运行的内存输出---输出流

IO流操作单元分类

按照操作的单元，可以将IO流分为字节流和字符流。
字节流：byte
InputStream—输入流，将信息从文件写入内存
OutputStream—输出流，将信息从内存写入文件
字符流：char
Write—输出流写出内存
Reader—输入流写入内存

IO流的操作分类

https://blog.csdn.net/czz1141979570/article/details/80098194

常用IO流的用法

IO体系的基类
	输入流：InputStream/Reader---内存去读
		所有输入流的抽象基类，不能创建实例，但是所有的输入流都可以使用其方法
	输出流：OutputStream/Writer---内存去写
		所有输出流的抽象基类，不能创建实例，但是所有的输出流都可以使用其方法

字节流输入流

InputStream s = new InputStream() {
    
    //字节输入流是一个抽象类 不能直接创建实例 可以通过匿名内部类的写法
  @Override
  public int read() throws IOException {
    
    //重写父类的方法
   // TODO Auto-generated method stub
   return 0;
  }
 };
 byte[] b = new byte[5];//
 int off=0;
 int len=b.length;
 s.read();//字节输入流
 s.read(b);
 s.read(b, off, len);

字符流输入流

//字符流
  Reader r = new Reader() {
    
    
   //
   @Override
   public int read(char[] cbuf, int off, int len) throws IOException {
    
    
    // TODO Auto-generated method stub
    return 0;
   }
   //
   @Override
   public void close() throws IOException {
    
    
    // TODO Auto-generated method stub
    
   }
  };

IO流中的文件基类的使用

文件输入流---FileInputStream----class FileInputStream extends InputStream注意以下的类是继承该基本的抽象类的实现类
	    FileReader
文件输出流---FileOutputStream
	    FileWriter			
流只能用来传输，不能用来源的打开，文件流基于父类的可以直接使用的文件流的实现类。
流在使用结束后要关流---管道使用结束后要关闭一样。

文件传输的固定写----其他流类似----但是注意输出流一般要搭配输入流

class MyClass {
    
    
  public  static void main(String[] args)throws IOException{
    
    
      FileInputStream fis=null;
      try {
    
    
          //创建字节输入流
          fis=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
          //创建一个长度为1024的竹筒
          byte[] b=new byte[1024];
          //用于保存的实际字节数
          int hasRead=0;
          //使用循环来重复取水的过程
          while((hasRead=fis.read(b))>0){
    
    
              //取出竹筒中的水滴（字节），将字节数组转换成字符串进行输出
            System.out.print(new String(b,0,hasRead));
          }
      }catch (IOException e){
    
    
        e.printStackTrace();
      }finally {
    
    
          fis.close();
      }
  }
}

缓冲流

缓冲流就像是管道在运输过程中由于管道过长或运输物品过多而创建的缓冲区域，以提高运输的效率和安全性。
缓冲区是在内存中进行的提高流畅性。
输入时的缓冲流---BufferedInputStream/BufferedReader
输出时的缓冲流---BufferedOutputStream/BufferedWriter

class BufferedStreamTest {
    
    
    public  static void main(String[] args)throws IOException {
    
    
        FileInputStream fis=null;
        FileOutputStream fos=null;
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
    
    
            //创建字节输入流
            fis=new FileInputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\Test.txt");
            //创建字节输出流
            fos=new FileOutputStream("E:\\learnproject\\Iotest\\lib\\src\\main\\java\\com\\newTest.txt");
            //创建字节缓存输入流
            bis=new BufferedInputStream(fis);
            //创建字节缓存输出流
            bos=new BufferedOutputStream(fos);
            byte[] b=new byte[1024];
            int hasRead=0;
            //循环从缓存流中读取数据
            while((hasRead=bis.read(b))>0){
    
    
                //向缓存流中写入数据，读取多少写入多少
                bos.write(b,0,hasRead);
            }
        }catch (IOException e){
    
    
            e.printStackTrace();
        }finally {
    
    
            bis.close();
            bos.close();
        }
    }
}

NIO

IO流的底层传输规则是基于万物皆字节的基础上进行的，底层在执行的过程中，都是以字节的方式进行的。
在这个过程中，容易出现阻塞的情况。
NIO利用内存访问映射的机制进行，将文件进行映射，像访问内存一样访问文件。提高了速度。