IO流概述和分类、字节流写数据、字节流写数据加异常处理、字节流读数据、字节流复制文件、字节缓冲流、字节缓冲流复制视频

清疚 2023-10-07 20:59 79阅读 0赞

#### 文章目录 ####

*  字节流
 *   *  IO流概述和分类
     *  字节流写数据
     *  字节流写数据的三种方式
     *  字节流写数据的两个小问题
     *  字节流写数据加异常处理
     *  字节流读数据（一次读一个字节数据）
     *  字节流复制文件
     *  字节缓冲流
     *  字节缓冲流复制视频

## 字节流 ##

### IO流概述和分类 ###

*  IO流介绍
    
     *  IO:输入/输出（Input/Output）
     *  流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流。流的本质是数据传输
     *  IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
 *  IO流的分类
    
     *  按照数据的流向
        
         *  输入流：读数据
         *  输出流：写数据
     *  按照数据类型来分
        
         *  字节流
            
             *  字节输入流
             *  字节输出流
         *  字符流
            
             *  字符输入流
             *  字符输出流
 *  IO流的使用场景
    
     *  如果操作的是纯文本文件，优先使用字符流
     *  如果操作的是图片、视频、音频等二进制文件，优先使用字节流
     *  如果不确定文件类型.优先使用字节流。字节流是万能的流

### 字节流写数据 ###

*  字节流抽象基类
    
     *  InputStream:这个抽象类是表示字节输入流的所有类的超类
     *  OutputStream:这个抽象类是表示字节输出流的所有类的超类
     *  子类名特点：子类名称都是以其父类名作为子类名的后缀
 *  字节输出流
    
     *  FileOutputStream(String name):创建文件输出流以指定的名称写入文件
 *  使用字节输出流写数据的步骤
    
     *  创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
     *  调用字节输出流对象的写数据的方法
     *  释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）
 *  示例代码

package com.itheima.output;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo1 {
        
        public static void main(String[] args) throws IOException {
        
            //1.创建字节流对象---告诉虚拟机我要往哪个文件中写数据了
                            //注意点：如果文件不存在，会帮我们自动创建出来
                                   //如果文件存在，会把文件清空。
    //        FileOutputStream fos = new FileOutputStream("D:\\a.txt");
            FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));
    
            //2.写数据     传递一个整数时，那么实际上写到文件中的，是这个整数在码表中对应的那个字符
            fos.write(97);
    
            //3.释放资源
            fos.close();//告诉操作系统，我现在已经不用这个文件了.
        }
    }

### 字节流写数据的三种方式 ###

*  写数据的方法分类

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void write (int b)</td> 
   <td>将指定的字节写入此文件输出流，一次写一个数据</td> 
  </tr> 
  <tr> 
   <td>void write(byte[] b)</td> 
   <td>将 b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据</td> 
  </tr> 
  <tr> 
   <td>void write(byte[] b,int off,int len)</td> 
   <td>将 len 字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码

package com.itheima.output;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo2 {
        
        public static void main(String[] args) throws IOException {
        
            //一次写一个数据
            FileOutputStream fos = new FileOutputStream("a.txt");
            fos.write(97);
            fos.write(98);
            fos.write(99);
    
            fos.close();
        }
    }

package com.itheima.output;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo3 {
        
        public static void main(String[] args) throws IOException {
        
            //一次写一个字节数组数据
            FileOutputStream fos = new FileOutputStream("a.txt");
            byte[]bytes={
        97,98,99};
            fos.write(bytes);
            fos.close();
        }
    }

package com.itheima.output;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo4 {
        
        public static void main(String[] args) throws IOException {
        
            //一次写一个字节数组部分数据
            FileOutputStream fos = new FileOutputStream("a.txt");
    
            byte[] bytes={
        97,98,99,100};
            fos.write(bytes,0,3);//从 bytes 数组第一个位置写，一共写3个
            fos.close();
        }
    }

### 字节流写数据的两个小问题 ###

*  字节流写数据如何实现换行
    
     *  windows:\\r\\n
     *  linux:\\n
     *  mac:\\r
 *  字节流写数据如何实现追加写入
    
     *  public FileOutputStream(String name,boolean append)
     *  创建文件输出流以指定的名称写入文件，如果第二个参数为 true,则字节将写入文件的末尾而不是开头

package com.itheima.output;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo5 {
        
        public static void main(String[] args) throws IOException {
        
            //第二个参数就是续写开关，如果没有传递，默认就是false
            //表示不打开续写功能,那么创建对象的这行代码会清空文件
    
            //如果第二个参数为 true,表示打开续写功能
            //那么创建对象的这行代码就不会清空文件
            FileOutputStream fos = new FileOutputStream("a.txt",true);
            fos.write(97);
            fos.write("\r\n".getBytes());
            fos.write(98);
            fos.write("\r\n".getBytes());
            fos.write(99);
            fos.write("\r\n".getBytes());
            fos.write(100);
            fos.write("\r\n".getBytes());
            fos.write(101);
            fos.write("\r\n".getBytes());
            fos.write(102);
            fos.write("\r\n".getBytes());
    
    
        }
    }

### 字节流写数据加异常处理 ###

*  异常处理格式
    
     *  try-catch-finally  
        ![在这里插入图片描述][7373cd739eb74232856d6adca85182e6.png]
     *  finally特点
        
         *  被 finally控制的语句一定会执行，除非 JVM 退出
 *  示例代码

package com.itheima.output;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class OutputDemo6 {
        
        public static void main(String[] args) {
        
            FileOutputStream fos = null;
            try {
        
    //            System.out.println(2/0);
                 fos = new FileOutputStream("a.txt");
                fos.write(97);
            }catch(IOException e){
        
                e.printStackTrace();
            }finally{
        
                //finally 语句里边的代码，一定会被执行
                if(fos != null){
        
                    try {
        
                        fos.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

### 字节流读数据（一次读一个字节数据） ###

*  字节输入流
    
     *  FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名 name 命名
 *  字节输入流读取数据的步骤
    
     *  创建字节输入流对象
     *  调用字节输入流对象的读数据方法
     *  释放资源
 *  示例代码

package com.itheima.input;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class InputDemo1 {
        
        public static void main(String[] args) throws IOException {
        
            //如果文件存在，那么就不会报错
            //如果文件不存在，那么就直接报错
            FileInputStream fis = new FileInputStream("a.txt");
    
            int read = fis.read();
            //一次读取一个字节，返回值就是本次读到的那个字节数据
            //也就是字符在码表中对应的那个数字
            //如果我们想要看到的是字符数据，那么一定要强转为char
            System.out.println(read);
    
            fis.close();
        }
    }

package com.itheima.input;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class InputDemo2 {
        
        public static void main(String[] args) throws IOException {
        
            FileInputStream fis = new FileInputStream("a.txt");
    
    
            //1，文件中多个字节我怎么办？
    //        while(true){
        
    //            int i1 = fis.read();
    //            System.out.println(i1);
    //        }
            int b;
            while((b = fis.read())!= -1){
         //判断读取到的数据是否 为 -1
                System.out.print((char)b);
            }
            fis.close();
        }
    }

### 字节流复制文件 ###

*  案例需求  
    把 “D:\\itheima\\嘿嘿嘿.avi"复制到模块目录下的"嘿嘿嘿.avi”(文件可以是任意文件)
 *  实现步骤
    
     *  根据数据源创建字节输入流对象
     *  根据目的地创建字节输出流对象
     *  读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
     *  释放资源

package com.itheima.input;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class InputDemo4 {
        
        public static void main(String[] args) throws IOException {
        
            FileInputStream fis = new FileInputStream("D:\\itheima\\嘿嘿嘿.avi");
            FileOutputStream fos = new FileOutputStream("嘿嘿嘿.avi");
    
            byte[] bytes = new byte[1024];
            int len;//本次读到的有效字节个数 --- 这次读了几个字节
    
            while((len = fis.read(bytes))!= -1){
        
                fos.write(bytes,0,len);
            }
            fis.close();
            fos.close();
    
        }
    }

### 字节缓冲流 ###

*  字节缓冲流介绍
    
     *  IBufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流。应用程序可以向底层输出流写入字节。而不必为写入的每个字节导致底层系统的调用
     *  IBufferedInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
 *  构造方法：

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>BufferedOutputStream(OutputStream out)</td> 
   <td>创建字节缓冲输出流对象</td> 
  </tr> 
  <tr> 
   <td>BufferedInputStream(inputStream in)</td> 
   <td>创建字节缓冲输入流对象</td> 
  </tr> 
 </tbody> 
</table>

*  示例代码

package com.itheima.input;
    
    import java.io.*;
    
    public class InputDemo5 {
        
        public static void main(String[] args) throws IOException {
        
            //就要利用缓冲流去拷贝文件
    
            //创建一个字节缓冲输入流
            //在底层创建了一个默认长度为8192的字节数组
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("嘿嘿嘿.avi"));
    
            //创建一个字节缓冲输出流
            //在底层创建了一个默认长度为8192的字节数组
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
    
            int b;
            while((b = bis.read())!= -1){
        
                bos.write(b);
            }
            //方法的底层会把字节流给关闭。
            bis.close();
            bos.close();
        }
    }

### 字节缓冲流复制视频 ###

*  案例需求  
    把"D:\\itheima\\嘿嘿嘿.avi"复制到模块目录下的"嘿嘿嘿.avi中"
 *  实现步骤
    
     *  根据数据源创建字节输入流对象
     *  根据目的地创建字节输出流对象
     *  读写数据，复制视频
     *  释放资源

package com.itheima.input;
    
    import java.io.*;
    
    public class InputDemo6 {
        
        public static void main(String[] args) throws IOException {
        
            //缓冲流结合数组，进行文件拷贝
    
            //创建一个字节缓冲输入流
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("嘿嘿嘿.avi"));
    
            //创建一个字节缓冲输出流
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
    
            byte[] bytes = new byte[1024];
            int len;
            while((len= bis.read(bytes))!= -1){
        
                bos.write(bytes,0,len);
            }
            bis.close();
            bos.close();
        }
    }

[7373cd739eb74232856d6adca85182e6.png]: https://img-blog.csdnimg.cn/7373cd739eb74232856d6adca85182e6.png