javaIO流基础

1.IO的概述

1.1 IO流概述及其前奏
- A:IO流概述
  - IO流用来处理设备之间的数据传输
  - 上传文件和下载文件
- B:IO流前奏
  - 讲解IO流之前为什么先讲解异常和File类呢?
  - 因为File表示的是IO流将来要操作的文件，所以我们需要学习File类。
  - 而常见操作文件无非就是上传文件和下载文件，在这个操作的过程中可能出现问题，
  - 出现问题后，我们需要对对应的代码进行处理。所以我们需要学习异常。

2.IO流整体介绍

3.File文件类

3.1 File类的概述和方法介绍【掌握】
- A:File类的概述
  - 文件和目录路径名的抽象表示形式
- B:构造方法
  - File(String pathname)：根据一个路径得到File对象
  - File(String parent, String child): 根据一个目录和一个子文件/目录得到File对象
  - File(File parent, String child): 根据一个父File对象和一个子文件/目录得到File对象
- C:创建功能
  - public boolean createNewFile(): 创建文件如果存在这样的文件，就不创建了
  - public boolean mkdir(): 创建文件夹如果存在这样的文件夹，就不创建了
  - public boolean mkdirs(): 创建文件夹,如果父文件夹不存在，会帮你创建出来
  - 注意事项：如果你创建文件或者文件夹忘了写盘符路径，那么，默认在项目路径下。
- D:删除功能
  - public boolean delete(): 删除文件或者文件夹
  - 注意事项：Java中的删除不走回收站。要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹
- E:重命名功能
  - public boolean renameTo(File dest): 把文件重命名为指定的文件路径
  - 注意事项：如果路径名相同，就是改名。如果路径名不同，就是改名并剪切。
- F:判断功能
  - public boolean isDirectory(): 判断是否是目录
  - public boolean isFile(): 判断是否是文件
  - public boolean exists(): 判断是否存在
  - public boolean canRead(): 判断是否可读
  - public boolean canWrite(): 判断是否可写
  - public boolean isHidden(): 判断是否隐藏
- G:获取功能
  - public String getAbsolutePath()：获取绝对路径
  - public String getPath(): 获取相对路径
  - public String getName(): 获取名称
  - public long length(): 获取长度。字节数
  - public long lastModified(): 获取最后一次的修改时间，毫秒值
  - public String[] list(): 获取指定目录下的所有文件或者文件夹的名称数组
  - public File[] listFiles(): 获取指定目录下的所有文件或者文件夹的File数组

4.递归

4.1 递归概述和注意事项
- 递归概述: 方法定义中调用方法本身的现象
- 递归注意事项要有出口，否则就是死递归。次数不能太多，否则就内存溢出
- 递归解决问题的思想及图解
- 案例代码

public static void main(String[] args) {
    show(5) ;
}

/**
 * 递归
 */
public static void show(int n) {
    if(n == 0){
        return ;
    }
    System.out.println(n);
    show(--n) ;
}

5.IO流

5.1 IO流概述及其分类【掌握】
- A:IO流概述
  - IO流用来处理设备之间的数据传输
  - Java对数据的操作是通过流的方式
  - Java用于操作流的对象都在IO包中
- B:IO流分类
  - a:按照数据流向
    - 输入流读入数据
    - 输出流写出数据
  - b:按照数据类型
    - 字节流
    - 字符流
    - 什么情况下使用哪种流呢?
    - 如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
    - 如果你什么都不知道，就用字节流
  - c:字节流和字符流
    - 字节流
      - 字节输入流 InputStream 读
      - 字节输出流 OutputStream 写
    - 字符流
      - 字符输入流 Reader 读
      - 字符输出流 Writer 写
    - 上面的4个流对象都是抽象类,我们不能直接使用,我们需要使用子类

5.2 输入流和输出流分类

5.3 IO流基类概述和FileOutputStream的构造方法【掌握】
IO流基类概述
- a:字节流的抽象基类：
  - InputStream ，OutputStream。
- b:字符流的抽象基类：
  - Reader ， Writer。
  - 注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
  - 如：InputStream的子类FileInputStream。
  - 如：Reader的子类FileReader。

5.4 FileOutputStream【掌握】

A: 构造方法

FileOutputStream(File file)
FileOutputStream(String name)

注意事项：创建字节输出流对象了做了几件事情?为什么一定要close()?

public static void main(String[] args) throws IOException {
    FileOutputStream fos = new FileOutputStream("a.txt") ;
    /**
     * 上面的代码做了什么事情?
     *         1: 调用系统资源,创建了一个a.txt文件
     *         2: 创建一个fos对象
     *         3: 把fos指向a.txt
     */
    String s = "hello, IO , 我来了" ;
    // 把字符串转换成字节数组
    byte[] bytes = s.getBytes() ;
    // 调用方法写数据
    fos.write(bytes) ;
    /**
     * 关闭流对象
     * 作用: 通知系统释放关于该文件的资源
     */
    fos.close() ;
}

B:FileOutputStream的三个write()方法

public void write(int b):写一个字节
public void write(byte[] b):写一个字节数组
public void write(byte[] b,int off,int len):写一个字节数组的一部分

FileOutputStream写出数据实现换行和追加写入

实现数据的换行

实现数据的追加写入

public static void main(String[] args) throws IOException {
    // public FileOutputStream(String name,  boolean append)
    // 表示追加写入
    FileOutputStream fos = new FileOutputStream("c.txt" , true) ;       
    // 写数据
    for(int x = 0 ; x < 5 ; x++) {
        byte[] bytes = ("呵呵" + x + "\r\n").getBytes() ;
        fos.write(bytes) ;
    }
    // 是否资源
    fos.close() ;
}

5.5 FileInputStream【掌握】

FileInputStream读取数据一次一个字节
- int read():一次读取一个字节

6.IO流案例

6.1 字节流复制文本文件【字节流一次读写一个字节复制文本文件】

一次读取一个字节

public static void main(String[] args) throws IOException {
    /**
     * 复制文本文件:
     *         读和写
     *     分析:
     *         1: 创建两个对象一个是字节输入流对象,一个是字节输出流对象
     *         2: 一次读取一个字节,一次写一个字节
     *         3: 释放资源
     */
    // 创建两个对象一个是字节输入流对象,一个是字节输出流对象
    FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java") ;
    FileOutputStream fos = new FileOutputStream("copyFile.java") ;
    // 一次读取一个字节,一次写一个字节
    int by = 0 ;
    while((by = fis.read()) != -1){
        fos.write(by) ;
    }
    // 释放资源
    fos.close() ;
    fis.close() ;
}

6.2 字节流复制MP3【字节流一次读写一个字节复制MP3】

一次读取一个字节

public static void main(String[] args) throws IOException {
    // 需求: 使用字节流复制mp3文件
    // 创建字节输入流和字节输出流对象
    FileInputStream fis = new FileInputStream("C:\\a.mp3") ;
    FileOutputStream fos = new FileOutputStream("D:\\a.mp3") ;
    // 复制文件
    int by = 0 ;
    while((by = fis.read()) != -1){
        fos.write(by) ;
    }
    // 释放资源
    fos.close() ;
    fis.close() ;
}

6.3 FileInputStream读取数据一次一个字节数组

6.4 FileInputStream读取数据的两种方式比较

6.5 字节流复制文本文件【字节流一次读写一个字节数组复制文本文件】

字节流一次读写一个字节数组

public static void main(String[] args) throws IOException {
    /**
     * 需求: 使用字节流复制文本文件,采用字节输入流的第二种读取数据的方式
     */
    // 创建字节输入流对象和字节输出流对象
    FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java") ;
    FileOutputStream fos = new FileOutputStream("copyFile2.java") ;
    // 一次读取一个字节数组复制文件
    byte[] bytes = new byte[1024] ;
    int len = 0 ;        // 作用: 记录读取到的有效的字节个数
    while((len = fis.read(bytes)) != -1){
        fos.write(bytes, 0, len) ;
    }
    // 释放资源
    fos.close() ;
    fis.close() ;
}

6.6 字节流复制MP3【字节流一次读写一个字节数组复制MP3】

一次读取一个字节数组

public static void main(String[] args) throws IOException {
    /**
     * 需求: 使用字节流复制mp3文件一次读取一个字节数组
     */
    // 创建对象
    FileInputStream fis = new FileInputStream("C:\\a.mp3") ;
    FileOutputStream fos = new FileOutputStream("D:\\a.mp3") ;
    // 一次读取一个字节数组复制文件
    byte[] bytes = new byte[1024] ;
    int len = 0 ;
    while((len = fis.read(bytes)) != -1){
        fos.write(bytes, 0, len) ;
    }
    // 释放资源
    fos.close() ;
    fis.close() ;
}

7.Buffer缓冲数据流

7.1 BufferedOutputStream写出数据

代码如下所示：

public static void main(String[] args) throws IOException {
    /**
     * BufferedOutputStream构造方法:
     *         public BufferedOutputStream(OutputStream out)
     */
    // 创建FileOutputStream对象
    //FileOutputStream fos = new FileOutputStream("buf.txt") ;
    //BufferedOutputStream bof = new BufferedOutputStream(fos) ;
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("buf.txt")) ;
    // 调用方法
    bos.write("哈哈,我来了".getBytes()) ;
    // 释放资源
    bos.close() ;
}

7.2 BufferedInputStream读取数据

代码如下所示：

public static void main(String[] args) throws IOException {
    /**
     * BufferedInputStream构造方法:
     *         public BufferedInputStream(InputStream in)
     */
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream("e.txt")) ;
    // 一次读取一个字节
    //int by = 0 ;
    //while((by = bis.read()) != -1){
    //    System.out.print((char)by);
    //}
    // 一次读取一个字节数组
    byte[] bytes = new byte[1024] ;
    int len = 0 ;
    while((len = bis.read(bytes)) != -1){
        System.out.print(new String(bytes , 0 , len));
    }
    // 释放资源
    bis.close() ;
}

7.3 字节流四种方式复制MP3并测试效率

基本字节流一次读写一个字节
基本字节流一次读写一个字节数组
高效字节流一次读写一个字节

高效字节流一次读写一个字节数组

public class CopyFileDemo {

    public static void main(String[] args) throws IOException {
        // 获取开始时间
        long startTime = System.currentTimeMillis() ;
        // 复制文件
        copyFile_4() ;
        // 获取结束时间
        long endTime = System.currentTimeMillis() ;
        // 输出
        System.out.println("复制文件使用的时间是:" + (endTime - startTime) + "毫秒");
    }

    /**
     * 高效流一次读取一个字节数组赋值文件
     * @throws IOException
     */
    public static void copyFile_4() throws IOException {       
        // 复制文件使用的时间是:50毫秒
        // 创建高效流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\a.avi")) ;
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\a.avi")) ;
        // 一次读取一个字节数组
        byte[] bytes = new byte[1024] ;
        int len = 0 ;
        while((len = bis.read(bytes)) != -1){
            bos.write(bytes, 0, len) ;
        }
        // 释放资源
        bos.close() ;
        bis.close() ;
    }

    /**
     * 高效流一次读取一个字节复制文件
     * @throws IOException
     */
    public static void copyFile_3() throws IOException {       
        // 复制文件使用的时间是:990毫秒
        // 创建高效流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\a.avi")) ;
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\a.avi")) ;
        // 一次读取一个字节
        int by = 0 ;
        while((by = bis.read()) != -1){
            bos.write(by) ;
        }
        // 释放资源
        bos.close() ;
        bis.close() ;
    }

    /**
     * 基本流一次读取一个字节数组复制文件
     * @throws IOException
     */
    private static void copyFile_2() throws IOException {       
        // 复制文件使用的时间是:130毫秒
        // 创建对象
        FileInputStream fis = new FileInputStream("C:\\a.avi") ;
        FileOutputStream fos = new FileOutputStream("D:\\a.avi") ;

        // 一次读取一个字节数组
        byte[] bytes = new byte[1024] ;
        int len = 0 ;
        while((len = fis.read(bytes)) != -1){
            fos.write(bytes, 0, len) ;
        }
        // 释放资源
        fos.close() ;
        fis.close() ;
    }

    /**
     * 基本流一次读取一个字节复制文件
     * @throws IOException
     */
    private static void copyFile_1() throws IOException {   
        // 复制文件使用的时间是:88670毫秒
        // 创建对象
        FileInputStream fis = new FileInputStream("C:\\a.avi") ;
        FileOutputStream fos = new FileOutputStream("D:\\a.avi") ;
        // 一次读取一个字节
        int by = 0 ;
        while((by = fis.read()) != -1){
            fos.write(by) ;
        }
        // 释放资源
        fos.close() ;
        fis.close() ;
    }
}