IO流和反射

IO流

1.File

1.创建File类的对象（构造器和说明）

创建一个File对象，指代某个具体的文件

        File f1 = new File("D:/develop/javalearn/Java1/.idea");
        System.out.println(f1);

注意：File对象可以指代一个不存在的文件路径。通过调用exists 方法返回true/false来判断文件路径是否存在
相对路径和绝对路径：绝对路径是带盘符的，而相对路径是不带盘符的，默认是直接去工程下寻找文件的

2.File提供的判断文件类型，获取文件信息功能的方法

上述方法的代码展示：

        // 1.创建文件对象，指代某个文件
        File f1 = new File("D:/resource/ab.txt");

        // 2.public boolean exists():判断当前文件对象，对应的文件路径是否存在，存在返回true，反之，false
        System.out.println(f1.exists());

        // 3.public boolean isFile():判断当前文件对象指代的是否是文件，是文件返回true
        System.out.println(f1.isFile());

        // 4.public boolean isDirectory():判断当前文件对象指代的是否是文件夹，是文件夹返回true
        System.out.println(f1.isDirectory());

        // 5.public String getName():获取文件的名称（包含后缀）
        System.out.println(f1.getName());

        // 6.public long length():获取文件的大小，返回字节个数
        System.out.println(f1.length());

        // 7.public long lastModified():获取文件的最后修改时间
        long time = f1.lastModified();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        System.out.println(sdf.format(time));

        // 8.public String getPath():获取创建文件对象时，使用的路径
        File f2 = new File("D:/resource/ab.txt");
        File f3 = new File("file-io-app\\file-io-app\\src\\itheima.txt");
        System.out.println(f2);
        System.out.println(f3);

        // 9.public String getAbsolutePath():获取绝对路径
        System.out.println(f2.getAbsolutePath());
        System.out.println(f3.getAbsolutePath());
//        System.out.println(f3.getAbsoluteFile());
//        System.out.println(f2.getAbsoluteFile()); 相对路径

3.File创建文件和删除文件的方法

上述方法的代码展示：

        // 1.public boolean createNewFile():创建一个新文件（文件内容为空），创建成功返回true，反之false
        File f1 = new File("D:/resource/itheima2.txt");
        System.out.println(f1.createNewFile());

        // 2.public boolean mkdir():用于创建文件夹，注意：只能创建一级文件夹
        File f2 = new File("D:/resource/aaa");
        System.out.println(f2.mkdir());

        // 3.public boolean mkdirs():用于创建文件夹，注意：只能创建多级文件夹
        File f3 = new File("D:/resource/bbb/ccc");
        System.out.println(f3.mkdirs());

        // 4.public boolean delete():删除文件，或者空文件，注意：不能删除非空文件夹
        System.out.println(f1.delete());
        System.out.println(f2.delete());
        File f4 = new File("D:/resource");
        System.out.println(f4.delete());

4.File遍历文件夹的方法

        // 1.public String[] list():获取当前目录下所有的“一级文件名称”到一个字符串数组中去返回
        File f1 = new File("D:\\code");
        String[] names = f1.list();
        for (String name : names) {
            System.out.println(name);
        }

        // 2.public File[] listFiles():(重点)获取当前目录下所有的“一级文件对象”到一个文件对象数组中去返回（重点）
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file.getAbsolutePath());
        }

第一个是把D：//code下的一级文件名称存到一个数组中进行返回
第二个是获得一级文件的绝对路径

使用list Files方法时的注意事项：
当主调时文件，或者路径不存在时，返回null
当主调是空文件夹时，返回一个长度为0的数组
当主调是一个有内容的文件夹时，将里面所有的一级文件和文件夹的路径放在File数组中返回
当主调是一个文件夹，且里面有隐藏文件，将里面所有文件和文件夹的路径放在File数组中返回
当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

2.字符集编码

• ASCII字符集：只有英文，数字，符号等，占1个字节
• GBK字符集：汉字占2个字节，英文，数字占1个字节
• UTF-8字符集：汉字占3个字节，英文，数字占1个字节
  注意1：字符编码时使用的字符集，和解码时使用的字符集必须一致，否则会出现乱码
  注意2：英文，数字一般不会乱码，因为很多字符集都兼容了ASCII编码

（编码：把字符按照指定字符集编码成字节。解码：把字符按照指定字符集解码成字节。）

        // 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);

3.字节流

1.FileInputStream（文件字节输入流）

作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去
注意事项：使用FileInputStream每次读取一个字节，读取性能较差，并且读取汉字输出会乱码
使用FileInputStream每次读取多个字节，读取性能得到明显提升，但读取汉字输出还是会乱码

创建文件字节输出流管道，与源文件相通

InputStream is = new FileInputStream("D:\\code\\javasepromax\\file-io-app\\file-io-app\\src\\itheima01.txt");

1.每次读取一个字节

        int b;// 用于记住读取的字节
        while((b = is.read()) != -1){
            System.out.print((char) b);
        }

2.每次读取多个字节

len是读取的字节的个数

        byte[] buffer = new byte[3];
        int len;
        while ((len = is.read(buffer)) != -1){
            // 注意：读取多少，输出多少
            String rs = new String(buffer,0,len);
            System.out.println(rs);
        }

3.一次读取完文件的全部字节=到一个字节数组中去

要准备一个字节数组，大小与文件的大小正好一样大

        File f = new File("D:\\code\\javasepromax\\file-io-app\\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));

        System.out.println(size);
        System.out.println(len);

（这里只能用于文件大小比较小的时候）
注意：流使用完毕之后，必须关闭；释放资源

        is.close();

2.FileOutputStream（文件字节输出流）

作用：以内存为基准，把内存中的数据以字节的形式写出到文件中去

先创建一个字节输出流管道与目标文件相通

 OutputStream os = new FileOutputStream("D:/code/javasepromax/file-io-app/file-io-app/src/itheima04out.txt");

对上述方法的代码展示：

        os.write(97); // 97就是一个字节，代表a
        os.write('b');// ‘b’也是一个字节

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

        os.write(bytes,0,15);

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

注意：流使用完毕之后，必须关闭；释放资源

        os.close();

4.try-catch-finally

try-catch用来捕获异常。适用于：在某个类的方法中会抛出异常，那么当其父类或其他类调用这个方法时，就要预测这个方法在某种情况下会抛出这个异常。将它捕获并进行处理。

作用：一般用于在程序执行完成后进行资源的释放操作

代码如下：

        try{
            System.out.println(10/ 0);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 除非虚拟机挂掉。负责finally一定会执行
            System.out.println("===finally执行了===");
        }
    }

10/0时可能会抛出异常，抛出异常会使程序终止，但是这个异常我们能预测到，并且可以规避，应该使用try-catch将其捕获，并在catch后对其处理。
注意：1.try和catch块内部的代码是相对独立的，也就是说在try中创建的对象、声明的变量的生命周期在try结束后也就随之结束了；

2.若在try中代码运行的过程中没有发生任何异常，那么catch中的代码就完全不会运行。

3.try-catch是捕获异常的过程，finally相当于是对它们两个的“收尾工作”。
（finally中存在return语句时，在try/catch中将要return的返回值会被finally中的return的返回值覆盖，不要再finally语句中return）

资源释放

先创建字节输入流和输出流管道与源文件接通
（要放在try（）里面，这样结束之和能自动的进行流的资源的释放）

            // 1.创建一个字节输入流管道与源文件接通
            InputStream is = new FileInputStream("D:\\code\\javasepromax\\file-io-app\\file-io-app\\src\\itheima03.txt");
            // 2.创建一个字节输出流管道与源文件接通
            OutputStream  os = new FileOutputStream("D:\\code\\javasepromax\\file-io-app\\file-io-app\\src\\itheima04out.txt");

然后转移字节数据即可

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

关于catch部分的代码

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

5.字符流

1.FileReader

文件字符输入流
作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去


先创建一个文件字符输入流管道与源文件接通

        try( // 1.创建一个文件字符输入流管道与源文件接通
             Reader fr = new FileReader("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima01.txt");
             )

一个一个的读取文本文件的内容

           int c;
            while((c = fr.read()) != -1){
                System.out.print((char)c);
            }

每次读取多个字符

            char[] buffer = new char[3];
            int len;// 记住每次读取了多少个字符
            while((len = fr.read(buffer)) != -1){
                // System.out.print(new String(buffer, 0, len));
                String s = new String(buffer, 0, len);
                System.out.print(s);

2.FileWriter

文件字符输出流，写字符数据出去

先创建一个文件字符输出流管道与目标文件接通

        try (
                // 0.创建一个文件字符输出流管道与目标文件接通
                Writer fw = new FileWriter("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima02out.txt");
                )

public void write(int c):写一个字符出去

            fw.write('a');
            fw.write(97);
            fw.write('磊');

.public void write(String c)写一个字符串出去

            fw.write("我爱你中国");
            fw.write("\r\n");

public void write(String c, int pos, int len):写字符串的一部分出去

            fw.write("我爱你中国",0,5);
            fw.write("\r\n");

public void write(char[] buffer):写一个字符数组出去

            char[] buffer = {'黑','马'};
            fw.write(buffer);
            fw.write("\r\n");

（\r\n 为换行符）
字符输出流使用时的注意事项：字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

fw.flush() 刷新流
fw.close() 关闭流

6.字节缓冲流

作用：提高字节流读写数据的性能

原理：字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池

如何使用字节缓冲流？
（先创建字节输入流或输出流管道与源文件接通，然后再定义字节缓冲输入流或输出流包装原始的字节输入流或输出流）

        try(
            InputStream is = new FileInputStream("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima01.txt");
            // 1.定义一个字节缓冲流输入流包装原始的字节输入流
            InputStream bis = new BufferedInputStream(is);

            OutputStream os = new FileOutputStream("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima01_back.txt");
            // 2.定义一个字节缓冲输出流包装原始的字节输出流
            OutputStream bos = new BufferedOutputStream(os);
        )

把对曾经原始字节输入流/输出流的调用再改为包装后的字符输入流/输出流，进行数据的读取即可

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

1.BufferedReader（字符缓冲输入流）

作用：自带8K的字符缓冲池，可以提高字符输入流读取字符数据的性能

        try(
                Reader fr = new FileReader("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima04.txt");
                // 创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
                ){
            char[] buffer = new char[3];
            int len;
            while((len = br.read(buffer)) != -1){
                System.out.print(new String(buffer,0,len));
            }

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

            System.out.println(br.readLine());// 直接读一行
            System.out.println(br.readLine());
            System.out.println(br.readLine());
            System.out.println(br.readLine());

对数据一行一行的读取

2.BufferedWriter（字符缓冲输出流）

作用：自带8K的字符缓冲池，可以提高字符输出流读取字符数据的性能

        try(
                Writer fw = new FileWriter("D:\\code\\javasepromax\\io-app2\\io-app2\\src\\itheima08out.txt");
                BufferedWriter bw = new BufferedWriter(fw);
                ){
            
            bw.write('a');
            bw.write(97);
            bw.write('磊');
            bw.newLine();
            
            bw.write("我爱你中国abc");
            bw.newLine();
            
        }catch (Exception e){
            e.printStackTrace();
        }