IO流之读写,复制详解

IO流的复制问题无非就是读写问题,复制字节流文件或字符流文件有不同的方法,在这里简单详细介绍一下

先了解一下io流的常用方法:
一.字节输入流InputStream 常用方法
1.int read() 读取一个字节,并将它返回,如果遇到源的末尾,则返回-1
2.int read(byte[] b) 最多读取b.length个字节放在byte数组中,并返回字节数,如果遇到源的末尾,则返回-1
3.int read (byte[] b,int off,int len) 最多len个数据字节读入byte数组.将读取的第一个字节存储在元素b[off]中,下一个存储在b[off+1]中,一次类推,读入的总字节数,如果因为已到达流末尾而不再有数据可用,则返回-1
4.void close() 用于关闭该流,在使用完流以后,一顶要记得使用此方法将流关闭,释放流所占用的资源
5.int available() 用于返回在不发生阻塞情况下,该流可以读取的字节数

二.字节输出流OutputStream
1.void write(int c) 写一个字节到流中
2.void wrire(byte[] b) 将b.length个字节从指定的byte数组写入此输出流
3.void write(byte[] b,int off,int len) 将指定byte数组中从偏移量off开始的len个字节写入此输出流
4.void close() 关闭输出流
5.void flush() 将缓冲中的字节立即发送到流中,同时清空缓冲

三.字符输出流 Reader
1.int read() 读取单个字符,并返回他的整数值,如果遇到源的末尾,则返回-1
2.int read(char[] cbuf) 最多读取cbuf.length个字符放在char数组中,并返回字符数,如果遇到源的末尾,则返回-1
3.int read(char[] cbuf,int off,int len) 最多len个数据字符读入char数组.将读取的第一个字符存储在元素cbuf[off]中,下一个存储在cbuf[off+1]中,依次类推,读入的总字符数.如果因为已到达流末尾,则返回-1
4.void close() 用于关闭该流,在使用完流以后,一定要记得使用次方法将流关闭,释放流所占用的资源

四.字符输出流 Writer
1.void write(int c) 写一个字符到流中
2.void write(char[] cbuf) 将cbuf.length个字符从指定的char数组写入此输出流
3.void write(char[] cbuf,int off,int len) 将指定char数组中从偏移量off开始的len个字符写入此输出流
4.void write(String str) 写入字符串
5.void write(String str,int off,int len) 写入字符串的某一部分
6.void close() 关闭输出流
7.void flush() 将缓冲中的字符立即发送到流中,同时清空缓冲

五.缓冲
//缓冲功能, 好处:1.效率高 2.节省电脑硬件(主要是硬盘)
//BufferedReader 对字符输入流 提供缓冲功能
//BufferedWriter 对字符输出流 提供缓冲功能
//BufferedInputStream 对字节防输入流 提供缓冲功能
//BufferedOutoutStream 对字节输出流 提供缓冲功能

---

先来说一下字符的读写追加代码如下
一.追加字符串到指定文件中

 @SuppressWarnings("resource")
 public static void main(String[] args) throws IOException {
 FileWriter fileWriter = new FileWriter("D:\\DG\\1611A.txt",true);//添加出是追加的意思
  fileWriter.write("hello world");
  fileWriter.write("shanghaibawei"); 
  fileWriter.flush();
  fileWriter.close();
  
  从指定文件中读取
  FileReader fileReader = new FileReader("D:\\DG\\1611A.txt");
  int m = fileReader.read();//读取一个字节,并将它返回,如果遇到源的末尾,则返回-1
  //System.out.println((char)m);//只读取一个字符,将int类型转为字符型

 循环读取所有
 int m1=0;
  while((m1=fileReader.read())!=-1){//读取不等与-1 就会一直读取
   System.out.print((char)m1);
  }

   //一次读取多个字符
  char[] ch = new char[10];//1k-1M之间
  fileReader.read(ch);
 System.out.print(ch);

int m2=0;
  while((m2=fileReader.read(ch))!=-1){
   System.out.println(new String(ch,0,m2));
  }
  fileReader.close();//关闭流

字符类文件  所以要用char型数组
将指定文件夹下的文件赋值到另一个文件夹中
 @SuppressWarnings("resource")
 public static void main(String[] args) throws IOException {
 //读
  FileReader fileReader = new FileReader("D:\\DG\\1611A.txt");
//写
FileWriter fileWriter = new FileWriter("D:\\DG\\ge\\1611B.txt");
char[] cbuf =  new char[1024];//定义一个char型数组 
int m=0;//定义m个数据字节 默认为0

//void write(char[] cbuf,int off,int len) 将指定char数组中从偏移量off开始的len个字符写入此输出流
while((m=fileReader.read(cbuf))!=-1){
       fileWriter.write(cbuf, 0, m);
      }
      fileWriter.flush();
      fileWriter.close();
      fileReader.close();

复制指定文件夹下的图片 属于字节类文件 用byte型数组 图片,音频,视频属于字节
    //FileInputStream 字节型输入流
    //FileOutputStream 字节型 输出流
  @SuppressWarnings("resource")
 public static void main(String[] args) throws IOException {
    FileInputStream fi = new FileInputStream("D:\\DG\\b.png"); 
     FileOutputStream fo = new FileOutputStream("D:\\DG\\b复制.png");
     
    byte[] b = new byte[1024];
     int m=0;
     while((m=fi.read(b))!=-1){
      fo.write(b, 0, m);
     }
     fo.flush();
      fo.close();
      fi.close();

缓冲流的应用

     //缓冲功能, 好处:1.效率高 2.节省电脑硬件(主要是硬盘)
     //对之前的四个类 提供缓冲功能 
     //BufferedReader  对字符输入流 提供缓冲功能
     //BufferedWriter  对字符输出流 提供缓冲功能
     //BufferedInputStream  对字节防输入流 提供缓冲功能
     //BufferedOutoutStream 对字节输出流  提供缓冲功能
 
  @SuppressWarnings("resource")
 public static void main(String[] args) throws IOException {
 //字符输入缓冲流
      BufferedReader br = new BufferedReader(new FileReader("D:\\DG\\1611A.txt"));
      //字符输出缓冲流
      BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\DG\\1611C.txt"));
//      char[] cbuf = new char[1024];
//      int m=0;
//      while((m=br.read(cbuf))!=-1){
//       System.out.println(new String(cbuf,0,m));//可以直接读
//       bw.write(cbuf, 0, m);
//      }

 String s="";
      //缓冲流br.readLine()//每次可以读取一行
      while((s=br.readLine())!=null){
       bw.write(s);
       bw.newLine();//换行
      }
     bw.flush();
      bw.close();
      br.close();

根据以上例子接下来复制视频有无缓冲时间差

 public static void main(String[] args) throws IOException {
  copy();
     copy2();
     }
     
     //无缓冲
    @SuppressWarnings("resource")
 public static void copy() throws IOException{
long m1 = System.currentTimeMillis();
      System.out.println("开始运行时间:"+m1);
       FileInputStream fi = new FileInputStream("D:/DG/a.mp4");
      FileOutputStream fo = new FileOutputStream("D:\\DG\\a复制.mp4");
       byte[] b= new byte[1024];
      int m=0;
      while((m=fi.read(b))!=-1){
       fo.write(b,0,m);
      }
     fo.flush();
      fo.close();
      fi.close();
       long m2 = System.currentTimeMillis();
      System.out.println("结束运行时间:"+m2);
      System.out.println("程序运行时间:"+(m2-m1));
      }


//有缓冲
 @SuppressWarnings("resource")
 public static void copy2() throws IOException{
 long m3 = System.currentTimeMillis();
      System.out.println("开始运行时间:"+m3);
             BufferedInputStream bm = new BufferedInputStream(new FileInputStream("D:\\DG\\a.mp4"));
       BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\DG\\a.复制2.mp4"));
 byte[] b = new byte[1024];
       int m=0;
       while((m=bm.read(b))!=-1){
        bo.write(b, 0, m);
       }
      bo.flush();
       bo.close();
       bm.close();
long m4 = System.currentTimeMillis();
       System.out.println("结束运行时间:"+m4);
       System.out.println("程序运行时间:"+(m4-m3));