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();//告诉操作系统，我现在已经不用这个文件了.
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字节流写数据的三种方式

• 写数据的方法分类

• 示例代码

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

• 字节流写数据如何实现换行
  • 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());


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

字节流写数据加异常处理

• 异常处理格式

  • try-catch-finally
    

  • 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();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

• 字节输入流

  • 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字节流复制文件

• 案例需求
  把 “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();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

字节缓冲流

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

• 示例代码

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

字节缓冲流复制视频

• 案例需求
  把"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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23