十七、IO流

IO 目录

  • 一、IO流的概述
    • IO流的分类
  • 二、基本流
    • 2.1字节流
    • 2.2 字节输出流写出数据的三种方式
    • 2.3 换行和续写
    • 2.4 字节输入流
    • 2.5 文件拷贝
    • 2.6 IO流中不同JDK版本捕获异常的方式
    • 2.7 字符集详解
      • 2.7.1 ASCII字符集
      • 2.7.2 GBK字符集
      • 2.7.3 Unicode字符集
    • 2.8 为什么会有乱码
    • 2.9 Java中的编码和解码
    • 2.10 字符流
      • FileReader
      • FileWriter
      • 字符流原理解析
    • 2.11 综合练习
      • 练习1:(拷贝)
      • 练习2:(文件加密)
      • 练习3:(修改文件中的数据)
  • 三、高级流
    • 3.1 缓冲流
      • 3.1.1 字节缓冲流
      • 3.1.2 字符缓冲流
    • 3.2 综合练习
      • 练习1(拷贝文件)
      • 练习2(修改文本顺序)
      • 练习3(软件运行次数)
    • 3.3 转换流
    • 3.4 序列化流
    • 3.5 反序列化流
    • 3.6 打印流
    • 3.7 解压缩流 / 压缩流
      • 3.7.1 解压缩流
      • 3.7.2 压缩流
    • 3.8 Commons-io
  • 1,IOUtils(数据相关)
      • 拷贝方法:
      • 拷贝大文件的方法:
      • 将输入流转换成字符串
      • 将输入流转换成字符数组
      • 字符串读写
      • 从一个流中读取内容
      • 把数据写入到输出流中
      • 从一个流中读取内容,如果读取的长度不够,就会抛出异常
      • 比较
      • 其他方法
  • 2,FileUtils(文件/文件夹相关)
      • 复制文件夹
      • 复制文件
      • 把字符串写入文件
      • 把字节数组写入文件
      • 把集合里面的内容写入文件
      • 往文件里面写内容
      • 文件移动
      • 清空和删除文件夹
      • 创建文件夹
      • 获取文件输入/输出流
      • 读取文件
      • 测试两个文件的修改时间
      • 文件/文件夹的迭代
      • 其他
  • FilenameUtils(文件名/后缀名相关)
  • Hutool工具包


一、IO流的概述

IO流:存储和读取数据的解决方方案
内存:不能永久化存储,程序停止,数据丢失

在这里插入图片描述
在这里插入图片描述

IO流的分类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、基本流

在这里插入图片描述

2.1字节流

在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        //实现需求:写出一段文字到本地文件中。(暂时不写中文)

        //0.创建字节输出流对象
        FileOutputStream fop = new FileOutputStream("day28_code/src/myIO/a.txt");

        //1.写数据
        fop.write(97);
        //2.释放资源
        fop.close();

    }

字节输出流的细节:

  1. 创建字节输出流对象
    • 细节1:参数是字符串表示的路径或者是File对象都是可以的
    • 细节2:如果文件不存在会创建一个新的文件,但是要保证父级路径是存在的
    • 细节3:如果文件已经存在,则会清空文件
      2.写数据
    • 细节:write方法的参数是整数,但是实际上写到本地文件中的整数在ASCII上对应的字符
  2. 释放资源
    • 每次使用完流之后都要释放资源

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

在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建对象
        FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/a.txt");

        //1.写出数据
        /*fos.write(97);
        fos.write(98);*/

        byte[] bytes = {97, 98, 100, 101, 102, 103};
//        fos.write(bytes);

        fos.write(bytes, 1, 3);
        //2.释放资源
        fos.close();
    }

2.3 换行和续写

在这里插入图片描述

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

        //0.创建对象
        FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/a.txt",true);//append 续写开关

        //1.写出数据
        String str = "Javachengxuyuan";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);

        //换行
        /*再次写出一个换行符就可以了
        * Windows:  \r\n
        * Linux:    \n
        * Mac:      \r
        *
        * 细节:
            * 在Windows操作系统当中,Java对回车换行进行了优化
            * 虽然完整的是\r\n,但是我们写其中一个\r或者\n,
            * Java也可以实现换行,因为Java在底层会补全*/
        String wrap = "\r\n";
        byte[] bytes2 = wrap.getBytes();
        fos.write(bytes2);

        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);

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

2.4 字节输入流

在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建对象
        FileInputStream fis = new FileInputStream("day28_code/src/myIO/a.txt");

        //1.读取数据
        int b1 = fis.read();
        System.out.println((char) b1);
        //2.释放资源
        fis.close();
    }

字节输入流的细节:

  1. 创建字节输入流对象
    • 细节:如果文件不存在,就直接报错
  2. 写数据
    • 细节1:依次读一个字节,读出来的是数据在ASCII上对应的数字
    • 细节2:读到文件末尾了,read方法返回-1
  3. 释放资源
    • 细节:每次使用完流时候都要释放资源
public static void main(String[] args) throws IOException {
        //0.创建对象
        FileInputStream fis = new FileInputStream("day28_code/src/myIO/a.txt");

        //1.循环读取
        int b;
        while ((b = fis.read()) != -1){
            System.out.print((char)b);
        }

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

2.5 文件拷贝

在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建对象
        FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
        FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/abc.mp4");

        //1.拷贝
        long start = System.currentTimeMillis();
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
        long end = System.currentTimeMillis();

        System.out.println(end - start);//统计时间

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建对象
        FileInputStream fis = new FileInputStream("day28_code/src/myIO/a.txt");

        //读取数据
        //一次读3个
        byte[] bytes = new byte[3];
        int len = fis.read(bytes);
        System.out.println(len);
        String str = new String(bytes);
        System.out.println(str);

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

    }

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        //0.创建对象
        FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
        FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/copy.mp4");

        //1.拷贝数据
        int len;
        byte[] bytes = new byte[5 * 1024 * 1024];
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }

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

        long end = System.currentTimeMillis();

        System.out.println(end - start);
    }

2.6 IO流中不同JDK版本捕获异常的方式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //0.创建对象
            fis = new FileInputStream("E:\\下载\\123.mp4");
            fos = new FileOutputStream("day28_code/src/myIO/copy.mp4");

            //1.拷贝数据
            int len;
            byte[] bytes = new byte[5 * 1024 * 1024];
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //2.释放资源

            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

简化代码:
在这里插入图片描述
在这里插入图片描述
JDK7:

public static void main(String[] args) {
        /*JDK7 IO流中捕获异常的方法*/

        try(FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
            FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/copy.mp4")){
            int len;
            byte[] bytes = new byte[5 * 1024 * 1024];
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

JDK8:

public static void main(String[] args) throws FileNotFoundException {
        /*JDK9 IO流中捕获异常的方法*/
        FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
        FileOutputStream fos = new FileOutputStream("day28_code/src/myIO/copy.mp4");

        try (fis; fos) {
            int len;
            byte[] bytes = new byte[5 * 1024 * 1024];
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2.7 字符集详解

在这里插入图片描述
字节:计算机最小的存储单元
在这里插入图片描述
在这里插入图片描述

2.7.1 ASCII字符集

在这里插入图片描述
在这里插入图片描述

2.7.2 GBK字符集

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.7.3 Unicode字符集

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.8 为什么会有乱码

原因1:读取数据时未读完整个汉字。
原因2:编码和解码时的方式不统一。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.9 Java中的编码和解码

在这里插入图片描述

public static void main(String[] args) throws UnsupportedEncodingException {
        //0.编码
        String str = "ai你哟";
        byte[] bytes1 = str.getBytes(); // UTF-8
        System.out.println(Arrays.toString(bytes1)); //[97, 105, -28, -67, -96, -27, -109, -97]

        byte[] bytes2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2)); //[97, 105, -60, -29, -45, -76]

        //1.解码
        String str2 = new String(bytes1); // 平台默认方式
        System.out.println(str2); //ai你哟

        String str3 = new String(bytes1, "GBK");
        System.out.println(str3); //ai浣犲摕
    }

2.10 字符流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

FileReader

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 空参的方法读取数据:
public static void main(String[] args) throws IOException {

        //0.创建对象
        FileReader fr = new FileReader("day28_code/src/MyFileStream/a.txt");

        //1.读取数据
        /*read() 细节:
            * 1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
            * 2.在读取之后,方法的底层还会进行解码并转成十进制
            *   最终把这个十进制作为返回值
            *   这个十进制的数据也表示在字符集上的数字*/
        int ch = 0;
        while ((ch = fr.read())!=-1){
            System.out.print((char) ch);
        }

        //2.释放资源
        fr.close();
    }
  • 带参方法读取数据
public static void main(String[] args) throws IOException {
        //0.创建对象
        FileReader fr = new FileReader("day28_code/src/MyFileStream/a.txt");

        //1.读取数据
        char[] chars = new char[2];
        int len;
        while ((len = fr.read(chars)) != -1) {
            System.out.print(new String(chars, 0, len));
        }

        //2.释放资源
        fr.close();
    }
  • read(chars):读取数据,解码,强转三步合并了,把强转 之后的字符房嫂数组当中
  • 空惨的read + 强转类型转换

FileWriter

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("day28_code/src/MyFileStream/b.txt", true);

        //写出一个字符
//        fw.write(25105);

        //写出一个字符串
//        fw.write("程序员");

        //写出一个字符串的一部分
//        fw.write("Java程序员很牛",0,7);

        //写出一个字符数组
        /*char[] chars = {'a', 'b', 'c'};
        fw.write(chars);*/

        //写出字符数组的一部分
        fw.write("\r\n");

        char[] chars = {'a', 'b', 'c'};
        fw.write(chars, 1, chars.length - 1);

        fw.close();
    }

字符流原理解析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.11 综合练习

在这里插入图片描述

练习1:(拷贝)

需求:
	拷贝一个文件夹,考虑子文件夹
public static void main(String[] args) throws IOException {
        //0.创建对象
        File src = new File("day28_code\\src\\MyTest\\src");
        File dest = new File("day28_code\\src\\MyTest\\dest");

        //1.调用方法copy
        copyDir(src,dest);
    }

    /*作用:拷贝文件
    * 参数一:要拷贝的文件(数据源)
    * 参数二:目的地*/
    private static void copyDir(File src, File dest) throws IOException {
        dest.mkdirs();

        //0.进入数据源
        File[] files = src.listFiles();

        //1.遍历数组
        for (File file : files) {
            if (file.isFile()){
                //2.判断-文件-copy
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream(new File(dest, file.getName()));

                byte[] bytes = new byte[1024];
                int len;
                while ((len = fis.read(bytes)) != -1){
                    fos.write(bytes,0,len);
                }
                fos.close();
                fis.close();
            }else {
                //3.判断-文件夹-递归
                copyDir(file,new File(dest,file.getName()));
            }
        }
    }

练习2:(文件加密)

为了保证文件的安全性,就需要对原始文件进行加密存储,再使用的的时候再对其进行解密处理。
加密原理:
	对原始文件中的每一个字节数据进行更改,然后将更改以后得数据存储到新的文件中
解密原理:
读取加密之后的文件,按照加密的规则反向操作,变成原始文件。

加密:

public static void main(String[] args) throws IOException {
        /*
        * ^ : 异或
                 两边相同:false
                 两边不同:true

                 0:false
                 1:true

               100:1100100
               10: 1010

               1100100
             ^ 0001010
             __________
               1101110
             ^ 0001010
             __________
               1100100
           */

        //0.创建对象关联原始文件
        FileInputStream fis = new FileInputStream("day28_code\\src\\MyTest\\a.jpg");
        //1.创建对象关联加密文件
        FileOutputStream fos = new FileOutputStream("day28_code\\src\\MyTest\\ency.jpg");

        //2.加密处理
        int len;
        while ((len = fis.read()) != -1){
            fos.write(len ^ 2);// 任意一个数字
        }

        //3.关流
        fos.close();
        fis.close();
    }

解密:

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

        //0.创建对象关联原始文件
        FileInputStream fis = new FileInputStream("day28_code\\src\\MyTest\\ency.jpg");
        //1.创建对象关联加密文件
        FileOutputStream fos = new FileOutputStream("day28_code\\src\\MyTest\\redu.jpg");

        //2.解密处理
        int len;
        while ((len = fis.read()) != -1){
            fos.write(len ^ 2);
        }

        //3.关流
        fos.close();
        fis.close();
    }

练习3:(修改文件中的数据)

文本文件中有以下的数据:
	2-1-9-4-7-8
将文件中的数据进行排序,变成一下的数据:
	1-2-4-7-8-9

解法1:

public static void main(String[] args) throws IOException {
        /*文本文件中有以下的数据:
		        2-1-9-4-7-8
	      将文件中的数据进行排序,变成一下的数据:
		        1-2-4-7-8-9
		*/

        //0.读取数据
        FileReader fr = new FileReader("day28_code\\src\\MyTest\\Test4.txt");
        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch = fr.read()) != -1) {
            sb.append((char) ch);
        }
        fr.close();

        //1.排序
        String str = sb.toString();
        String[] arrStr = str.split("-");

        ArrayList<Integer> list = new ArrayList<>();
        for (String s : arrStr) {
            int num = Integer.parseInt(s);
            list.add(num);
        }

        Collections.sort(list);

        //2.写入文件
        FileWriter fw = new FileWriter("day28_code\\src\\MyTest\\Test4.txt");
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size() - 1) {
                fw.write(list.get(i) + "");
            } else {
                fw.write(list.get(i) + "-");
            }
        }

        fw.close();
    }

解法2:

public static void main(String[] args) throws IOException {
        /*文本文件中有以下的数据:
		        2-1-9-4-7-8
	      将文件中的数据进行排序,变成一下的数据:
		        1-2-4-7-8-9
		*/

        //0.读取数据
        FileReader fr = new FileReader("day28_code\\src\\MyTest\\Test4.txt");
        StringBuilder sb = new StringBuilder();
        int ch;
        while ((ch = fr.read()) != -1) {
            sb.append((char) ch);
        }
        fr.close();

        //1.排序
        Integer[] arr = Arrays.stream(sb.toString()
                        .split("-"))
                .map(Integer::parseInt)
                .sorted()
                .toArray(Integer[]::new);


        //2.写入文件
        FileWriter fw = new FileWriter("day28_code\\src\\MyTest\\Test4.txt");
        String s = Arrays.toString(arr).replace(", ", "-");
        String result = s.substring(1, s.length() - 1);
        System.out.println(result);
        fw.write(result);
        fw.close();
    }

三、高级流

3.1 缓冲流

3.1.1 字节缓冲流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day29_code\\src\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day29_code/src/copy.txt"));

        //1.循环读取数据并写到文件中
        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }

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

public static void main(String[] args) throws IOException {
        //0.创建缓冲流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("day29_code/src/a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day29_code/src/copy2.txt"));

        //1.循环读取数据并写到文件中
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }

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

在这里插入图片描述
在这里插入图片描述

3.1.2 字符缓冲流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
readLine()方法细节:

  • readLine方法在读取的时候,依次读一整行,遇到回车换行结束
  • 但是他不会把回车换行读到内存当中
public static void main(String[] args) throws IOException {
        //0.创建对象
        BufferedReader br = new BufferedReader(new FileReader("day29_code/src/a.txt"));

        //1.读取数据
        /*String line1 = br.readLine();
        System.out.println(line1);*/
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        //2.关流
        br.close();

    }
public static void main(String[] args) throws IOException {
        //0.创建对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("day29_code/src/b.txt",true));

        //1.写入数据
        bw.write("你嘴角上扬的样子,百度是搜不到的");
        bw.newLine();
        bw.write("我以后结婚,你一定要来哟!");
        bw.newLine();
        bw.write("我以后结婚,你一定要来哟!");
        //2.关流
        bw.close();
    }

在这里插入图片描述

3.2 综合练习

练习1(拷贝文件)

四种方式拷贝文件,并统计各自用时

在这里插入图片描述

public static void main(String[] args) throws IOException {
        /*四种方式拷贝文件,并统计各自用时*/

        long start = System.currentTimeMillis();
        method1(); // 共耗时:6.493 秒
//        method2(); // 共耗时:0.008 秒
//        method3(); // 共耗时:0.024 秒
//        method4(); // 共耗时:0.006 秒
        long end = System.currentTimeMillis();
        System.out.println("共耗时:" + (end - start) / 1000.0 + " 秒");
    }

    private static void method4() throws IOException {
        //字节缓冲流:一次读写一个字节数组
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\下载\\123.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day29_code/src/Test/copy.mp4"));
        byte[] bytes = new byte[8192];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bos.close();
        bis.close();
    }

    //字节缓冲流:一次读写一个字节
    private static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\下载\\123.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day29_code/src/Test/copy.mp4"));

        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }

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

    //字节流的基本流:一次读写一个字节数组
    private static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
        FileOutputStream fos = new FileOutputStream("day29_code/src/Test/copy.mp4");
        byte[] bytes = new byte[8192];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        fos.close();
        fis.close();
    }

    //字节流的基本流 一次读写一个字节4,588,568,576 字节
    private static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\下载\\123.mp4");
        FileOutputStream fos = new FileOutputStream("day29_code/src/Test/copy.mp4");

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

练习2(修改文本顺序)

需求:把《出师表》的文章顺序进行恢复到一个新文件中。
public static void main(String[] args) throws IOException {
        /*需求:把《出师表》的文章顺序进行恢复到一个新文件中。*/
        //0.创建对象
        BufferedReader br = new BufferedReader(new FileReader("day29_code/src/Test/csb.txt"));
        

        //1.读取数据
        String b;
        TreeSet<String> t = new TreeSet<>();
        while ((b = br.readLine()) != null) {
            t.add(b);
        }
        br.close();
        //2.恢复数据
        String[] arr = t.stream().sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int first = Integer.parseInt(String.valueOf(o1.charAt(0)));
                int second = Integer.parseInt(String.valueOf(o2.charAt(0)));

                return first - second;
            }
        }).toArray(String[]::new);

        //3.写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("day29_code/src/Test/newcsb.txt"));
        for (String s : arr) {
            System.out.println(s);
            bw.write(s);
            bw.newLine();
        }
        //4.关流
        bw.close();
        
    }

练习3(软件运行次数)

实现一个验证程序运行次数的小程序,要求如下:
	1. 当程序运行超过3次时给出提示:本软件只能免费使用3次,欢迎您注册会员后继续使用~
	2. 程序运行演示如下:
			第一次运行控制台输出:欢迎使用本软件,第1次使用免费~
			第二次运行控制台输出:欢迎使用本软件,第2次使用免费~
			第三次运行控制台输出:欢迎使用本软件,第3次使用免费~
			第四次及之后运行控制台输出:本软件只能免费使用3次,欢迎您注册会员后继续使用~
public static void main(String[] args) throws IOException {
        /*实现一个验证程序运行次数的小程序,要求如下:
		1. 当程序运行超过3次时给出提示:本软件只能免费使用3次,欢迎您注册会员后继续使用~
		2. 程序运行演示如下:
				第一次运行控制台输出:欢迎使用本软件,第1次使用免费~
				第二次运行控制台输出:欢迎使用本软件,第2次使用免费~
				第三次运行控制台输出:欢迎使用本软件,第3次使用免费~
				第四次及之后运行控制台输出:本软件只能免费使用3次,欢迎您注册会员后继续使用~*/

        //0.把文件中的数字读到内存中
        BufferedReader br = new BufferedReader(new FileReader("day29_code/src/Test/count.txt"));

        String line = br.readLine();
        int count = Integer.parseInt(line);
        br.close();
        //运行一次+1
        count++;
        //判断
        if (count <= 3) {
            System.out.println("欢迎使用本软件,第" + count + "次使用免费~");
        }else {
            System.out.println("本软件只能免费使用3次,欢迎您注册会员后继续使用~");
        }

        //把自增的count写入到文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("day29_code/src/Test/count.txt"));
        bw.write(count+"");
        bw.close();
    }

IO流的使用原则:随用随创建、什么时候不用什么时候关闭

3.3 转换流

在这里插入图片描述
转换流是字符流和字节流之间的桥梁
在这里插入图片描述
在这里插入图片描述

转换文件编码
需求1:手动创建一个GBK的文件,把文件中的中文读取到内存中,不能出现乱码
需求2:把一段中文按照GBK的方式写到本地文件
需求3:将本地文件中的GBK文件,转成UTF-8

需求1:

public static void main(String[] args) throws IOException {
        /*//0.创建对象并指定字符编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("day29_code\\src\\ConvertStream\\gbkfile.txt"),"GBK");
        //1.读取数据
        int ch;
        while ((ch = isr.read()) != -1) {
            System.out.print((char) ch);
        }
        isr.close();*/

        //以上这种方式已经被淘汰了
        //替代方案
        FileReader fr = new FileReader("day29_code\\\\src\\\\ConvertStream\\\\gbkfile.txt", Charset.forName("GBK"));
        //1.读取数据
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char) ch);
        }
        fr.close();

    }

需求2:

public static void main(String[] args) throws IOException {
        /*需求2:把一段中文按照GBK的方式写到本地文件*/

        /*//0.创建转换流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day29_code\\src\\ConvertStream\\a.txt"), "GBK");
        //1.写出数据
        osw.write("你好你好");
        //2.释放资源
        osw.close();*/

        //以上方式淘汰
        //替代方案
        FileWriter fw = new FileWriter("day29_code\\src\\ConvertStream\\a.txt", Charset.forName("GBK"), true);
        fw.write("\t\n我爱你");
        fw.close();
    }

需求3:将本地文件中的GBK文件,转成UTF-8

public static void main(String[] args) throws IOException {
        /*需求3:将本地文件中的GBK文件,转成UTF-8*/
        /*InputStreamReader isr = new InputStreamReader(new FileInputStream("day29_code\\src\\ConvertStream\\a.txt"), "GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day29_code\\src\\ConvertStream\\b.txt"),"UTF-8");

        int ch;
        while ((ch = isr.read())!=-1){
            osw.write(ch);
        }

        osw.close();
        isr.close();*/

        //替代方案
        FileReader fr = new FileReader("day29_code\\src\\ConvertStream\\a.txt", Charset.forName("GBK"));
        FileWriter fw = new FileWriter("day29_code\\src\\ConvertStream\\c.txt", Charset.forName("UTF-8"));

        int b;
        while ((b = fr.read()) != -1) {
            fw.write(b);
        }
        fw.close();
        fr.close();
    }
利用字节流读取文件中的数据,每次读一整行,而且不能出现乱码

1. 字节流在读取中文的时候,是会出现乱码的,但是字符流可以搞定
2. 字节流里面是没有读一整行的方法的,只有字符缓冲流才能搞定
public static void main(String[] args) throws IOException {
        /*利用字节流读取文件中的数据,每次读一整行,而且不能出现乱码

            1. 字节流在读取中文的时候,是会出现乱码的,但是字符流可以搞定
            2. 字节流里面是没有读一整行的方法的,只有字符缓冲流才能搞定*/

        /*FileInputStream fis = new FileInputStream("day29_code\\src\\ConvertStream\\newcsb.txt");
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);
        String str = br.readLine();
        System.out.println(str);
        br.close();*/

        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("day29_code\\src\\ConvertStream\\newcsb.txt")));
        String len;
        while ((len=br.readLine())!=null){
            System.out.println(len);
        }
        br.close();
    }

在这里插入图片描述

3.4 序列化流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package ObjectStream;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}


public static void main(String[] args) throws IOException {
        /*把一个对象写到本地文件中*/
        //0.创建学生对象
        Student s1 = new Student("zhangsan", 23);

        //1.创建序列化流的对象/对象操作输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day29_code\\src\\ObjectStream\\Student.txt"));

        //2.写出数据
        oos.writeObject(s1);

        //3.释放资源
        oos.close();
    }

3.5 反序列化流

在这里插入图片描述

public static void main(String[] args) throws IOException, ClassNotFoundException {
        //0.创建反序列化流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day29_code\\src\\ObjectStream\\Student.txt"));

        //1.读取数据
        Object o = ois.readObject();
        System.out.println(o);
        //2.释放资源
        ois.close();
    }

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package ObjectStream;

import java.io.Serializable;

public class Student implements Serializable {
    //第一种方法:手动添加
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

第二种方法:
在这里插入图片描述
之后应用
鼠标悬停在Student上可以看到
在这里插入图片描述
如果鼠标悬停没有显示,那么是版本不同换了位置,可以在File>Settings>Editor>Inspections>JVM languages下找到并勾选应用


之后ALT+Enter创建好就可以了。
在这里插入图片描述

public class Student implements Serializable {
    @Serial
    private static final long serialVersionUID = 2294754669754402810L;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

在这里插入图片描述
在这里插入图片描述
练习:用对象流读写多个对象

需求:将多个自定义对象序列化到文件中,但是由于对象的个数不确定,反序列化流该如何读取呢?
package Test;

import java.io.Serial;
import java.io.Serializable;

public class Student implements Serializable {
    @Serial
    private static final long serialVersionUID = 8986009981186061115L;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", address = " + address + "}";
    }
}

public static void main(String[] args) throws IOException {
        /*需求:将多个自定义对象序列化到文件中,但是由于对象的个数不确定,反序列化流该如何读取呢?*/

        //0.创建学生对象
        Student s1 = new Student("zhangsan", 23, "云南");
        Student s2 = new Student("lisi", 24, "北京");
        Student s3 = new Student("wangwu", 25, "四川");
        ArrayList<Student> list = new ArrayList<>();
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //1.创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day29_code/src/Test/Student.txt"));

        //2.写入数据
        oos.writeObject(list);

        //3.释放资源
        oos.close();
    }
public static void main(String[] args) throws IOException, ClassNotFoundException {
        //0.创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day29_code/src/Test/Student.txt"));

        //1.读取数据
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        for (Student s : list) {
            System.out.println(s);
        }

        //2.释放资源
        ois.close();
    }

3.6 打印流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws FileNotFoundException {
        //0.创建字节打印流的对象
        PrintStream ps = new PrintStream(new FileOutputStream("day29_code/src/PrintStream/a.txt"));

        //1.写入数据
        ps.println(97);
        ps.print(true);
        ps.printf("%s 爱上了 %s", "阿珍", "阿强");

        //2.释放资源
        ps.close();
    }

在这里插入图片描述
在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建字符打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("day29_code/src/PrintStream/a.txt"),true);

        //1.写出数据
        pw.println("今天你终于叫我的名字了,虽然交错了,但没关系~");
        pw.print("你好你好");
        pw.printf("%s 爱上了 %s", "阿珍", "阿强");
        //2.释放资源
        pw.close();
    }

在这里插入图片描述
在这里插入图片描述

3.7 解压缩流 / 压缩流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.7.1 解压缩流

在这里插入图片描述

public static void main(String[] args) throws IOException {
        //0.创建一个对象表示需要解压的文件
        File src = new File("day29_code\\src\\zipStream\\aaa.zip");
        //1.创建一个对象表示解压文件的存放目录
        File dest = new File("day29_code\\src\\zipStream\\");

        unZip(src, dest);

    }

    //定义一个方法用来解压文件
    private static void unZip(File src, File dest) throws IOException {
        //0.创建一个解压缩流用来读取压缩包中的数据
        ZipInputStream zis = new ZipInputStream(new FileInputStream(src));

        //1.读取数据
        ZipEntry entry;

        while ((entry = zis.getNextEntry()) != null) {
            System.out.println(entry);
            if (entry.isDirectory()) {
                //文件夹
                File file = new File(dest, entry.toString());
                file.mkdirs();
            } else {
                //文件
                FileOutputStream fos = new FileOutputStream(new File(dest, entry.toString()));
                int b;
                while ((b = zis.read()) != -1) {
                    fos.write(b);
                }

                fos.close();
                zis.closeEntry();
            }
        }
        zis.close();

    }

3.7.2 压缩流

在这里插入图片描述
单个文件:

public static void main(String[] args) throws IOException {
        //0.创建一个对象表示需要压缩的文件
        File src = new File("day29_code\\src\\a.txt");
        //1.创建一个对象表示压缩文件的存放目录
        File dest = new File("day29_code\\src\\");

        toZip(src, dest);
    }

    private static void toZip(File src, File dest) throws IOException {
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest, "a.zip")));

        //创建ZipEntry对象
        ZipEntry entry = new ZipEntry("a.txt");

        zos.putNextEntry(entry);

        //拷贝文件中的数据
        FileInputStream fis = new FileInputStream(src);
        int b;
        while ((b = fis.read()) != -1) {
            zos.write(b);
        }
        fis.close();
        zos.close();
    }

压缩文件夹

public static void main(String[] args) throws IOException {
        //0.创建File对象表示要压缩的文件夹
        File src = new File("day29_code/src/zipStream/bbb");
        //1.创建File对象表示压缩包放在哪里
        File parentFile = src.getParentFile();
        //2.创建对象表示压缩文件的路径
        File dest = new File(parentFile, src.getName() + ".zip");

        //3.创建压缩流关联压缩包
        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));

        //4.获取src里面的每一个文件,变成ZipEntry对象,放入到压缩包中

        toZip(src, zos, src.getName());

        //5.释放资源
        zos.close();
    }

    /*作用:获取src里面的每一个文件,变成ZipEntry对象,放入到压缩包当中
     *   参数一:数据源
     *   参数二:压缩流
     *   参数三:压缩包内部的路径*/
    private static void toZip(File src, ZipOutputStream zos, String name) throws IOException {
        //0.进入src文件夹
        File[] files = src.listFiles();
        //1.遍历数组
        for (File file : files) {
            if (file.isFile()) {
                //判断文件 将其变成ZipEntry对象,放到压缩包当中
                ZipEntry entry = new ZipEntry(name + "\\" + file.getName());
                zos.putNextEntry(entry);
                //读取文件中的数据
                FileInputStream fis = new FileInputStream(file);
                int b;
                while ((b = fis.read()) != -1) {
                    zos.write(b);
                }
                fis.close();
                zos.closeEntry();
            } else {
                //判断文件夹 递归
                toZip(file, zos, name + "\\" + file.getName());
            }
        }
    }

3.8 Commons-io

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


1,IOUtils(数据相关)

拷贝方法:

copy方法有多个重载方法,满足不同的输入输出流

IOUtils.copy(InputStream input, OutputStream output)

IOUtils.copy(InputStream input, OutputStream output, int bufferSize)//可指定缓冲区大小

IOUtils.copy(InputStream input, Writer output, String inputEncoding)//可指定输入流的编码表

IOUtils.copy(Reader input, Writer output)

IOUtils.copy(Reader input, OutputStream output, String outputEncoding)//可指定输出流的编码表

拷贝大文件的方法:

// 这个方法适合拷贝较大的数据流,比如2G以上

IOUtils.copyLarge(Reader input, Writer output) // 默认会用1024*4的buffer来读取

IOUtils.copyLarge(Reader input, Writer output, char[] buffer)//可指定缓冲区大小

将输入流转换成字符串

IOUtils.toString(Reader input)

IOUtils.toString(byte[] input, String encoding)

IOUtils.toString(InputStream input, Charset encoding)

IOUtils.toString(InputStream input, String encoding)

IOUtils.toString(URI uri, String encoding)

IOUtils.toString(URL url, String encoding)

将输入流转换成字符数组

IOUtils.toByteArray(InputStream input)

IOUtils.toByteArray(InputStream input, int size)

IOUtils.toByteArray(URI uri)

IOUtils.toByteArray(URL url)

IOUtils.toByteArray(URLConnection urlConn)

IOUtils.toByteArray(Reader input, String encoding)

字符串读写

IOUtils.readLines(Reader input)

IOUtils.readLines(InputStream input, Charset encoding)

IOUtils.readLines(InputStream input, String encoding)

IOUtils.writeLines(Collection<?> lines, String lineEnding, Writer writer)

IOUtils.writeLines(Collection<?> lines, String lineEnding, OutputStream output, Charset encoding)

IOUtils.writeLines(Collection<?> lines, String lineEnding, OutputStream output, String encoding)

从一个流中读取内容

IOUtils.read(InputStream input, byte[] buffer)

IOUtils.read(InputStream input, byte[] buffer, int offset, int length) IOUtils.read(Reader input, char[] buffer)

IOUtils.read(Reader input, char[] buffer, int offset, int length)

把数据写入到输出流中

IOUtils.write(byte[] data, OutputStream output)

IOUtils.write(byte[] data, Writer output, Charset encoding)

IOUtils.write(byte[] data, Writer output, String encoding)

IOUtils.write(char[] data, Writer output)

IOUtils.write(char[] data, OutputStream output, Charset encoding)

IOUtils.write(char[] data, OutputStream output, String encoding)

IOUtils.write(String data, Writer output)

IOUtils.write(CharSequence data, Writer output)

从一个流中读取内容,如果读取的长度不够,就会抛出异常

IOUtils.readFully(InputStream input, int length)

IOUtils.readFully(InputStream input, byte[] buffer)

IOUtils.readFully(InputStream input, byte[] buffer, int offset, int length) IOUtils.readFully(Reader input, char[] buffer)

IOUtils.readFully(Reader input, char[] buffer, int offset, int length)

比较

IOUtils.contentEquals(InputStream input1, InputStream input2) // 比较两个流是否相等

IOUtils.contentEquals(Reader input1, Reader input2)

IOUtils.contentEqualsIgnoreEOL(Reader input1, Reader input2) // 比较两个流,忽略换行符

其他方法

IOUtils.skip(InputStream input, long toSkip) // 跳过指定长度的流

IOUtils.skip(Reader input, long toSkip)

IOUtils.skipFully(InputStream input, long toSkip) // 如果忽略的长度大于现有的长度,就会抛出异常

IOUtils.skipFully(Reader input, long toSkip)

2,FileUtils(文件/文件夹相关)

复制文件夹

FileUtils.copyDirectory(File srcDir, File destDir) // 复制文件夹(文件夹里面的文件内容也会复制)

FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter) // 复制文件夹,带有文件过滤功能

FileUtils.copyDirectoryToDirectory(File srcDir, File destDir) // 以子目录的形式将文件夹复制到到另一个文件夹下

复制文件

FileUtils.copyFile(File srcFile, File destFile) // 复制文件

FileUtils.copyFile(File input, OutputStream output) // 复制文件到输出流

FileUtils.copyFileToDirectory(File srcFile, File destDir) // 复制文件到一个指定的目录

FileUtils.copyInputStreamToFile(InputStream source, File destination) // 把输入流里面的内容复制到指定文件

FileUtils.copyURLToFile(URL source, File destination) // 把URL 里面内容复制到文件(可以下载文件)

FileUtils.copyURLToFile(URL source, File destination, int connectionTimeout, int readTimeout)

把字符串写入文件

FileUtils.writeStringToFile(File file, String data, String encoding)

FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)

把字节数组写入文件

FileUtils.writeByteArrayToFile(File file, byte[] data)

FileUtils.writeByteArrayToFile(File file, byte[] data, boolean append) FileUtils.writeByteArrayToFile(File file, byte[] data, int off, int len) FileUtils.writeByteArrayToFile(File file, byte[] data, int off, int len, boolean append)

把集合里面的内容写入文件

// encoding:文件编码,lineEnding:每行以什么结尾

FileUtils.writeLines(File file, Collection<?> lines)

FileUtils.writeLines(File file, Collection<?> lines, boolean append)

FileUtils.writeLines(File file, Collection<?> lines, String lineEnding)

FileUtils.writeLines(File file, Collection<?> lines, String lineEnding, boolean append)

FileUtils.writeLines(File file, String encoding, Collection<?> lines)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, boolean append)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, String lineEnding)

FileUtils.writeLines(File file, String encoding, Collection<?> lines, String lineEnding, boolean append)

往文件里面写内容

FileUtils.write(File file, CharSequence data, Charset encoding)

FileUtils.write(File file, CharSequence data, Charset encoding, boolean append)

FileUtils.write(File file, CharSequence data, String encoding)

FileUtils.write(File file, CharSequence data, String encoding, boolean append)

文件移动

FileUtils.moveDirectory(File srcDir, File destDir) // 文件夹在内的所有文件都将移动FileUtils.moveDirectoryToDirectory(File src, File destDir, boolean createDestDir) // 以子文件夹的形式移动到另外一个文件下

FileUtils.moveFile(File srcFile, File destFile) // 移动文件

FileUtils.moveFileToDirectory(File srcFile, File destDir, boolean createDestDir) // 以子文件的形式移动到另外一个文件夹下

FileUtils.moveToDirectory(File src, File destDir, boolean createDestDir) // 移动文件或者目录到指定的文件夹内

清空和删除文件夹

FileUtils.deleteDirectory(File directory) // 删除文件夹,包括文件夹和文件夹里面所有的文件

FileUtils.cleanDirectory(File directory) // 清空文件夹里面的所有的内容

FileUtils.forceDelete(File file) // 删除,会抛出异常

FileUtils.deleteQuietly(File file) // 删除,不会抛出异常

创建文件夹

FileUtils.forceMkdir(File directory) // 创建文件夹(可创建多级)

FileUtils.forceMkdirParent(File file) // 创建文件的父级目录

获取文件输入/输出流

FileUtils.openInputStream(File file)

FileUtils.openOutputStream(File file)

读取文件

FileUtils.readFileToByteArray(File file) // 把文件读取到字节数组

FileUtils.readFileToString(File file, Charset encoding) // 把文件读取成字符串

FileUtils.readFileToString(File file, String encoding)

FileUtils.readLines(File file, Charset encoding) // 把文件读取成字符串集合

FileUtils.readLines(File file, String encoding)

测试两个文件的修改时间

FileUtils.isFileNewer(File file, Date date)

FileUtils.isFileNewer(File file, File reference)

FileUtils.isFileNewer(File file, long timeMillis)

FileUtils.isFileOlder(File file, Date date)

FileUtils.isFileOlder(File file, File reference)

FileUtils.isFileOlder(File file, long timeMillis)

文件/文件夹的迭代

FileUtils.iterateFiles(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.iterateFiles(File directory, String[] extensions, boolean recursive)

FileUtils.iterateFilesAndDirs(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.lineIterator(File file)

FileUtils.lineIterator(File file, String encoding)

FileUtils.listFiles(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

FileUtils.listFiles(File directory, String[] extensions, boolean recursive)

FileUtils.listFilesAndDirs(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)

其他

FileUtils.isSymlink(File file) // 判断是否是符号链接

FileUtils.directoryContains(File directory, File child) // 判断文件夹内是否包含某个文件或者文件夹

FileUtils.sizeOf(File file) // 获取文件或者文件夹的大小

FileUtils.getTempDirectory()// 获取临时目录文件

FileUtils.getTempDirectoryPath()// 获取临时目录路径

FileUtils.getUserDirectory()// 获取用户目录文件

FileUtils.getUserDirectoryPath()// 获取用户目录路径

FileUtils.touch(File file) // 创建文件

FileUtils.contentEquals(File file1, File file2) // 比较两个文件内容是否相同

FilenameUtils(文件名/后缀名相关)

FilenameUtils.concat(String basePath, String fullFilenameToAdd) // 合并目录和文件名为文件全路径

FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名

FilenameUtils.getExtension(String filename) // 获取文件的后缀

FilenameUtils.getFullPath(String filename) // 获取文件的目录

FilenameUtils.getName(String filename) // 获取文件名

FilenameUtils.getPath(String filename) // 去除盘符后的路径

FilenameUtils.getPrefix(String filename) // 盘符

FilenameUtils.indexOfExtension(String filename) // 获取最后一个.的位置

FilenameUtils.indexOfLastSeparator(String filename) // 获取最后一个/的位置

FilenameUtils.normalize(String filename) // 获取当前系统格式化路径

FilenameUtils.removeExtension(String filename) // 移除文件的扩展名

FilenameUtils.separatorsToSystem(String path) // 转换分隔符为当前系统分隔符

FilenameUtils.separatorsToUnix(String path) // 转换分隔符为linux系统分隔符

FilenameUtils.separatorsToWindows(String path) // 转换分隔符为windows系统分隔符

FilenameUtils.equals(String filename1, String filename2) // 判断文件路径是否相同,非格式化

FilenameUtils.equalsNormalized(String filename1, String filename2) // 判断文件路径是否相同,格式化

FilenameUtils.directoryContains(String canonicalParent, String canonicalChild) // 判断目录下是否包含指定文件或目录

FilenameUtils.isExtension(String filename, String extension) // 判断文件扩展名是否包含在指定集合(数组、字符串)中

FilenameUtils.wildcardMatch(String filename, String wildcardMatcher) // 判断文件扩展名是否和指定规则匹配


Hutool工具包

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
官网:
https://hutool.cn/
API文档:
https://apidoc.gitee.com/dromara/hutool/

中文使用文档:
https://hutool.cn/docs/#/

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/436702.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

python之海龟绘图

海龟绘图&#xff08;turtle&#xff09;是一个Python内置的绘图库&#xff0c;也被称为“Turtle Graphics”或简称“Turtles”。它采用了一种有趣的绘图方式&#xff0c;模拟一只小海龟在屏幕上爬行&#xff0c;而小海龟爬行的路径就形成了绘制的图形。这种绘图方式最初源自20…

某资产管理系统打点过程中的免杀经历

上周&#xff0c;被扔过来单位内部的一个链接&#xff0c;让渗透一下&#xff0c;本以为三下五除二很快就能测完&#xff0c;没想到在对抗杀软时费了一番功夫&#xff0c;再加上杂七杂八的事儿&#xff0c;经过了一个星期才测完(&#xff03;&#xffe3;&#xff5e;&#xff…

API(接口) | 软件组件之间信息交互的“桥梁”

Hi&#xff0c;大家好&#xff0c;我是半亩花海。本文主要从 API 的定义、包含、用途和其他方面来简单地介绍 API&#xff08;接口&#xff09; ——软件组件之间信息交互的“桥梁”。 目录 一、什么是 API&#xff1f; 二、 API 中所包含哪些&#xff1f; 补充 三、API 可…

SQL server内存问题排查方案

前言 由于昨晚线上服务器数据库突然访问数据缓慢&#xff0c;任务管理里面SQL server进程爆满等等&#xff0c;重大事故的排查拟写解决方案。 整体思路 查询数据库请求连接&#xff1a;排查连接池是否占满查询数据库请求量&#xff1a;排查数据是否存在反复查询查询数据库阻…

Mysql 学习(十五)redo 日志

redo 日志 什么是redo日志&#xff1f;在说这个之前我们先来想一个场景&#xff0c;在访问磁盘的页面之前&#xff0c;我们会先把页面缓存到Buffer Pool之后&#xff0c;才会访问。写页面的时候也会先将buffer pool中的页面修改之后&#xff0c;然后在某个时机才会刷新到磁盘中…

【Oracle Database】如何远程连接服务器、创建用户、从本地dmp导入表

C:\Users\test>imp test/123456ip/orcl:1521 fileE:\db.dmp tablestable1,table2Import: Release 11.2.0.3.0 - Production on 星期一 3月 4 12:59:09 2024Copyright (c) 1982, 2011, Oracle and/or its affiliates. All rights reserved.IMP-00058: 遇到 ORACLE 错误 1263…

vue3 vue-i18n 多语言

1. 安装 npm install vue-i18n -s 2. 引入main.js import { createI18n } from vue-i18n import messages from ./i18n/index const i18n createI18n({legacy: false,locale: Cookies.get(language) || en_us, // set localefallbackLocale: en_us, // set fallback local…

Spring面向切片编程AOP概念及相关术语(一)

个人名片&#xff1a; &#x1f43c;作者简介&#xff1a;一名大三在校生&#xff0c;喜欢AI编程&#x1f38b; &#x1f43b;‍❄️个人主页&#x1f947;&#xff1a;落798. &#x1f43c;个人WeChat&#xff1a;hmmwx53 &#x1f54a;️系列专栏&#xff1a;&#x1f5bc;️…

面试问答之Spring进阶

文章目录 &#x1f412;个人主页&#xff1a;信计2102罗铠威&#x1f3c5;JavaEE系列专栏&#x1f4d6;前言&#xff1a;&#x1f380;说说你对Spring的认识与理解&#x1f415;Bean的分类&#x1f415; BeanFactory 接口和ApplicationContex 接口 的区别&#x1f415;SpringBe…

Canvas笔记04:绘制九大基本图形的方法,重头戏是贝塞尔曲线

hello&#xff0c;我是贝格前端工场&#xff0c;最近在学习canvas&#xff0c;分享一些canvas的一些知识点笔记&#xff0c;本期分享canvas绘制图形的知识&#xff0c;欢迎老铁们一同学习&#xff0c;欢迎关注&#xff0c;如有前端项目可以私信贝格。 Canvas是HTML5中的一个绘…

ROS2学习(七) Foxy版本ros2替换中间件。

在ros2使用的过程中&#xff0c;一开始选用的foxy版本&#xff0c;后来发现&#xff0c;foxy版本的ros2有很多问题。一个是foxy版本已经停止维护了。另一个问题是这个版本有很多bug, 后续的版本在功能实现上做了很大的改动&#xff0c;甚至说进行了重写。修复的一些问题&#x…

【Flink网络传输】ShuffleMaster与ShuffleEnvironment创建细节与提供的能力

文章目录 一. Taskmanager之间传递数据细节二. ShuffleService的设计与实现三. 在JobMaster中创建ShuffleMaster四. 在TaskManager中创建ShuffleEnvironment五. 基于ShuffleEnvironment创建ResultPartition1. 在task启动时创建ResultPartition2. ResultPartition的创建与对数据…

WSL2安装+深度学习环境配置

WSL2安装深度学习环境配置 1 安装WSL22 配置深度学习环境1.1 设置用户名、密码1.2 安装cuda修改WSL安装路径 1.3 安装Anaconda 参考&#xff1a;搭建Windows Linux子系统&#xff08;WSL2&#xff09;CUDA环境 参考&#xff1a;深度学习环境配置 WindowsWSL2 1 安装WSL2 WSL …

java-springboot 源码 01

01.springboot 是一个启动器 先安装maven&#xff0c;按照网上的流程来。主要是安装完成后&#xff0c;要修改conf目录下的setting.xml文件。 添加&#xff1a;阿里云镜像 <mirror><id>aliyunmaven</id><mirrorOf>*</mirrorOf><name>ali…

判断连续数据同意特征的方法:插旗法

bool isMonotonic(int* nums, int numsSize) {int flag 2;for (int i 1; i < numsSize; i) {if (nums[i-1] > nums[i]) {if (flag 0)return false;flag 1;}else if (nums[i-1] < nums[i]) {if (flag 1)return false;flag 0;}}return true; }此代码较为简单&…

【Python】新手入门(8):什么是迭代?迭代的作用是什么?

【Python】新手入门&#xff08;8&#xff09;&#xff1a;什么是迭代&#xff1f;迭代有什么应用&#xff1f; &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;Matplotlib之旅&#xff1a;零基础精通数据可视化、Python基础【高质量合集】…

《时代教育》是什么级别的期刊?是正规期刊吗?能评职称吗?

问题解答 问&#xff1a;《时代教育》杂志是正规刊物吗&#xff1f; 答&#xff1a;是的&#xff0c;国家新闻出版总署正式备案的期刊 问&#xff1a;《时代教育》是什么级别刊物&#xff1f; 答&#xff1a;省级 主管单位&#xff1a;成都日报报业集团 主办单位&#x…

<C++>【继承篇】

​ ✨前言✨ &#x1f393;作者&#xff1a;【 教主 】 &#x1f4dc;文章推荐&#xff1a; ☕博主水平有限&#xff0c;如有错误&#xff0c;恳请斧正。 &#x1f4cc;机会总是留给有准备的人&#xff0c;越努力&#xff0c;越幸运&#xff01; &#x1f4a6;导航助手&#x1…

主题乐园如何让新客变熟客,让游客变“留客”?

群硕跨越时间结识了一位爱讲故事的父亲&#xff0c;他汇集了一群幻想工程师&#xff0c;打算以故事为基础&#xff0c;建造一个梦幻的主题乐园。 这个乐园后来成为全球游客最多、收入最高的乐园之一&#xff0c;不仅在2023财年创下了近90亿&#xff08;美元&#xff09;的营收…

软件测试必学的16个高频数据库操作及命令

数据库作为软件系统数据的主要存取与操作中心&#xff0c;广泛应用于企业当中。在企业中常用的数据库管理系统有 ORACLE、MS SQL SERVER、MySQL等。其中以免费的 MySQL 最多&#xff0c;特别在中小型互联网公司里。 因此&#xff0c;本文的数据库操作是基于 MySQL 数据库系统下…