文章目录

1.数据源
2.流
3.IO流的分类
4.字节流
- 4.1文件字节输入流
- - 1. FileInputStream类概述
  - 2. FileInputStream类构造方法
  - 3. FileInputStream类常用方法
- 4.2文件字节输出流
- - 1. FileOutputStream类概述
  - 2. FileOutputStream类构造方法
  - 3. FileOutputStream类常用方法
5字符流
- 5.1. FileWriter类
- - 1. FileWriter类概述
  - 2. FileWriter类构造方法
  - 3. FileWriter类常用方法
- 5.2. FileReader类
- - 1. FileReader类概述
  - 2. FileReader类构造方法
  - 3. FileReader类常用方法
6.缓冲流
- 6.1. 字节缓冲流
- - 1. 字节缓冲输出流对象BufferedOutputStream
  - - 1. 字节缓冲输出流对象BufferedOutputStream构造方法
    - 2. 字节缓冲输出流对象BufferedOutputStream常用方法
  - 2. 字节缓冲输入流对象BufferedInputStream
  - - 1. 字节缓冲输入流对象BufferedInputStream构造方法
    - 2. 字节缓冲输入流对象BufferedInputStream常用方法
- 6.2. 字符缓冲流
- - 1. 字符缓冲输出流对象BufferedWriter
  - - 1. 字符缓冲输出流对象BufferedWriter构造方法
    - 2. 字符缓冲输出流对象BufferedWriter常用方法
  - 2. 字符缓冲输入流对象BufferedReader
  - - 1. 字符缓冲输入流对象BufferedReader构造方法
    - 2. 字符缓冲输入流对象BufferedReader常用方法

1.数据源

数据源：提供数据的原始媒介。
数据源分为：源设备、目标设备。
源设备：为程序提供数据，一般对应输入流。
目标设备：程序数据的目的地，一般对应输出流

2.流

数据源就像水箱，流(stream)就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象、动态的概念，是一连串连续动态的数据集合。
在这里插入图片描述

当程序需要读取数据源的数据时，就会通过IO流对象开启一个通向数据源的流，通过这个IO流对象相关方法可以顺序读取流中的数据。

3.IO流的分类

输入(Input)指的是：将外部(硬盘、数据库、浏览器等)数据写入到程序中（核心含义是“读”，读取外部数据）。
输出(Output)指的是：将程序中的数据写出到外界（核心含义是“写”，将数据写出到外部系统）。
1、按流的方向分类
输入流：数据流向是数据源到程序(InputStream、Reader结尾的流)
输出流：数据流向是程序到目的地(OutPutStream、Writer结尾的流)
2、按处理的数据单元分类
字节流：按照字节读取数据(InputStream、OutputStream)，命名上以stream结尾的流一般是字节流。
字符流：按照字符读取数据(Reader、Writer)，命名上以Reader/Writer结尾的流一般是字符流。
3、按处理对象不同分类
节点流（普通流）：可以直接从数据源或目的地读写数据。
处理流（包装流）：不直接连接到数据源或目的地，是“处理流的流”。通过对其它流进行封装，目的主要是简化操作和提高程序的性能。
节点流处于IO操作的第一线，所有操作必须通过他们进行；处理流可以对节点流进行包装，提高性能或提高程序的灵活性。
在这里插入图片描述

4.字节流

字节流是以字节(二进制数据)方式读写数据,主要用于操作二进制数据，Java中字节流对象分为两种:字节输入流对象InputStream,字节输出流对象OutputStream,这两个是抽象类所以无法直接创建对象,需要使用其子孙类创建：
字节输入流对象InputStream子类FileInputStream
字节输出流对象OutputStream子类FileOutputStream
字节流是万能流,他可以读取计算机中的任意类型文件或程序或音频视频等等。

4.1文件字节输入流

1. FileInputStream类概述

FileInputStream类是InputStream的子类,实现类父类中所有的方法,方法与父类也是相同的,主要用于数据的读取
FileInputStream类是节点流(普通流),是操作文件数据的基本流

2. FileInputStream类构造方法

public FileInputStream(String name):创建对象并指定文件位置
1. name:String类型指定文件位置
public FileInputStream(File file):创建对象并指定文件位置
1. file:File类型指定文件位置

3. FileInputStream类常用方法

public abstract int read():读取数据到Java应用程序,一次读取一个字节数据
public int read(byte b[]):读取数据到Java应用程序,一次读取一个字节数组数据
public int read(byte b[], int off, int len):读取数据到Java应用程序,一次读取一个字节数组数据,并指定数据的起始位置以及数据长度
public int available():读取数据的总长度(总字节数)
public void close():关闭输入流并释放资源

4.2文件字节输出流

1. FileOutputStream类概述

FileOutputStream类是OutputStream的子类,实现类父类中所有的方法,方法与父类也是相同的,主要用于数据的写出
FileOutputStream类是节点流(普通流),是操作文件数据的基本流

2. FileOutputStream类构造方法

public FileOutputStream(String name):创建对象并指定文件输出的位置
1. name:String类型指定文件位置
public FileOutputStream(String name, boolean append):创建对象并指定文件输出的位置,以及是否为追加文本
1. name:String类型指定文件位置
2. append:true为追加文本,false为不追加文本(默认为false)
public FileOutputStream(File file):创建对象并指定文件输出的位置
1. file:File类型指定文件位置
2. append:true为追加文本,false为不追加文本(默认为false)
public FileOutputStream(File file, boolean append):创建对象并指定文件输出的位置,以及是否为追加文本
1. file:File类型指定文件位置
2. append:true为追加文本,false为不追加文本(默认为false)

3. FileOutputStream类常用方法

public abstract void write(int b):从Java应用程序写出数据到文件,一次写出一个字节数据
public void write(byte b[]):从Java应用程序写出数据到文件,一次写出一个字节数组数据
public void write(byte b[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字节数组数据,并指定数据的起始位置以及数据长度
public void flush():强制刷新流数据,将还在数据流中的数据强制写出
public void close():关闭输出流并释放资源

    public static void main(String[] args) {
        //1.定义源文件
        String sourcePath = "text.txt";
		//2.定义目的地
        String targetPath = "src/Demo.txt";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //图片的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Pictures\\Saved Pictures\\9.jpg";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/img/demo.gif";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //视频的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Videos\\MgtvVideos\\Myvedio\\FamilyTime.mp4";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/video/demo.avi";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //软件的绝对路径
        sourcePath = "D:\\软件\\Install Termius.exe";
        // 2. 定义目的地
        // 拷贝的相对路径
        targetPath = "src/soft/Install Termius.exe";
        copyFile(sourcePath,targetPath);
    }
    private static void copyFile(String sourcePath, String targetPath){
        // 使用JDK1.7新特性try...with...resource
        try(
               //1.字节输入流对象
               InputStream fis = new FileInputStream(sourcePath);
               //2.字节输出流对象
               OutputStream fos = new FileOutputStream(targetPath);
       ){
           //3.定义一个接收数据的字节数组
           byte[] bytes = new byte[1024];
           //4.声明length属性，用于接收读取数据的长度
           int length;
           //5.循环读取字节数据
           while((length=fis.read(bytes)) != -1){
               //6.循环写出数据
               fos.write(bytes,0,length);
               //7.强制刷新流数据
               fos.flush();
           }
       }catch (Exception e){
           e.printStackTrace();
       }
    }
   /**
     * 拷贝文件步骤
     * // 1. 字节输入流对象
     * // 2. 字节输出流对象
     * // 3. 定义byte数组,用于接收读取的数据
     * // 4. 声明length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环写出数据
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     */

5字符流

字符流是以字符方式读写数据,主要操作文字,文字并不是单指汉子,包括所有国家文字
Java中字符流对象分为两种:字符输入流对象Reader,字符输出流对象Writer,这两个是抽象类所以无法直接创建对象,需要使用其子孙类创建
字符输入流对象Reader子类FileReader
字符输出流对象Writer子类FileWriter
字符流只能读写使用文本文档打开后可以看的懂得文件,如果文本文档打开是乱码的则无法读写

5.1. FileWriter类

1. FileWriter类概述

FileWriter类是OutputStreamWriter的子类是Writer类的孙子,所有的方法全都来自于OutputStreamWriter类,方法与父类也是相同的,主要用于数据的写出
FileWriter类是节点流(普通流),是操作文件数据的基本流

2. FileWriter类构造方法

public FileWriter(String fileName):创建对象并指定文件输出的位置
public FileWriter(String fileName, boolean append):创建对象并指定文件输出的位置,以及是否为追加内容
public FileWriter(File file):创建对象并指定文件输出的位置
public FileWriter(File file, boolean append):创建对象并指定文件输出的位置,以及是否为追加内容

3. FileWriter类常用方法

public void write(int c):从Java应用程序写出数据到文件,一次写出一个字符数据
public void write(char cbuf[]):从Java应用程序写出数据到文件,一次写出一个字符数组数据
abstract public void write(char cbuf[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字符数组数据,并指定数据起始位置和数据长度
public void write(String str):从Java应用程序写出数据到文件,一次写出一个字符串数据
public void write(String str, int off, int len):从Java应用程序写出数据到文件,一次写出一个字符串数据,并指定数据起始位置和数据长度
public void flush():强制刷新流数据,将还在数据流中的数据强制写出
public void close():关闭输出流并释放资源

5.2. FileReader类

1. FileReader类概述

FileReader类是InputStreamReader的子类是Reader类的孙子,所有的方法全都来自于InputStreamReader类,方法与父类也是相同的,主要用于数据的写出
FileReader类是节点流(普通流),是操作文件数据的基本流

2. FileReader类构造方法

public FileReader(String fileName):创建对象并指定文件位置
public FileReader(File file):创建对象并指定文件位置

3. FileReader类常用方法

public int read():读取数据到Java应用程序,一次读取一个字符数据
public int read(char cbuf[]):读取数据到Java应用程序,一次读取一个字符数组数据
abstract public int read(char cbuf[], int off, int len):读取数据到Java应用程序,一次读取一个字符数组数据,并指定数据起始位置和数据长度
abstract public void close():关闭输入流对象释放资源

   public static void main(String[] args) {
        //1.定义源文件
        String sourcePath = "text.txt";
        //2.定义目的地
        String targetPath = "src/Demo.txt";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //图片的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Pictures\\Saved Pictures\\8.jpg";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/img/demo2.jpg";
//        copyFile(sourcePath,targetPath);
        //1.定义源文件
        //视频的绝对路径
        sourcePath = "C:\\Users\\huashuo\\Videos\\MgtvVideos\\Myvedio\\FamilyTime.mp4";
        //2.定义目的地
        //拷贝的相对路径
        targetPath = "src/video/demo2.avi";
        copyFile(sourcePath,targetPath);

    }
    /**
     * 拷贝文件步骤
     * // 1. 字符输入流对象
     * // 2. 字符输出流对象
     * // 3. 定义char数组,用于接收读取的数据
     * // 4. 声明Length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环将读取的数据写出到文件
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     * 因为图片和视频是二进制数据传输的，拷贝时用的是字符拷贝，会对源数据造成损毁无法正常展示。
     */
    private static void copyFile(String sourcePath, String targetPath){
        // 使用JDK1.7新特性try...with...resource
        try(
               //1.创建源文件输入流对象
               Reader fr = new FileReader(sourcePath);
               //2.创建目的地输出流对象
               Writer fw = new FileWriter(targetPath)
        ){
            //3.创建一个接收数据的字符数组
            char[] chars = new char[1024];
            //4.创建length变量，声明接收的数据长度
            int length;
            //5.循环遍历数据
            while((length = fr.read(chars)) != -1){
                //6.将每次遍历读取到chars中的数据输出到目的地
                fw.write(chars,0,length);
                //7.强制刷新流数据
                fw.flush();
            }
            //8.释放资源使用JDK1.7新特性try...with...resource自动释放资源
        }catch (IOException e){
            e.printStackTrace();
        }
    }

6.缓冲流

缓冲流属于处理流(包装流),主要作用是用于包装节点流(普通流)对象,可以包装的由字节流和字符流,包装后可以提升读写的效率
缓冲流原理:缓冲流是将读取的数据线存放在内存,当读取的数据存满时再从内存写出到文件或读取到程序
缓冲流分为两类:1. 字节缓冲流,2. 字符缓冲流,提升字节流与字符流的读写效率

6.1. 字节缓冲流

字节缓冲流用于包装字节流对象,提升字节流读写速度
字节缓冲输入流对象BufferedInputStream
字节缓冲输出流对象BufferedOutputStream

1. 字节缓冲输出流对象BufferedOutputStream

1. 字节缓冲输出流对象BufferedOutputStream构造方法

public BufferedOutputStream(OutputStream out):创建对象并指定字节输出流对象
public BufferedOutputStream(OutputStream out, int size):创建对象并指定字节输出流对象,并指定缓冲区大小

2. 字节缓冲输出流对象BufferedOutputStream常用方法

public synchronized void write(byte b[], int off, int len):从Java应用程序写出数据到文件,一次写出一个字节数组数据,并指定数据起始位置和数据长度
public void flush():强制刷新流数据,将还在数据流中的数据强制写出
public void close():关闭输出流并释放资源

2. 字节缓冲输入流对象BufferedInputStream

1. 字节缓冲输入流对象BufferedInputStream构造方法

public BufferedInputStream(InputStream in):创建对象并指定字节输入流对象
public BufferedInputStream(InputStream in, int size):创建对象并指定字节输入流对象,以及缓冲区大小

2. 字节缓冲输入流对象BufferedInputStream常用方法

public int read(byte b[]):读取数据到Java应用程序,一次读取一个字节数组数据
public int available():获取数据的长度
public void close():关闭输入流释放资源

  public static void main(String[] args) {
        // 1. 源文件位置
        String sourcePath = "D:/ideaIUPortable.zip";
        // 2. 目的地位置
        String targetPath = "src/ideaIUPortable.zip";
        // 3. 拷贝文件方法
        copyFile(sourcePath, targetPath);
    }

    /**
     * 缓冲流拷贝流程
     * // 1. 创建字节流对象
     * // 2. 创建缓冲流对象
     * // 3. 定义byte数组,用于接收读取的数据
     * // 4. 声明length属性,用于接收读取数据的长度
     * // 5. while循环读取数据
     * // 6. 循环读取的数据写出到文件
     * // 7. 强制刷新流数据
     * // 8. 释放资源
     */
    private static void copyFile(String sourcePath, String targetPath) {
        // 使用JDK1.7try...with...resource
        try (
                // 1. 创建字节流对象
                InputStream is = new FileInputStream(sourcePath);
                OutputStream os = new FileOutputStream(targetPath);
                // 2. 创建缓冲流对象
                BufferedInputStream bis = new BufferedInputStream(is);
                BufferedOutputStream bos = new BufferedOutputStream(os)
        ) {
            // 3. 定义byte数组,用于接收读取的数据
            byte[] bytes = new byte[1024 * 1024];
            // 4. 声明length属性,用于接收读取数据的长度
            int length;
            // 记录拷贝起始时间
            long start = System.currentTimeMillis();
            // 5. while循环读取数据
            while ((length = bis.read(bytes)) != -1) {
                // 6. 循环读取的数据写出到文件
                bos.write(bytes, 0, length);
                // 7. 强制刷新流数据
                bos.flush();
            }
            // 记录拷贝结束时间
            long end = System.currentTimeMillis();
            // 计算耗时
            System.out.println("拷贝耗时:" + (end - start));
            // 8. 释放资源使用JDK1.7try...with...resource自动释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

6.2. 字符缓冲流

字符缓冲流用于包装字符流对象,提升字符流读写速度
字符缓冲输入流对象BufferedReader
字符缓冲输出流对象BufferedWriter

1. 字符缓冲输出流对象BufferedWriter

1. 字符缓冲输出流对象BufferedWriter构造方法

public BufferedWriter(Writer out):创建对象并指定字符输出流对象
public BufferedWriter(Writer out, int sz):创建对象并指定字符输出流对象以及缓冲区大小

2. 字符缓冲输出流对象BufferedWriter常用方法

public void write(String str):从Java应用程序写出数据到文件,一次写出一个字符串的数据
public void newLine():新行,输出一个换行符(由于Windows,Linux,macOS系统的换行符不一样所以如果手写换行符则可能会出现在其他系统中失效的问题)
public void flush():强制刷新流数据
public void close():关闭输出流并释放资源

2. 字符缓冲输入流对象BufferedReader

1. 字符缓冲输入流对象BufferedReader构造方法

public BufferedReader(Reader in):创建对象并指定字符输入流对象
public BufferedReader(Reader in, int sz):创建对象并指定字符输入流对象以及缓冲区大小

2. 字符缓冲输入流对象BufferedReader常用方法

public String readLine():读取数据到Java应用程序,一次读取一行数据
public void close():关闭输入流并释放资源

    public static void main(String[] args) {
        // 1. 源文件位置
        String sourcePath = "src/com/powernode/demo12/Demo.java";
        // 2. 目的地位置
        String targetPath = "src/com/powernode/demo12/Demo.txt";
        // 3. 拷贝方法
        copyFile(sourcePath, targetPath);
    }

    /**
     * 拷贝文件方法
     * // 1. 创建字符流对象
     * // 2. 创建缓冲流对象
     * // 3. 定义String变量,接收读取的数据
     * // 4. while循环读取数据
     * // 5. 将读取的数据写出到文件
     * // 6. 强制刷新
     * // 7. 释放资源
     */
    private static void copyFile(String sourcePath, String targetPath) {
        // 使用JDK1.7新特性try...with...resource
        try (
                // 1. 创建字符流对象
                Reader r = new FileReader(sourcePath);
                Writer w = new FileWriter(targetPath);
                // 2. 创建缓冲流对象
                BufferedReader br = new BufferedReader(r);
                BufferedWriter bw = new BufferedWriter(w);
        ) {
            // 3. 定义String变量,接收读取的数据
            String readLine;
            // 4. while循环读取数据
            while ((readLine = br.readLine()) != null) {
                // 5. 将读取的数据写出到文件
                bw.write(readLine);
                // 输出换行符
                bw.newLine();
                // 6. 强制刷新
                bw.flush();
            }
            // 7. 释放资源使用JDK1.7新特性try...with...resource自动释放资源
        } catch (Exception e) {
            e.printStackTrace();
        }
    }