JavaIO流01

1. 异常
(1) 程序出现的不正常的情况。
(2) 异常的体系
　　Throwable
　　　　|--Error 严重问题，我们不处理。
　　　　|--Exception
　　　　　　|--RuntimeException 运行期异常，我们需要修正代码
　　　　　　|--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过
(3) 异常的处理：
　　A:JVM的默认处理
　　　　把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。
　　B:自己处理
　　　　a:try...catch...finally
　　　　　　自己编写处理代码,后面的程序可以继续执行
　　　　b:throws
　　　　　　把自己处理不了的，在方法上声明，告诉调用者，这里有问题
(4) 思考题
　　A:编译期异常和运行期异常的区别?
　　　　编译期异常 必须要处理的，否则编译不通过
　　　　运行期异常 可以不处理，也可以处理
　　B:throw和throws的区别
　　　　throw:
　　　　　　在方法体中,后面跟的是异常对象名,并且只能是一个
　　　　　　throw抛出的是一个异常对象，说明这里肯定有一个异常产生了
　　　　throws:
　　　　　　在方法声明上,后面跟的是异常的类名,可以是多个
　　　　　　throws是声明方法有异常，是一种可能性，这个异常并不一定会产生
(5) finally关键字及其思考题
　　A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了
　　B:思考题
　　　　a:final,finally,finalize的区别?
　　　　　　final：最终的意思，可以修饰类、成员变量、成员方法。修饰类，类不能被继承。修饰变量，变量是常量。修饰方法，方法不能被重写。
　　　　　　finally：是异常处理的一部分，用于释放资源。
　　　　　　　　一般来说，代码肯定会执行，特殊情况：如果在执行到finally之前jvm退出了，比如System.exit(0)，则就不能执行了finally控制的语句体了。
　　　　　　finalize：是Object类的一个方法，用于垃圾回收。
　　　　b:如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后b:
　　　　　　会。前。相对于最后一个能执行到的return语句来说。准确的说，应该是在中间。
　　　　　　　　finally语句在try和catch语句中的return执行后、返回前执行；
　　　　　　　　若finally语句中没有return，则其执行结果不影响try和catch中已确定的返回值；
　　　　　　　　若finally语句中有return，则其执行后的结果会直接返回。
　　C:异常处理的变形
　　　　try...catch...finally
　　　　try...catch...
　　　　try...catch...catch...
　　　　try...catch...catch...fianlly
　　　　try...finally -> 这种做法的目前是为了释放资源但是异常没有处理
(6) 自定义异常
继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可
(7) 异常的注意实现
　　A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常
　　B:父的方法没有异常抛出,子的重写方法不能有异常抛出
　　C:父的方法抛出多个异常,子的重写方法必须比父少或者小

2. File
(1) IO流操作中大部分都是对文件的操作，所以Java就提供了File类供我们来操作文件
(2) 构造方法
　　A:File file = new File("e:\\demo\\a.txt");
　　B:File file = new File("e:\\demo","a.txt");
　　C:File file = new File("e:\\demo");
　　　File file2 = new File(file,"a.txt");
(3) File类的功能
　　A:创建功能
　　B:删除功能
　　C:重命名功能
　　D:判断功能
　　E:获取功能
　　F:高级获取功能
　　G:过滤器功能
(4) 案例：
A:输出指定目录下指定后缀名的文件名称
　　a:先获取所有的，在遍历的时候判断，再输出
　　b:先判断，再获取，最后直接遍历输出即可

import java.io.File;

/*
 * 判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
 * 
 * 分析：
 *         A:封装e判断目录
 *         B:获取该目录下所有文件或者文件夹的File数组
 *         C:遍历该File数组，得到每一个File对象，然后判断
 *         D:是否是文件
 *             是：继续判断是否以.jpg结尾
 *                 是：就输出该文件名称
 *                 否：不搭理它
 *             否：不搭理它
 */
public class FileDemo {
    public static void main(String[] args) {
        // 封装e判断目录
        File file = new File("e:\\");

        // 获取该目录下所有文件或者文件夹的File数组
        File[] fileArray = file.listFiles();

        // 遍历该File数组，得到每一个File对象，然后判断
        for (File f : fileArray) {
            // 是否是文件
            if (f.isFile()) {
                // 继续判断是否以.jpg结尾
                if (f.getName().endsWith(".jpg")) {
                    // 就输出该文件名称
                    System.out.println(f.getName());
                }
            }
        }
    }
}

View Code

import java.io.File;
import java.io.FilenameFilter;

/*
 * 判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
 * A:先获取所有的，然后遍历的时候，依次判断，如果满足条件就输出。
 * B:获取的时候就已经是满足条件的了，然后输出即可。
 * 
 * 要想实现这个效果，就必须学习一个接口：文件名称过滤器
 * public String[] list(FilenameFilter filter)
 * public File[] listFiles(FilenameFilter filter)
 */
public class FileDemo2 {
    public static void main(String[] args) {
        // 封装e判断目录
        File file = new File("e:\\");

        // 获取该目录下所有文件或者文件夹的String数组
        // public String[] list(FilenameFilter filter)
        String[] strArray = file.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir, name).isFile() && name.endsWith(".jpg");
            }
        });

        // 遍历
        for (String s : strArray) {
            System.out.println(s);
        }
    }
}

View Code

B:批量修改文件名称

import java.io.File;

/*
 * 需求：把E:\评书\三国演义下面的视频名称修改为
 *         00?_介绍.avi
 * 
 * 思路：
 *         A:封装目录
 *         B:获取该目录下所有的文件的File数组
 *         C:遍历该File数组，得到每一个File对象
 *         D:拼接一个新的名称，然后重命名即可。
 */
public class FileDemo {
    public static void main(String[] args) {
        // 封装目录
        File srcFolder = new File("E:\\评书\\三国演义");

        // 获取该目录下所有的文件的File数组
        File[] fileArray = srcFolder.listFiles();

        // 遍历该File数组，得到每一个File对象
        for (File file : fileArray) {
            // System.out.println(file);
            // E:\评书\三国演义\三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi
            // 改后：E:\评书\三国演义\001_桃园三结义.avi
            String name = file.getName(); // 三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi

            int index = name.indexOf("_");
            String numberString = name.substring(index + 1, index + 4);
            // System.out.println(numberString);

            // int startIndex = name.lastIndexOf('_');
            // int endIndex = name.lastIndexOf('.');
            // String nameString = name.substring(startIndex + 1, endIndex);
            // System.out.println(nameString);
            int endIndex = name.lastIndexOf('_');
            String nameString = name.substring(endIndex);

            String newName = numberString.concat(nameString); // 001_桃园三结义.avi
            // System.out.println(newName);

            File newFile = new File(srcFolder, newName); // E:\\评书\\三国演义\\001_桃园三结义.avi

            // 重命名即可
            file.renameTo(newFile);
        }
    }
}

View Code

3. 递归
(1) 方法定义中调用方法本身的现象
(2) 递归的注意事项；
　　A:要有出口，否则就是死递归
　　B:次数不能过多，否则内存溢出
　　C:构造方法不能递归使用
(3) 递归的案例：
　　A:递归求阶乘
　　B:兔子问题
　　C:递归输出指定目录下所有指定后缀名的文件绝对路径
　　D:递归删除带内容的目录(小心使用)

4. IO流
(1) IO用于在设备间进行数据传输的操作
(2) 分类：
　　A:流向
　　　　输入流 读取数据
　　　　输出流 写出数据
　　B:数据类型
　　　　字节流
　　　　　　字节输入流
　　　　　　字节输出流
　　　　字符流
　　　　　　字符输入流
　　　　　　字符输出流
　　注意：
　　　　a:如果我们没有明确说明按照什么分，默认按照数据类型分。
　　　　b:除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。
(3) FileOutputStream写出数据
　　A:操作步骤
　　　　a:创建字节输出流对象
　　　　b:调用write()方法
　　　　c:释放资源
　　B:代码体现：

FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("hello".getBytes());
fos.close();

　　C:要注意的问题?
　　　　a:创建字节输出流对象做了几件事情?
　　　　b:为什么要close()?
　　　　c:如何实现数据的换行?
　　　　d:如何实现数据的追加写入?
(4) FileInputStream读取数据
　　A:操作步骤
　　　　a:创建字节输入流对象
　　　　b:调用read()方法
　　　　c:释放资源
　　B:代码体现：

FileInputStream fis = new FileInputStream("fos.txt");

//方式1
int by = 0;
while((by=fis.read())!=-1) {
　　System.out.print((char)by);
}

//方式2
byte[] bys = new byte[1024];
int len = 0;
while((len=fis.read(bys))!=-1) {
　　System.out.print(new String(bys,0,len));
}

fis.close();

(5) 案例：2种实现
　　A:复制文本文件
　　B:复制图片
　　C:复制视频
(6) 字节缓冲区流
　　A:BufferedOutputStream
　　B:BufferedInputStream
(7) 案例：4种实现
　　A:复制文本文件

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 复制文本文件。
 * 
 * 数据源：从哪里来
 * a.txt    --    读取数据    --    FileInputStream    
 * 
 * 目的地：到哪里去
 * b.txt    --    写数据        --    FileOutputStream
 * 
 * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
 * 
 * 这一次复制中文没有出现任何问题，为什么呢?
 * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
 * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
 * 它会自己做转换。
 */
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("b.txt");

        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        // 释放资源(先关谁都行)
        fos.close();
        fis.close();
    }
}

View Code

　　B:复制图片

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
 * 
 * 数据源：
 *         e:\\林青霞.jpg    --读取数据--FileInputStream
 * 目的地：
 *         mn.jpg--写出数据--FileOutputStream
 */
public class CopyImageDemo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("mn.jpg");

        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        // 释放资源
        fos.close();
        fis.close();
    }
}

View Code

　　C:复制视频

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源：
 *         e:\\哥有老婆.mp4--读取数据--FileInputStream
 * 目的地：
 *         copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("copy.mp4");

        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        // 释放资源
        fos.close();
        fis.close();
    }
}

View Code

　　D:四种方式

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节：    共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        // method1("e:\\哥有老婆.mp4", "copy1.mp4");
        // method2("e:\\哥有老婆.mp4", "copy2.mp4");
        // method3("e:\\哥有老婆.mp4", "copy3.mp4");
        method4("e:\\哥有老婆.mp4", "copy4.mp4");
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }

    // 高效字节流一次读写一个字节数组：
    public static void method4(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }

        bos.close();
        bis.close();
    }

    // 高效字节流一次读写一个字节：
    public static void method3(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));

        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);

        }

        bos.close();
        bis.close();
    }

    // 基本字节流一次读写一个字节数组
    public static void method2(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);

        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

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

    // 基本字节流一次读写一个字节
    public static void method1(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);

        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

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

5. 字符流
IO流分类
　　字节流：
　　　　InputStream
　　　　　　FileInputStream
　　　　　　BufferedInputStream
　　　　OutputStream
　　　　　　FileOutputStream
　　　　　　BufferedOutputStream
　　字符流：
　　　　Reader
　　　　　　FileReader
　　　　　　BufferedReader
　　　　Writer
　　　　　　FileWriter
　　　　　　BufferedWriter