JavaSE（2）15 IO流

IO流

IO流概述和分类

IO流介绍

• IO:输入/输出（Input/Output）
• 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据的传输
• IO流：用来处理设备间数据的传输问题。常见的应用：文件复制；文件上传，文件下载

IO流分类

• 按数据的流向：
  • 输入流：读数据
  • 输出流：写数据
• 按照数据类型：
  • 字节流 字节输入流 字节输出流
  • 字符流 字符输入流 字符输出流

IO流的使用场景

• 如果操作的是纯文本文件，优先使用字符流
• 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
• 如果不确定文件类型，优先使用字节流。字节流是万能的流

字节流

字节流写数据

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

//文件输出流用于将数据写入到file
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        OutputStream outputStream=new FileOutputStream("JavaSE\\phx.txt");
        /* 做了三件事情
             调用系统功能创建了文件；
             创建了字节输出流对象
             让字节输出流对象指向了创建好的文件
         */
        //将指定的字节写入此文件输出流
        outputStream.write(97);
        //最后释放资源
        outputStream.close();
    }

字节流写数据的三种方式

//字节流写数据的三种方式
    public static void main(String[] args) throws IOException {
        OutputStream outputStream=new FileOutputStream(new File("BasicGrammar\\phx.txt"));
        //方式一：
        outputStream.write(97);
        outputStream.write(98);
        outputStream.write(99);
        outputStream.write(100);
        //方式二：
        String s="Hello World";
        byte[] bytes = s.getBytes();
        outputStream.write(bytes);
        //方式三
        outputStream.write(bytes,1,3);
        //释放资源
        outputStream.close();
    }

字节流写数据小问题

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

字节流写数据加异常处理

try{
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作;
}

• 被finally控制的语句一定会执行，除非JVM退出

字节流读数据(一次读一个字节数据)

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

 public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        // FileInputStream(String name)
        InputStream ips=new FileInputStream("BasicGrammar\\phx.txt");
        /*
        ips.read()：读数据
        by=ips.read()：把读取到的数据赋值给by
        by != -1：判断读取到的数据是否是-1
        */
        int by;
        while((by=ips.read())!=-1) {
            System.out.print((char) by);
        }
        //释放资源
        ips.close();
    }

字节流复制文本文件

 //字节流复制文本文件
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        InputStream inputStream=new FileInputStream("BasicGrammar\\phx.txt");
        //根据目的地创建字节输出流对象
        OutputStream outputStream=new FileOutputStream("BasicGrammar\\phx2.txt");
        int by;
        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        while ((by=inputStream.read())!=-1){
            outputStream.write((char)by);
        }
        //释放资源
        inputStream.close();
        outputStream.close();
    }

字节流读数据(一次读一个字节数组数据)

 //字节流读数据(一次读一个字节数组数据)
    public static void main(String[] args) throws IOException {
        InputStream inputStream=new FileInputStream("BasicGrammar"+ File.separatorChar+"phx.txt");
        byte[] bytes=new byte[1024];//1024及其整数倍
        //实际读取的数据的个数
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            System.out.print(new String(bytes,0,len));
        }
        //释放资源
        inputStream.close();
    }

字节流复制图片

 //字节流复制图片
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream=new FileInputStream("F:\\phx.png");
        FileOutputStream fileOutputStream=new FileOutputStream("BasicGrammar\\phx.png");
        //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bytes=new byte[1024];
        int len;
        while((len=fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }
        //释放资源
        fileInputStream.close();
        fileOutputStream.close();
    }

字节缓冲流

字节缓冲流构造方法

• 字节缓冲流介绍
  • lBufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。
  • lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内存缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节。
  • 构造方法
    
• 为什么构造方法中需要的是字节流而不是具体的文件或路径呢？
  字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

//字节缓冲流构造方法
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("BasicGrammar\\phx.txt"));
        //写数据
        bos.write("Hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("BasicGrammar\\phx.txt"));
        //一次读取一个字节数据
        // int by;
        // while ((by=bis.read())!=-1) {
        // System.out.print((char)by);
        // }
        //一次读取一个字节数组数据
        byte[]bytes=new byte[1024];
        int len;
        while((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        //释放资源
        bis.close();
    }

字节流复制视频

//字节流复制视频
    public static void main(String[] args) throws IOException {
        Long startTime=System.currentTimeMillis();
        //method4();// 字节缓冲流一次读一个字节数组: 一共耗时4ms
       method3();//字节缓冲流一次读一个字节: 一共耗时35ms
        //method2();//基本字节流一次读一个字字节数组:一共耗时9ms
        //method1();//基本字节流一次读一个字节: 一共耗时4621ms
        Long endTime=System.currentTimeMillis();
        System.out.println("一共耗时"+(endTime-startTime)+"ms");

    }
    //字节缓冲流一次读一个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("F://123.avi"));
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("F://abc.avi"));
        byte[] bytes=new byte[1024];
        int len;
        while((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
    //字节缓冲流一次读一个字节
    public static void method3() throws IOException {
        BufferedInputStream bufferedInputStream=new BufferedInputStream(new FileInputStream("F://123.avi"));
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream("F://abc.avi"));
        int by;
        while((by=bufferedInputStream.read())!=-1){
            bufferedOutputStream.write((char)by);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
    //基本字节流一次读一个字字节数组
    public static void method2() throws IOException{
        FileInputStream fileInputStream = new FileInputStream("F://123.avi");
        FileOutputStream fileOutputStream=new FileOutputStream("F://efg.avi");
        byte[] bytes=new byte[1024];
        int len;
        while((len=fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
    //基本字节流一次读一个字节
    public static void method1() throws IOException{
        FileInputStream fileInputStream = new FileInputStream("F://123.avi");
        FileOutputStream fileOutputStream=new FileOutputStream("F://efg.avi");
        int by;
        while((by=fileInputStream.read())!=-1){
            fileOutputStream.write((char)by);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }