IO流

输入流用于从源读取数据，输出流用于向目标写数据。
下图是一个描述输入流和输出流的类层次图。

1.File类

1.1 File类概述和构造方法

File类介绍

• 它是文件和目录路径名的抽象表示
• 文件和目录是可以通过File封装成对象的
• 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

File类的构造方法

import java.io.File;
public class FileDemo01 {
    public static void main(String[] args) {
        File file1 = new File("G:\\JavaEE\\file01.txt");
        System.out.println(file1);
        File file2 = new File("G:\\JavaEE", "file02.txt");
        System.out.println(file2);
        File file3 = new File("G:\\JavaEE");
        File file4 = new File(file3, "file03.txt");
        System.out.println(file4);
    }
}

运行结果

G:\JavaEE\file01.txt
G:\JavaEE\file02.txt
G:\JavaEE\file03.txt

1.2 File类创建功能

public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在G:\\JavaEE2021目录下创建一个文件file01.txt
        File file1 = new File("G:\\JavaEE2021\\file01.txt");
        System.out.println(file1.createNewFile());
        //需求2：我要在G:\\JavaEE2021目录下创建一个目录JavaEE
        File file2 = new File("G:\\JavaEE2021\\JavaEE");
        System.out.println(file2.mkdir());
        //需求3：我要在G:\\JavaEE2021目录下创建一个多级目录JavaWEB\\HTML
        File file3 = new File("G:\\JavaEE2021\\JavaWEB\\HTML");
        System.out.println(file3.mkdirs());;

    }
}

1.3 File类判断和获取功能

File类的判断和获取功能：
  public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
  public boolean isFile()：测试此抽象路径名表示的File是否为文件
  public boolean exists()：测试此抽象路径名表示的File是否存在

  public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
  public String getPath()：将此抽象路径名转换为路径名字符串
  public String getName()：返回由此抽象路径名表示的文件或目录的名称

  public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
  public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("G:\\JavaEE2021\\file01.txt");

        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");
			
       File f2 = new File("G:\\JavaEE2021");

        String[] strArray = f2.list();
        for (String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for (File file : fileArray) {
            if (file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

1.4 File类的删除功能

public class FileDemo03 {
    public static void main(String[] args) throws IOException {

        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
      //  f1.mkdirs();
        System.out.println(f1.createNewFile());
        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("myFile\\itcast");
        System.out.println(f2.mkdir());
        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
        File f3 = new File("myFile\\itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
        System.out.println(f4.createNewFile());
        //需求6：删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.5 递归遍历目录

给定一个路径(...)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台

public class DiGuiDemo02 {
    public static void main(String[] args) {
        File file = new File("G:\\JavaEE2021");
        getSrcFile(file);
    }
    public static void getSrcFile(File srcFile){
        File[] files = srcFile.listFiles();
        if(files != null){
            for (File file : files) {
                if(file.isDirectory()){
                    getSrcFile(file);
                }else{
                    System.out.println(file.getAbsolutePath());
                }

            }
        }
    }
}

2.IO流

• IO流介绍

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

• IO流的分类

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

• IO流的使用场景

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

2.1 字节流写数据

• 字节流抽象基类

  • InputStream：这个抽象类是表示字节输入流的所有类的超类
  • OutputStream：这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点：子类名称都是以其父类名作为子类名的后缀

• 字节输出流

  • FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

• 使用字节输出流写数据的步骤

  • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

• 示例代码

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        File file = new File("myFileOutputStream\\file.txt");
        FileOutputStream fos = new FileOutputStream(file);
       /**
        *  做了三件事情：
        *   A:调用系统功能创建了文件
        *   B:创建了字节输出流对象
        *   C:让字节输出流对象指向创建好的文件
        * */
      fos.write(97);
      fos.close();
    }
}

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

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(new File("myFileOutputStream\\fos.txt"));
        fos.write(97);
        fos.write(98);
        fos.write(99);

        byte[] bys={97,98,99,100,101};
        fos.write(bys);

        byte[] bytes = "abcde".getBytes();
        fos.write(bytes);

        fos.write(bys,1,3);

        fos.close();
    }
}

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

1.字节流写数据如何实现换行

windows:\r\n

linux:\n

mac:\r

2.字节流写数据如何实现追加写入

public FileOutputStream(String name,boolean append)

创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

示例代码

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream(new File("fos.txt"), true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("你好，世界".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.3 字节流写数据异常处理

异常处理格式

try-catch-fifinally

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

fifinally特点

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

示例代码

/*
    字节流写数据加入异常处理
 */
public class FileOutputStreamDemo04 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = null;

        try {
            File file = new File("myByteStream");
            file.mkdir();
            fos = new FileOutputStream("myByteStream\\fos.txt", true);
            
            //写数据
            for (int i = 0; i < 10; i++) {
                fos.write("hello".getBytes());
                fos.write("\r\n".getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
           if(fos != null)
               try {
                   fos.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
        }
    }
}

2.4 字节流读数据

• 字节输入流

  • FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名

• 字节输入流读取数据的步骤

  • 创建字节输入流对象

  • 调用字节输入流对象的读数据方法

  • 释放资源

2.5.1一次读一个字节字符数据

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("myByteStream/fos.txt");
        int file = 0;
        while((file=fis.read())!=-1){
            System.out.print((char)file);
        }
        fis.close();
    }
}

2.5.2一次读一个字节数组数据

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
        byte[]bytes = new byte[1024];
        int file = 0;
        while((file=fis.read(bytes))!=-1){
            System.out.print(new String(bytes,0,file));
        }
        fis.close();
    }
}

2.6 复制

实现步骤

复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目

的地)

数据源：

fis.txt --- 读数据 --- InputStream --- FileInputStream

目的地：

fos.txt --- 写数据 --- OutputStream --- FileOutputStream

2.6.1复制文本

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(new File("fis.txt"));
        FileOutputStream fos = new FileOutputStream(new File("fos.txt"));

        int fileCopy=0;
        while((fileCopy=fis.read())!=-1){
            fos.write(fileCopy);
        }
        System.out.println("finish");

        fos.close();
        fis.close();
    }
}

2.6.2 复制图片

public class CopyJpgDemo {
    public static void main(String[] args)throws IOException {
        FileInputStream fis = new FileInputStream("image01.jpg");
        FileOutputStream fos = new FileOutputStream("image02.jpg");
        int length;
        byte[]buf = new byte[1024];
        while ((length=fis.read(buf))!=-1){
            fos.write(buf,0,length);
        }
        fos.close();
        fis.close();
    }
}

2.6.3 复制视频

public class CopyJpgDemo {
    public static void main(String[] args)throws IOException {
        FileInputStream fis = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos = new FileOutputStream("copy张艺兴-Jorke.mp4");
        int length;
        byte[]buf = new byte[1024];
        while ((length=fis.read(buf))!=-1){
            fos.write(buf,0,length);
        }
        fos.close();
        fis.close();
    }
}

3.字节缓冲流

• 字节缓冲流介绍

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

• 构造方法

3.1 字节流读写文本

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("fos.txt"));
        for (int i = 0; i < 10; i++) {
            fos.write("你好,世界\n".getBytes());
        }
        fos.close();
        //读数据
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("fos.txt"));
        int length = 0;
      //方式一
        /*while((length = fis.read())!=-1){
            System.out.print((char)length);
        }*/

        //读数据
      //方式二
        byte []bytes = new byte[1024];
        while((length = fis.read(bytes))!=-1){
          //防止乱码
            System.out.println(new String(bytes,0,length, "UTF-8"));
        }
        fis.close();
    }
}

3.2 字节流复制视频

• 实现步骤

  • 根据数据源创建字节输入流对象

  • 根据目的地创建字节输出流对象

  • 读写数据，复制视频

  • 释放资源

    四种方式实现复制视频，并记录每种方式复制视频的时间
      1:基本字节流一次读写一个字节             
      2:基本字节流一次读写一个字节数组          
      3:字节缓冲流一次读写一个字节             
      4:字节缓冲流一次读写一个字节数组         
    

    实现代码：

import java.io.*;

public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
        // method01();
        //method02();
        //method03();
        method04();
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
    }

    //    1:基本字节流一次读写一个字节
    public static void method01() throws IOException {
        FileInputStream fis01 = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos01 = new FileOutputStream("Jorke01.mp4");
        int length;
        while ((length = fis01.read()) != -1) {
            fos01.write(length);
        }
        fos01.close();
        fis01.close();
    }

    //    2:基本字节流一次读写一个字节数组
    public static void method02() throws IOException {
        FileInputStream fis02 = new FileInputStream("张艺兴-Jorke.mp4");
        FileOutputStream fos02 = new FileOutputStream("Jorke02.mp4");
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = fis02.read(bytes)) != -1) {
            fos02.write(bytes, 0, length);
        }
        fos02.close();
        fis02.close();
    }

    //    3:字节缓冲流一次读写一个字节
    public static void method03() throws IOException {
        BufferedInputStream fis03 = new BufferedInputStream(new FileInputStream("张艺兴-Jorke.mp4"));
        BufferedOutputStream fos03 = new BufferedOutputStream(new FileOutputStream("Jorke03.mp4"));
        int length = 0;

        while ((length = fis03.read()) != -1) {
            fos03.write(length);
        }
        fos03.close();
        fis03.close();
    }

    //    4:字节缓冲流一次读写一个字节数组
    public static void method04() throws IOException {
        BufferedInputStream fis04 = new BufferedInputStream(new FileInputStream("张艺兴-Jorke.mp4"));
        BufferedOutputStream fos04 = new BufferedOutputStream(new FileOutputStream("Jorke04.mp4"));
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = fis04.read(bytes)) != -1) {
            fos04.write(length);
        }
        fos04.close();
        fis04.close();
    }
}

4.字符流

• 字符流的介绍

  • 由于字节流操作中文不是特别的方便，所以Java就提供字符流
  • 字符流 = 字节流 + 编码表

• 中文的字节存储方式

  • 用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？
  • 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

4.1 编码表

• 什么是字符集

  • 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
  • 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
  • 常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

• 常见的字符集

• ASCII字符集：

  • lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)
  • 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

• GBXXX字符集：

  • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

• Unicode字符集：

  • UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
  • 编码规则：
    • 128个US-ASCII字符，只需一个字节编码
    • 拉丁文等字符，需要二个字节编码
    • 大部分常用字（含中文），使用三个字节编码
    • 其他极少使用的Unicode辅助字符，使用四字节编码

4.2 字符串中的编码解码问题

package com.itheima_01;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "青春";
        System.out.println(Arrays.toString(s.getBytes()));
        System.out.println(Arrays.toString(s.getBytes("UTF-8")));
        System.out.println(Arrays.toString(s.getBytes("GBK")));
        System.out.println(Arrays.toString(s.getBytes("ASCII")));

        System.out.println(new String(s.getBytes()));
        System.out.println(new String(s.getBytes("UTF-8")));
        System.out.println(new String(s.getBytes("GBK")));
        System.out.println(new String(s.getBytes("ASCII")));
    }
}

控制台输出

[-23, -99, -110, -26, -104, -91]
[-23, -99, -110, -26, -104, -91]
[-57, -32, -76, -70]
[63, 63]
青春
青春
??
??

4.3 字符流中的编码解码问题

字符流抽象基类

• Reader：字符输入流的抽象类
• Writer:字符输出流的抽象类

字符流中和编码解码问题相关的两个类

• InputStreamReader：是从字节流到字符流的桥梁

  • 它读取字节，并使用指定的编码将其解码为字符
  • 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

• OutputStreamWriter：是从字符流到字节流的桥梁

  • 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
  • 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

构造方法

方法名 说明 
InputStreamReader(InputStream in) 使用默认字符编码创建InputStreamReader对象

InputStreamReader(InputStream in,Stringchatset)使用指定的字符编码创建InputStreamReader对象

OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象

OutputStreamWriter(OutputStream out,Stringcharset)使用指定的字符编码创建OutputStreamWriter对象

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //写数据
        OutputStreamWriter osw01 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter osw02 = new OutputStreamWriter(new FileOutputStream("fos.txt", true), "GBK");
        osw01.write("岁月静好，现世安稳\n");
        osw02.write("我不喜欢这世界，我只喜欢你\n");
        osw01.close();
        osw02.close();
        //读数据
        InputStreamReader isr01 = new InputStreamReader(new FileInputStream("fos.txt"));
        InputStreamReader isr02 = new InputStreamReader(new FileInputStream("fos.txt"), "GBK");
        int length = 0;
        while ((length = isr01.read()) != -1) {
            System.out.print((char) length);
        }

        char[] ch = new char[1024];
        while ((length = isr02.read(ch)) != -1) {
            System.out.println(new String(ch, 0, length));
        }
        isr01.close();
        isr02.close();
    }
}

4.4 字符流写数据的5种方式

• 写数据

• 刷新和关闭的方法

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter ows1 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows2 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows3 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows4 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        OutputStreamWriter ows5 = new OutputStreamWriter(new FileOutputStream("fos.txt", true));
        int c = 97;
        for (int i = 0; i < 10; i++) {
            ows1.write(c + i);
            ows1.write(" ");
        }
        char[] ch2 = {‘J‘, ‘a‘, ‘v‘, ‘a‘, ‘E‘, ‘E‘};
        ows2.write(ch2);
        char[]ch3={‘S‘,‘t‘,‘u‘,‘d‘,‘y‘,‘J‘, ‘a‘, ‘v‘, ‘a‘, ‘E‘, ‘E‘};
        ows3.write(ch3,0,7);
        String s4="疯狂学Java";
        ows4.write(s4);
        String s5="我不喜欢这世界，我只喜欢你";
        ows5.write(s5,3,6);

        ows5.close();
        ows4.close();
        ows3.close();
        ows2.close();
        ows1.close();
    }
}

4.5 字符流读数据的2种方式

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader fis = new InputStreamReader(new FileInputStream("fis.txt"));
        int length=0;
        //一次读一个字符数据
        while ((length=fis.read())!=-1){
            System.out.print((char)length);
        }
        char[]buf=new char[1024];
        //一次读一个字符数组数据
        while ((length=fis.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
        fis.close();
    }
}

4.6 字符缓冲流

• 字符缓冲流介绍
  • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
  • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途
• 构造方法

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("fis.txt"));

        //一次读取一个字符数据
        int ch;
        while ((ch = br.read()) != -1) {
            System.out.print((char) ch);
        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        br.close();

    }

}

4.7 字符缓冲流特有功能

• 方法介绍

BufferedWriter：

BufferedReader：

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("fis.txt"));
        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
//            bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        //创建字符缓冲输入流
        BufferedReader buf = new BufferedReader(new FileReader("fis.txt"));
        //public String readLine()：读一行文字。
        String line;
        while ((line = buf.readLine()) != null) {
            System.out.println(line);
        }
        buf.close();
    }
}

5.I O流小结

• 字节流
  

• 字符流
  

Java 流(Stream)、文件(File)和IO

原文：https://www.cnblogs.com/wanwanyuan/p/14342687.html