File文件、递归、字符集、IO流（一）

day09-字符集、IO流（一）

一、File类

接下来，我们要学习的知识是一个File类。但是在讲这个知识点之前，我想先和同学们聊点别的，聊完之后再回过来学习File你会更容易理解一些。

• 先问大家一个问题，目前你写代码时存储数据，可以用哪些方案?

  答案如下图所示：可以是变量、可以是数组、可以是对象、可以是集合，但是这些数据都是存储在内存中的，只要程序执行结束，或者断点了，数据就消失了。不能永久存储。

• 有些数据要长久保存，该怎么办呢？

  答案如下图所示：可以将数据以文件的形式存在硬盘里，即使程序结束了，断点了只要硬盘没坏，数据就永久存在。

  

而现在要学习的File类，它的就用来表示当前系统下的文件（也可以是文件夹），通过File类提供的方法可以获取文件大小、判断文件是否存在、创建文件、创建文件夹等。

**但是需要我们注意：**File对象只能对文件进行操作，不能操作文件中的内容。

1.1 File对象的创建

学习File类和其他类一样，第一步是创建File类的对象。 想要创建对象，我们得看File类有哪些构造方法。

下面我们演示一下，File类创建对象的代码

需求我们注意的是：路径中"\"要写成"\\"， 路径中"/"可以直接用

/*
   目标:掌握File类构造方法
      创建对象
      File类表达 系统中文件/文件夹

      new File(String pathname)  根据路径封装一个File对象

      // 路径写法 遵循 windows系统写法
      E:\414\resource\出师表.txt
      注意 java中 \\ 表示 \
       不喜欢\\  那你就写 /

 */
public class FileDemo01 {
    public static void main(String[] args) {
        //1:创建一个File对象 指代某个具体的文件
        File f1 = new File("E:\\414\\resource\\出师表.txt");
//        File f1 = new File("E:/414/resource/出师表.txt");
        System.out.println(f1);//重写toString 展示路径内容 没重写地址值

        // File类型 除了指代某个具体的文件 还可以指代文件夹
        File d1 = new File("E:\\414\\resource");
        System.out.println(d1);

        // 2: File的第二个构造
        //  new File(String parentpath,String childpath)
        //    根据父路径 和 子路径 确定文件的路径
        File f2 = new File("E:\\414\\resource","出师表.txt");
        System.out.println(f2);

        //3:File的第三个构造
        //  new File(File parent,String childpath)
        File f3 = new File(d1,"出师表.txt");
        System.out.println(f3);

    }
}

/*
   目标: 辨析 相对路径 绝对路径

 */
public class FileDemo03 {
    public static void main(String[] args) {
        // 前提是我在day09 src 创建 xiaopeng.txt
        //创建一个File对象 指代xiaopeng.txt的文件
        // 第一种方式 找到文件的绝对路径  带盘符(根)的路径
        //  E:\414\secode\day09\src\xiaopeng.txt
        File f1 = new File("E:\\414\\secode\\day09\\src\\xiaopeng.txt");
        System.out.println(f1);
        System.out.println(f1.exists());
        // 相对路径(注意)  经常写的是相对路径 不带盘符
        //  相对 是 相对的当前 idea中project
        //  E:\414\secode\       day09\src\xiaopeng.txt
        //  当前project          相对路径
        File f2 = new File("day09\\src\\xiaopeng.txt");
        System.out.println(f2);
        System.out.println(f2.exists());







    }
}

1.2 File判断和获取方法

各位同学，刚才我们创建File对象的时候，会传递一个文件路径过来。但是File对象封装的路径是存在还是不存在，是文件还是文件夹其实是不清楚的。好在File类提供了方法可以帮我们做判断。

话不多少，直接上代码

/*
   目标: 辨析 是否真实文件  辨析  File是文件还是文件夹

 */
public class FileDemo02 {
    public static void main(String[] args) {
        //1:创建一个File对象 指代某个具体的文件
        File f1 = new File("E:\\414\\resource\\出师表.txt");
        System.out.println(f1);

        File f2 = new File("E:\\414\\resource\\厨师表.txt");
        System.out.println(f2);

        // 1：有一个判断方法  exists() 是否是真实文件
        System.out.println("f1是真实的文件吗:"+f1.exists());//true
        System.out.println("f2是真实的文件吗:"+f2.exists());//false

        //如果存在 能不能知道该文件的大小--里面的字节数
        //2： 获取文件大小 length()
        System.out.println("f1文件大小:"+f1.length());


        // 3：File类型 除了指代某个具体的文件 还可以指代文件夹
        File d1 = new File("E:\\414\\resource");
        System.out.println(d1);
        // d1 是文件夹  f1 是文件
        System.out.println("f1是不是文件呢:"+f1.isFile());//true
        System.out.println("d1是不是文件呢:"+d1.isFile());//false

        System.out.println("f1是不是文件夹呢:"+f1.isDirectory());//false
        System.out.println("d1是不是文件夹呢:"+d1.isDirectory());//true




    }
}

除了判断功能还有一些获取功能，看代码

public class FileDemo04 {

    public static void main(String[] args) {
        // 创建一个File对象 表达 系统中某个文件
        //  E:\414\resource\出师表.txt
        File file = new File("E:\\414\\resource\\出师表.txt");
        //
//        File file = new File("day09\\src\\xiaopeng.txt");
        //  获取方法
        // 1:获取字节数（只针对文件 不针对文件夹）
        System.out.println("文件的字节数:"+file.length());//2258
        // 2: 获取文件的名字
        System.out.println("文件的名字:"+file.getName());// 带后缀名  出师表.txt
        //3: 获取文件的最后修改时间  long 毫秒值
        long time = file.lastModified();
        System.out.println("文件的最后修改时间:"+time);
        //可以格式化
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("文件修改时间:"+sdf.format(time));// 2023-08-09 08:55:53
        //4:getPath() 获取封装路径
        System.out.println("文件的封装路径:"+file.getPath());// E:\414\resource\出师表.txt
        //5:getAbsolutePath() 获取绝对路径
        System.out.println("文件的绝对路径:"+file.getAbsolutePath());
    }
}

1.3 创建和删除方法

刚才有同学问老师，我们不能不用Java代码创建一个文件或者文件夹呀？答案是有的，不光可以创建还可以删除。

File类提供了创建和删除文件的方法，话不多少，看代码。

/*
  创建文件(夹)的方法
 */
public class FileDemo05 {

    public static void main(String[] args) throws IOException {
        // 1:创建文件呢  creatNewFile()
        // 指定一个 文件对象  但是文件是不存在的
        File file = new File("E:\\414\\resource\\xiaopeng.txt");
        System.out.println("创建文件之前:"+file.exists());// false
        //创建一个新的文件 相当于 windows中 右键new 新的文件
        boolean b = file.createNewFile();//提醒你 可能有问题
        // 如果你写的文件夹不存在 就有问题  如果你没有盘符访问权限 那么也无法新建
        System.out.println("文件是否创建成功:"+b);
        System.out.println("创建文件之后:"+file.exists());
        //2:创建目录 文件夹
        // boolean mkdir() 创建 单级目录
        File dir1 = new File("E:\\414\\resource\\abc");
        System.out.println("创建一个abc文件夹:"+dir1.mkdir());//如果有就不能创建成功 没有就创建成功
        // boolean mkdir() 创建 多级目录
        File dir2 = new File("E:\\414\\resource\\aaa\\bbb\\ccc\\ddd");
        System.out.println("创建一个abc文件夹:"+dir2.mkdirs());

        //3 删除文件或 空文件夹  boolean delete() 有就能删除成功  没有就返回false
                               // 如果删除 有内容的文件夹也是false
        File f2 = new File("E:\\414\\resource\\出师表 (2).txt");
        System.out.println("删除 出师表2"+f2.delete());
        // 删除 abc
        File d2 = new File("E:\\414\\resource\\abc");
        System.out.println("删除 空的abc文件夹:"+d2.delete());
        // 删除 aaa呢？
        File d3 = new File("E:\\414\\resource\\aaa");
        System.out.println("删除 空的abc文件夹:"+d3.delete());

    }
}

需要注意的是：

1.mkdir(): 只能创建单级文件夹、
2.mkdirs(): 才能创建多级文件夹
3.delete(): 文件可以直接删除，但是文件夹只能删除空的文件夹，文件夹有内容删除不了。

1.4 遍历文件夹方法

有人说，想获取到一个文件夹中的内容，有没有方法呀？也是有的，下面我们就学习两个这样的方法。

话不多少上代码，演示一下

public class FileDemo06 {

    public static void main(String[] args) {
        // 跟文件夹相关的方法
        File dir = new File("E:\\414\\resource\\学习外语");
        //程序怎么感知你目录里面有什么呢？
        //  String[] list() //将当前一级目录下 所有的文件及文件夹的 名字 放到一个数组中
        String[] fileNames = dir.list();

        //建议 遍历之前 健壮性判断
        if(fileNames!=null && fileNames.length>0){
            //是一个 文件夹 里面有东西
            for (String fileName : fileNames) {
                System.out.println(fileName);
            }
        }

        System.out.println("======================");
        //  File[] listFiles()
        // 将当前一级目录下 所有的文件及文件夹的 File对象形式 放到一个对象数组中
        File[] files = dir.listFiles();
        //健壮性判断
        if(files!=null && files.length>0){
            for (File file : files) {
                System.out.println("包含文件的绝对路径:"+file.getAbsolutePath());
            }
        }

    }
}

这里需要注意几个问题

1.当主调是文件时，或者路径不存在时，返回null
2.当主调是空文件夹时，返回一个长度为0的数组
3.当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹路径放在File数组中，并把数组返回
4.当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在FIle数组中，包含隐藏文件
5.当主调是一个文件夹，但是没有权限访问时，返回null

关于遍历文件夹的基本操作就学习完了。 但是有同学如果想要获取文件夹中子文件夹的内容，那目前还做不到。但是学习下面了下面的递归知识就，很容易做到了。

二、递归

各位同学，为了获取文件夹中子文件夹的内容，我们就需要学习递归这个知识点。但是递归是什么意思，我们需要单独讲一下。学习完递归是什么，以及递归的执行流程之后，我们再回过头来用递归来找文件夹中子文件夹的内容。

2.1 递归算法引入

• 什么是递归？

  递归是一种算法，从形式上来说，方法调用自己的形式称之为递归。

• 递归的形式：有直接递归、间接递归，如下面的代码。

/**
 * 目标：认识一下递归的形式。
 */
public class RecursionTest1 {
    public static void main(String[] args) {
        test1();
    }

    // 直接方法递归
    public static void test1(){
        System.out.println("----test1---");
        test1(); // 直接方法递归
    }

    // 间接方法递归
    public static void test2(){
        System.out.println("---test2---");
        test3();
    }

    public static void test3(){
        test2(); // 间接递归
    }
}

如果直接执行上面的代码，会进入死循环，最终导致栈内存溢出

以上只是用代码演示了一下，递归的形式。在下一节，在通过一个案例来给同学们讲一讲递归的执行流程。

2.2 递归算法的执行流程

为了弄清楚递归的执行流程，接下来我们通过一个案例来学习一下。

案例需求：计算n的阶乘，比如5的阶乘 = 1 * 2 * 3 * 4 * 5 ； 6 的阶乘 = 1 * 2 * 3 * 4 * 5 * 6

分析需求用递归该怎么做

假设f(n)表示n的阶乘，那么我们可以推导出下面的式子
	 f(5) = 1+2+3+4+5
    f(5) = f(4)+5
    f(4) = f(3)+4
    f(3) = f(2)+3
    f(2) = f(1)+2
    f(1) = 1
总结规律：
	除了f(1) = 1; 出口
	其他的f(n) = f(n-1)+n

我们可以把f(n)当做一个方法，那么方法的写法如下

/**
 * 目标：掌握递归的应用，执行流程和算法思想。
 */
public class RecursionTest2 {
    public static void main(String[] args) {
        System.out.println("5的阶乘是：" + f(5));
    }

    //求n个数的阶乘
    public static int f(int n){
        // 终结点
        if(n == 1){
            return 1;
        }else {
            return f(n - 1) * n;
        }
    }
}

这个代码的执行流程，我们用内存图的形式来分析一下，该案例中递归调用的特点是：一层一层调用，再一层一层往回返。

2.3 递归文件搜索

学习完递归算法执行流程后，最后我们回过头来。再来看一下，如果使用递归来遍历文件夹。

案例需求：在D:\\判断下搜索QQ.exe这个文件，然后直接输出。

1.先调用文件夹的listFiles方法，获取文件夹的一级内容，得到一个数组
2.然后再遍历数组，获取数组中的File对象
3.因为File对象可能是文件也可能是文件夹，所以接下来就需要判断
	判断File对象如果是文件，就获取文件名，如果文件名是`QQ.exe`则打印，否则不打印
	判断File对象如果是文件夹，就递归执行1,2,3步骤
所以：把1，2,3步骤写成方法，递归调用即可。

代码如下：

/**
 * 目标：掌握文件搜索的实现。
 */
public class RecursionTest3 {
    public static void main(String[] args) throws Exception {
          searchFile(new File("D:/") , "QQ.exe");
    }

    /**
     * 去目录下搜索某个文件
     * @param dir  目录
     * @param fileName 要搜索的文件名称
     */
    public static void searchFile(File dir, String fileName) throws Exception {
        // 1、把非法的情况都拦截住
        if(dir == null || !dir.exists() || dir.isFile()){
            return; // 代表无法搜索
        }

        // 2、dir不是null,存在，一定是目录对象。
        // 获取当前目录下的全部一级文件对象。
        File[] files = dir.listFiles();

        // 3、判断当前目录下是否存在一级文件对象，以及是否可以拿到一级文件对象。
        if(files != null && files.length > 0){
            // 4、遍历全部一级文件对象。
            for (File f : files) {
                // 5、判断文件是否是文件,还是文件夹
                if(f.isFile()){
                    // 是文件，判断这个文件名是否是我们要找的
                    if(f.getName().contains(fileName)){
                        System.out.println("找到了：" + f.getAbsolutePath());
                        Runtime runtime = Runtime.getRuntime();
                        runtime.exec(f.getAbsolutePath());
                    }
                }else {
                    // 是文件夹，继续重复这个过程（递归）
                    searchFile(f, fileName);
                }
            }
        }
    }
}

各位同学，前面我们已经学习了File类，通过File类的对象可以对文件进行操作，但是不能操作文件中的内容。要想操作文件中的内容，我们还得学习IO流。在正式学习IO流之前，我们还需要学习一个前置知识叫做字符集，只有我们把字符集搞明白了，再学习IO流才会更加丝滑。

三、字符集

3.1 字符集的来历

所以，接下来我们正式学习一下字符集。先来带着同学们，了解一下字符集的来历。

我们知道计算机是美国人发明的，由于计算机能够处理的数据只能是0和1组成的二进制数据，为了让计算机能够处理字符，于是美国人就把他们会用到的每一个字符进行了编码（所谓编码，就是为一个字符编一个二进制数据），如下图所示：

美国人常用的字符有英文字母、标点符号、数字以及一些特殊字符，这些字符一共也不到128个，所以他们用1个字节来存储1字符就够了。 美国人把他们用到的字符和字符对应的编码总结成了一张码表，这张码表叫做ASCII码表（也叫ASCII字符集）。

其实计算机只在美国用是没有问题的，但是计算机慢慢的普及到全世界，当普及到中国的时候，在计算机中想要存储中文，那ASCII字符集就不够用了，因为中文太多了，随便数一数也有几万个字符。

于是中国人为了在计算机中存储中文，也编了一个中国人用的字符集叫做GBK字符集，这里面包含2万多个汉字字符，GBK中一个汉字采用两个字节来存储，为了能够显示英文字母，GBK字符集也兼容了ASCII字符集，在GBK字符集中一个字母还是采用一个字节来存储。

3.2 汉字和字母的编码特点

讲到这里，可能有同学有这么一个疑问： 如果一个文件中既有中文，也有英文，那计算机怎么知道哪几个字节表示一个汉字，哪几个字节表示一个字母呢？

其实这个问题问当想当有水平，接下来，就带着同学们了解一下，计算机是怎么识别中文和英文的。

比如：在文件中存储一个我a你，底层其实存储的是这样的二进制数据。

需要我们注意汉字和字母的编码特点：

• 1. 如果是存储字母，采用1个字节来存储，一共8位，其中第1位是0
  2. 如果是存储汉字，采用2个字节来存储，一共16位，其中第1位是1

当读取文件中的字符时，通过识别读取到的第1位是0还是1来判断是字母还是汉字

• 如果读取到第1位是0，就认为是一个字母，此时往后读1个字节。
• 如果读取到第1位是1，就认为是一个汉字，此时往后读2个字节。

3.3 Unicode字符集

同学们注意了，咱们国家可以用GBK字符集来表示中国人使用的文字，那世界上还有很多其他的国家，他们也有自己的文字，他们也想要自己国家的文字在计算机中处理，于是其他国家也在搞自己的字符集，就这样全世界搞了上百个字符集，而且各个国家的字符集互不兼容。 这样其实很不利于国际化的交流，可能一个文件在我们国家的电脑上打开好好的，但是在其他国家打开就是乱码了。

为了解决各个国家字符集互不兼容的问题，由国际化标准组织牵头，设计了一套全世界通用的字符集，叫做Unicode字符集。在Unicode字符集中包含了世界上所有国家的文字，一个字符采用4个自己才存储。

在Unicode字符集中，采用一个字符4个字节的编码方案，又造成另一个问题：如果是说英语的国家，他们只需要用到26大小写字母，加上一些标点符号就够了，本身一个字节就可以表示完，用4个字节就有点浪费。

于是又对Unicode字符集中的字符进行了重新编码，一共设计了三种编码方案。分别是UTF-32、UTF-16、UTF-8; 其中比较常用的编码方案是UTF-8

下面我们详细介绍一下UTF-8这种编码方案的特点。

1.UTF-8是一种可变长的编码方案，工分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节

3.4 字符集小结

最后，我们将前面介绍过的字符集小结一下

ASCII字符集：《美国信息交换标准代码》，包含英文字母、数字、标点符号、控制字符
	特点：1个字符占1个字节

GBK字符集：中国人自己的字符集，兼容ASCII字符集，还包含2万多个汉字
	特点：1个字母占用1个字节；1个汉字占用2个字节

Unicode字符集：包含世界上所有国家的文字，有三种编码方案，最常用的是UTF-8
    UTF-8编码方案：英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节

3.5 编码和解码

搞清楚字符集的知识之后，我们接下来再带着同学们使用Java代码完成编码和解码的操作。

其实String类类中就提供了相应的方法，可以完成编码和解码的操作。

• 编码：把字符串按照指定的字符集转换为字节数组
• 解码：把字节数组按照指定的字符集转换为字符串

/**
 * 目标：掌握如何使用Java代码完成对字符的编码和解码。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、编码
        String data = "a我b";
        byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。
        System.out.println(Arrays.toString(bytes));

        // 按照指定字符集进行编码。
        byte[] bytes1 = data.getBytes("GBK");
        System.out.println(Arrays.toString(bytes1));

        // 2、解码
        String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码
        System.out.println(s1);

        String s2 = new String(bytes1, "GBK");
        System.out.println(s2);
    }
}

四、IO流（字节流）

4.1 IO流概述

各位小伙伴，在前面我们已经学习过File类。但是我们知道File只能操作文件，但是不能操作文件中的内容。我们也学习了字符集，不同的字符集存字符数据的原理是不一样的。有了前面两个知识的基础，接下来我们再学习IO流，就可以对文件中的数据进行操作了。

IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。如下图所示

• 把数据从磁盘、网络中读取到程序中来，用到的是输入流。
• 把程序中的数据写入磁盘、网络中，用到的是输出流。
• 简单记：输入流（读数据）、输出流（写数据）

IO流在Java中有很多种，不同的流来干不同的事情。Java把各种流用不同的类来表示，这些流的继承体系如下图所示：

IO流分为两大派系：
	1.字节流：字节流又分为字节输入流、字节输出流
	2.字符流：字符流由分为字符输入流、字符输出流

4.2 FileInputStream读取一个字节

同学们，在上节课认识了什么是IO流，接下来我们学习字节流中的字节输入流，用InputStream来表示。但是InputStream是抽象类，我们用的是它的子类，叫FileInputStream。

需要用到的方法如下图所示：有构造方法、成员方法

使用FileInputStream读取文件中的字节数据，步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码如下：

/**
 * 目标：掌握文件字节输入流，每次读取一个字节。
 */
public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1、创建文件字节输入流管道，与源文件接通。
        InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));

        // 2、开始读取文件的字节数据。
        // public int read():每次读取一个字节返回，如果没有数据了，返回-1.
        int b; // 用于记住读取的字节。
        while ((b = is.read()) != -1){
            System.out.print((char) b);
        }
        
        //3、流使用完毕之后，必须关闭！释放系统资源！
        is.close();
    }
}

这里需要注意一个问题：由于一个中文在UTF-8编码方案中是占3个字节，采用一次读取一个字节的方式，读一个字节就相当于读了1/3个汉字，此时将这个字节转换为字符，是会有乱码的。

4.3 FileInputStream读取多个字节

各位同学，在上一节我们学习了FileInputStream调用read()方法，可以一次读取一个字节。但是这种读取方式效率太太太太慢了。 为了提高效率，我们可以使用另一个read(byte[] bytes)的重载方法，可以一次读取多个字节，至于一次读多少个字节，就在于你传递的数组有多大。

使用FileInputStream一次读取多个字节的步骤如下

第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read(byte[] bytes)方法开始读取文件的字节数据。
第三步：调用close()方法释放资源

代码如下：

/**
 * 目标：掌握使用FileInputStream每次读取多个字节。
 */
public class FileInputStreamTest2 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
        InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt");

        // 2、开始读取文件中的字节数据：每次读取多个字节。
        //  public int read(byte b[]) throws IOException
        //  每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.

        // 3、使用循环改造。
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。  abc 66
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，倒出多少。
            String rs = new String(buffer, 0 , len);
            System.out.print(rs);
        }
        // 性能得到了明显的提升！！
        // 这种方案也不能避免读取汉字输出乱码的问题！！

        is.close(); // 关闭流
    }
}

• 需要我们注意的是：read(byte[] bytes)它的返回值，表示当前这一次读取的字节个数。

假设有一个a.txt文件如下：

abcde

每次读取过程如下

也就是说，并不是每次读取的时候都把数组装满，比如数组是 byte[] bytes = new byte[3];
第一次调用read(bytes)读取了3个字节(分别是97,98,99)，并且往数组中存，此时返回值就是3
第二次调用read(bytes)读取了2个字节(分别是99,100),并且往数组中存，此时返回值是2
第三次调用read(bytes)文件中后面已经没有数据了，此时返回值为-1

• 还需要注意一个问题：采用一次读取多个字节的方式，也是可能有乱码的。因为也有可能读取到半个汉字的情况。

4.4 FileInputStream读取全部字节

同学们，前面我们到的读取方式，不管是一次读取一个字节，还是一次读取多个字节，都有可能有乱码。那么接下来我们介绍一种，不出现乱码的读取方式。

我们可以一次性读取文件中的全部字节，然后把全部字节转换为一个字符串，就不会有乱码了。

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");

// 2、准备一个字节数组，大小与文件的大小正好一样大。
File f = new File("file-io-app\\src\\itheima03.txt");
long size = f.length();
byte[] buffer = new byte[(int) size];

int len = is.read(buffer);
System.out.println(new String(buffer));

//3、关闭流
is.close(); 

// 1、一次性读取完文件的全部字节到一个字节数组中去。
// 创建一个字节输入流管道与源文件接通
InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");

//2、调用方法读取所有字节，返回一个存储所有字节的字节数组。
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));

//3、关闭流
is.close(); 

最后，还是要注意一个问题：一次读取所有字节虽然可以解决乱码问题，但是文件不能过大，如果文件过大，可能导致内存溢出。

4.5 FileOutputStream写字节

各位同学，前面我们学习了使用FIleInputStream读取文件中的字节数据。然后有同学就迫不及待的想学习往文件中写入数据了。

往文件中写数据需要用到OutputStream下面的一个子类FileOutputStream。写输入的流程如下图所示

使用FileOutputStream往文件中写数据的步骤如下：

第一步：创建FileOutputStream文件字节输出流管道，与目标文件接通。
第二步：调用wirte()方法往文件中写数据
第三步：调用close()方法释放资源

代码如下：

/**
 * 目标：掌握文件字节输出流FileOutputStream的使用。
 */
public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字节输出流管道与目标文件接通。
        // 覆盖管道：覆盖之前的数据
//        OutputStream os =
//                new FileOutputStream("file-io-app/src/itheima04out.txt");

        // 追加数据的管道
        OutputStream os =
                new FileOutputStream("file-io-app/src/itheima04out.txt", true);

        // 2、开始写字节数据出去了
        os.write(97); // 97就是一个字节，代表a
        os.write('b'); // 'b'也是一个字节
        // os.write('磊'); // [ooo] 默认只能写出去一个字节

        byte[] bytes = "我爱你中国abc".getBytes();
        os.write(bytes);

        os.write(bytes, 0, 15);

        // 换行符
        os.write("\r\n".getBytes());

        os.close(); // 关闭流
    }
}

4.6 字节流复制文件

同学们，我们在前面已经把字节输入流和字节输出流都学习完了。现在我们就可以用这两种流配合起来使用，做一个文件复制的综合案例。

比如：我们要复制一张图片，从磁盘D:/resource/meinv.png的一个位置，复制到C:/data/meinv.png位置。

复制文件的思路如下图所示：

1.需要创建一个FileInputStream流与源文件接通，创建FileOutputStream与目标文件接通
2.然后创建一个数组，使用FileInputStream每次读取一个字节数组的数据，存如数组中
3.然后再使用FileOutputStream把字节数组中的有效元素，写入到目标文件中

代码如下：

/**
 * 目标：使用字节流完成对文件的复制操作。
 */
public class CopyTest5 {
    public static void main(String[] args) throws Exception {
        // 需求：复制照片。
        // 1、创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("D:/resource/meinv.png");
        // 2、创建一个字节输出流管道与目标文件接通。
        OutputStream os = new FileOutputStream("C:/data/meinv.png");

        System.out.println(10 / 0);
        // 3、创建一个字节数组，负责转移字节数据。
        byte[] buffer = new byte[1024]; // 1KB.
        // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
        int len; // 记住每次读取了多少个字节。
        while ((len = is.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }

        os.close();
        is.close();
        System.out.println("复制完成！！");
    }
}

五、IO流资源释放(不重要)

各位同学，前面我们已经学习了字节流，也给同学们强调过，流使用完之后一定要释放资源。但是我们之前的代码并不是很专业。

我们现在知道这个问题了，那这个问题怎么解决呢？ 在JDK7以前，和JDK7以后分别给出了不同的处理方案。

5.1 JDK7以前的资源释放

在JDK7版本以前，我们可以使用try…catch…finally语句来处理。格式如下

try{
    //有可能产生异常的代码
}catch(异常类 e){
    //处理异常的代码
}finally{
    //释放资源的代码
    //finally里面的代码有一个特点，不管异常是否发生，finally里面的代码都会执行。
}

改造上面的低吗：

public class Test2 {
    public static void main(String[] args)  {
        InputStream is = null;
        OutputStream os = null;
        try {
            System.out.println(10 / 0);
            // 1、创建一个字节输入流管道与源文件接通
            is = new FileInputStream("file-io-app\\src\\itheima03.txt");
            // 2、创建一个字节输出流管道与目标文件接通。
            os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");

            System.out.println(10 / 0);

            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成！！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源的操作
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

代码写到这里，有很多同学就已经看不下去了。是的，我也看不下去，本来几行代码就写完了的，加上try…catch…finally之后代码多了十几行，而且阅读性并不高。难受…

5.2 JDK7以后的资源释放

刚才很多同学已经发现了try…catch…finally处理异常，并释放资源代码比较繁琐。Java在JDK7版本为我们提供了一种简化的是否资源的操作，它会自动是否资源。代码写起来也想当简单。

格式如下：

try(资源对象1; 资源对象2;){
    使用资源的代码
}catch(异常类 e){
    处理异常的代码
}

//注意：注意到没有，这里没有释放资源的代码。它会自动是否资源

代码如下：

/**
 * 目标：掌握释放资源的方式：try-with-resource
 */
public class Test3 {
    public static void main(String[] args)  {
    	try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码写起来也想当简单。

格式如下：

try(资源对象1; 资源对象2;){
    使用资源的代码
}catch(异常类 e){
    处理异常的代码
}

//注意：注意到没有，这里没有释放资源的代码。它会自动是否资源

代码如下：

/**
 * 目标：掌握释放资源的方式：try-with-resource
 */
public class Test3 {
    public static void main(String[] args)  {
    	try (
          // 1、创建一个字节输入流管道与源文件接通
          InputStream is = new FileInputStream("D:/resource/meinv.png");
          // 2、创建一个字节输出流管道与目标文件接通。
          OutputStream os = new FileOutputStream("C:/data/meinv.png");
        ){
            // 3、创建一个字节数组，负责转移字节数据。
            byte[] buffer = new byte[1024]; // 1KB.
            // 4、从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int len; // 记住每次读取了多少个字节。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
            System.out.println(conn);
            System.out.println("复制完成！！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}