Java进阶13讲__第十讲

已于 2024-09-06 18:05:41 修改
阅读量1.3k 收藏 7
点赞数 32
分类专栏： Java进阶13讲 文章标签： java python linux spring boot 开发语言 服务器 jvm
于 2024-09-06 14:52:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaomeiGuiSnJs/article/details/141915130
版权

IO流、File        

1.  File

1.1  创建对象

1.1.1  File指向

指向文件

File f1 = new File("E:\\TableFace\\Finished\\合同审核.txt");

指向文件夹 

File f2 = new File("E:\\TableFace\\Finished");

指向不存在文件 

File f2 = new File("E:\\TableFace\\Finished\\合同审核1.txt");

1.1.2  文件路径定位

绝对路径：包含盘符

File f4 = new File("E:\\Code\\itEE_SE_prove\\src\\a.txt");

相对路径：不含盘符，默认是直接去工程下寻找文件

File f5 = new File("src\\a.txt");

1.1.3  路径分隔符的三种写法

File f1 = new File("E:\\TableFace\\Finished\\合同审核.txt");
File f1 = new File("E:" + File.separator + "TableFace" + File.separator + "Finished" +             
          File.separator + "合同审核.txt");
File f1 = new File("E:/TableFace/Finished/合同审核.txt");

1.2  常用方法

1.2.1  判断文件类型、获取文件信息

package cn.hdc.itAdvance.d8.a_file;

import java.io.File;

/*
常用方法1：判断文件类型、获取文件信息
    boolean exists() 判断文件路径是否存在
    boolean isFile() 判断是否是文件(不存在的都是false)
    boolean isDirectory() 判断是否是文件夹(不存在的都是false)
    String getName() 获取文件/文件名，包含后缀
    long length() 获取文件大小，返回字节个数
    long lastModified() 获取最后修改时间
    string getPath() 获取创建对象时的路径
    String getAbsolutePath() 获取对象绝对路名
*/
public class Demo2 {
    public static void main(String[] args) {
        File f1 = new File("E:\\TableFace\\Finished");//文件夹-已存在
        File f11 = new File("E:\\TableFace\\Finished\\合同审核.txt");//文件-已存在
        File f2 = new File("E:\\TableFace\\Finished1");//文件夹-不存在
        File f21 = new File("E:\\TableFace\\Finished\\合同审核1.txt");//文件-不存在
        //boolean exists() 判断文件路径是否存在
        System.out.println(f1.exists());
        System.out.println(f11.exists());
        System.out.println(f2.exists());
        System.out.println(f21.exists());
        System.out.println("========================");
        //boolean isFile() 判断是否是文件
        System.out.println(f1.isFile());
        System.out.println(f11.isFile());
        System.out.println(f2.isFile());
        System.out.println(f21.isFile());
        System.out.println("========================");
        //boolean isDirectory() 判断是否是文件夹
        System.out.println(f1.isDirectory());
        System.out.println(f11.isDirectory());
        System.out.println(f2.isDirectory());
        System.out.println(f21.isDirectory());
        System.out.println("========================");
        //String getName() 获取文件/文件名，包含后缀
        System.out.println(f1.getName());
        System.out.println(f11.getName());
        System.out.println(f2.getName());
        System.out.println(f21.getName());
        System.out.println("========================");
        //long length() 获取文件大小，返回字节个数
        System.out.println(f1.length());
        System.out.println(f11.length());
        System.out.println(f2.length());
        System.out.println(f21.length());
        System.out.println("========================");
        //long lastModified() 获取最后修改时间
        System.out.println(f1.lastModified());
        System.out.println(f11.lastModified());
        System.out.println(f2.lastModified());
        System.out.println(f21.lastModified());
        System.out.println("========================");
        //string getPath() 获取创建对象时的路径
        System.out.println(f1.getPath());
        System.out.println(f11.getPath());
        System.out.println(f2.getPath());
        System.out.println(f21.getPath());
        System.out.println("========================");
        //String getAbsolutePath() 获取对象绝对路径
        System.out.println(f1.getAbsolutePath());
        System.out.println(f11.getAbsolutePath());
        System.out.println(f2.getAbsolutePath());
        File f = new File("src\\a.txt");
        System.out.println(f.getAbsolutePath());
    }
}

1.2.2  创建文件、删除文件

package cn.hdc.itAdvance.d8.a_file;

import java.io.File;
import java.io.IOException;

/*
File创建和删除方法
    boolean mkdir()   创建单级文件夹，创建失败返回false
    boolean mkdirs()   创建多级文件夹 (常用)

    boolean createNewFile()  创建文件，文件存在返回false

    boolean delete()  删除文件或空文件夹，删除失败返回false (注意: 删除方法不走回收站，填用)
*/
public class Demo3 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src\\test2");
        File f3 = new File("src\\test2\\del\\a.txt");
        File f2 = new File("src\\a1.txt");
        f2.createNewFile();
        //boolean mkdir()   创建单级文件夹，创建失败返回false
        f1.mkdir();
        //boolean mkdirs()   创建多级文件夹 (常用)
        f3.mkdirs();
        //boolean createNewFile()  创建文件，文件存在返回false
        f3.createNewFile();
        //boolean delete()  删除文件或空文件夹，删除失败返回false (注意: 删除方法不走回收站，填用)
        f1.delete();
        f2.delete();
        f3.delete();
    }
}

1.2.3  遍历文件夹

package cn.hdc.itAdvance.d8.a_file;
import java.io.File;
import java.util.Arrays;

/*
查看目录中的内容
    String[] list()	获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
    File[] listFiles()	获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回,包含隐藏文件（重点）

注意事项
    当主调是文件，或者路径不存在时，返回null
    当主调是空文件夹时，返回一个长度为0的数组
    当主调是一个非空文件夹，但是没有权限访问该文件夹时，返回null
*/
public class Demo4 {
    public static void main(String[] args) {
        //String[] list()  返回文件名数组
        File file = new File("S:\\");
        System.out.println(Arrays.toString(file.list()));
        //File[] listFiles() 返回文件数组
        System.out.println(Arrays.toString(file.listFiles()));
    }
}

1.3案例

案例一：寻找QQ.exe

方法1：

package cn.hdc.itAdvance.d8.a_file;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Demo6 {
    public static void main(String[] args) throws IOException {
        File rootDir = new File("S:\\");
        Scanner sc = new Scanner(System.in);
//        System.out.println("请输入你要查询的内容：");
//        String str = sc.next();
        searchFile(rootDir, "QQ.exe");
    }

    public static void searchFile(File file, String fileName) throws IOException {
        //1.拦截非法情况
        if (file == null || file.isFile() || !file.exists()) {
            return;
        }
        //2.file不是空，一定是目录对象
        //获取当前目录下的全部一级文件对象
        File[] arr = file.listFiles();
        //3.判断当前目录下是否存在一级文件目录，以及是否有权限可以拿到文件
        if (arr != null && arr.length > 0) {
            //4.遍历全部一级目录
            for (File f1 : arr) {
                //5.判断文件是文件还是文件夹
                if (f1.isFile()) {
                    //是文件、判断是不是我们找的文件
                    if (f1.getName().contains(fileName)) {
                        System.out.println(f1.getAbsolutePath());
//                        Runtime runtime = Runtime.getRuntime();
//                        runtime.exec(f1.getAbsolutePath());
                    }
                } else {
                    //是文件夹，继续搜索(递归)
                    searchFile(f1, fileName);
                }
            }
        }
    }
}

方法2：

package cn.hdc.itAdvance.d8.a_file;

import java.io.File;
import java.util.Arrays;
import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        File file = new File("S:\\");
        File[] f0 = file.listFiles();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要查询的内容：");
        String str = sc.next();
        System.out.println(f(f0, str));
    }

    public static String f(File[] f, String str) {
        if (f != null) {
            for (int i = 0; i < f.length; i++) {
                File item = f[i];
                if (item.isFile()) {
                    if (item.getName().equalsIgnoreCase(str)) {
                        return item.toString();
                    }
                } else if (item.isDirectory()) {
                    File f1 = new File(item.toURI());
                    File[] f2 = f1.listFiles();
                    if (f2 != null) {
                        // 递归调用 f 方法
//                        f(f2, str);
                        String result = f(f2, str);
                        if (!result.equals("未找到文件")) {
                            return result;
                        }

                    }
                }
            }
        }
        return "未找到文件";
    }

}

案例二：删除非空文件夹

2.  字符集

2.1  认识字符集

 2.2  UTF-8

2.3  Java完成编码、解码

package cn.hdc.itAdvance.d8.b_字符集;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/*
字符集
    ASCII字符集：只有英文、数字、符号等，占1个字节。
    GBK字符集：汉字占2个字节，英文、数字占1个字节。
    UTF-8字符集：汉字占3个字节，英文、数字占1个字节。

注意
    技术人员在开发时都应该使用UTF-8编码!
*/
public class Demo1 {
    public static void main(String[] args) {
        String data = "w思n、w姿n、w一r";
        byte[] b1 = data.getBytes();
        System.out.println(Arrays.toString(b1));
        try {
            byte[] b2 = data.getBytes("GBK");
            System.out.println(Arrays.toString(b2));
            //解码
            System.out.println(new String(b2));
            System.out.println(new String(b2, "GBK"));
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
}

3.I  O流基础

3.1  认识IO流

3.1.1  IO流概述

3.1.2  IO流应用场景 

 3.2  IO流分类体系

 4.  IO流增强

4.1  FileInputStream(文件字节输入流)

4.1.1  一次读取单个字节

        int b1 = is.read();
        System.out.println((char) b1);
        int b2 = is.read();
        System.out.println((char) b2);
        int b3 = is.read();
        System.out.println((char) b3);
        int b4 = is.read();
        System.out.println((char) b4);//
        //3. 如果流操作完毕, 应该主动关闭流
        is.close();
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1. 创建文件字节输入流(c_demo1.txt)
//        InputStream is1 = new FileInputStream(new File("src\\a.txt"));
        InputStream is = new FileInputStream("src\\a.txt");
        int b;
        while ((b = is.read()) != -1) {
            System.out.print((char) b);
        }
        /**
         * 缺点：
         * 读取数据的性能很差
         * 读取汉字输出会乱码！！无法避免！！
         */
        //3. 如果流操作完毕, 应该主动关闭流
        is.close();
    }
}

4.1.2  一次读取多个字节

package cn.hdc.itAdvance.d8.c_字节流;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/*
文件字节输入流(1次读多个字节)
    int read(byte[] buffer)	每次用一个字节数组去读取数据, 返回字节数组读取了多少个字节,如果发现没有数据可读会返回-1.
*/
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //1. 创建文件字节输入流(c_demo2.txt)
        InputStream is = new FileInputStream("src\\a.txt");
        //public int read(byte[] buffer) throws IOException
        //每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
        //2. 读取文件中的内容,读取多个字节
        byte[] buffer = new byte[2];
        int len = is.read(buffer);
        String res = new String(buffer);
        System.out.println(res);
        System.out.println(len);
        int len1 = is.read(buffer);
        //读取多少，倒出多少
        String res1 = new String(buffer, 0, len1);
        System.out.println(res1);
        System.out.println(len1);
        int len2 = is.read(buffer);
        System.out.println(len2);
    }
}

package cn.hdc.itAdvance.d8.c_字节流;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/*
文件字节输入流(1次读多个字节)
    int read(byte[] buffer)	每次用一个字节数组去读取数据, 返回字节数组读取了多少个字节,如果发现没有数据可读会返回-1.
*/
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //1. 创建文件字节输入流(c_demo2.txt)
        InputStream is = new FileInputStream("src\\a.txt");
        int len;
        byte[] arr = new byte[3];
        while ((len = is.read(arr)) != -1) {
            String str = new String(arr, 0, len);
            System.out.println(str);
        }
//性能得到明显提升,但是也无法避免读取汉字乱码问题
        is.close();
    }
}

4.1.3  一次读取全部字节

package cn.hdc.itAdvance.d8.c_字节流;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/*
文件字节输入流(1次读所有字节)

    方式1：自己定义一个字节数组与被读取的文件大小一样大，然后使用该字节数组，一次读完文件的全部字节。
        public int read(byte[] buffer)	每次用一个字节数组去读取，返回字节数组读取了多少个字节，如果发现没有数据可读会返回-1.

    方式2: Java官方为InputStream提供了如下方法，可以直接把文件的全部字节读取到一个字节数组中返回。
        public byte[] readAllBytes()   直接将当前字节输入流对应的文件对象的字节数据装到一个字节数组返回

*/
public class Demo3 {
    public static void main(String[] args) throws IOException {
        //1. 创建文件字节输入流(c_demo3.txt)
        InputStream is = new FileInputStream("src\\a.txt");
        //2. 读取文件中的内容
        //方式1: 定义一个跟文件同样大小的数组,一次接收所有
        long l = new File("src\\a.txt").length();
        byte[] bytes = new byte[(int) l];
        int len = is.read(bytes);
        System.out.println(new String(bytes));
        System.out.println(len);
        //方式2: 直接使用readAllBytes将文件中所有内容读取到数组
        byte[] arr = is.readAllBytes();
        System.out.println(new String(arr));
        System.out.println(arr.length);
        //3. 如果流操作完毕, 应该主动关闭流
        is.close();
    }
}

4.2  FileOutputStream(文件字节输出流)

package cn.hdc.itAdvance.d8.c_字节流;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/*
文件字节输出流
    作用:
        向文件中写入字节内容
    语法:
        FileOutputStream(String filepath)	创建字节输出流管道与源文件路径接通
        FileOutputStream(String filepath, boolean append)	创建字节输出流管道与源文件路径接通，可追加数据
    方法
        void write(int a)	写一个字节出去
        void write(byte[] buffer)	写一个字节数组出去
        void write(byte[] buffer, int pos, int len)  写一个字节数组的一部分出去
        void close()  关闭流
    注意:
        如果要写出换行, 需要写"\r\n"的字节数组表示形式
*/
public class Demo4 {
    public static void main(String[] args) throws Exception {
        //1.创建文件字节输出流通道
//        OutputStream os = new FileOutputStream("src\\write.txt");默认覆盖数据
        OutputStream os = new FileOutputStream("src\\write.txt", true);//加true改为追加数据
        //2.开始写字节数据出去
        os.write(97);// 97 就是一个字节，代表a
        os.write('b');//’b‘也是一个字节
//        os.write('王');//[o,o,o],默认只写一个字节
        os.write("\r\n".getBytes());
        byte[] bytes = "诺姿魏".getBytes();
        os.write(bytes, 3, 3);
        //关闭流
        os.close();
    }
}

4.3  字节流应用-文件复制

package cn.hdc.itAdvance.d8.c_字节流;

import java.io.*;

/*
文件复制
    源文件-->输入流-->程序-->输出流-->目标文件

步骤:
    1. 创建文件的输入流,对应到源文件; 创建文件输出流,对应到目标文件
    2. 使用输入流读取数据,使用输出流写出数据(边读边写)
    3. 释放资源(关闭流)
*/
public class Demo5 {
    public static void main(String[] args) throws Exception {
        InputStream is = new FileInputStream("S:\\芙宁娜.jpg");
        byte[] arr = is.readAllBytes();
        OutputStream os = new FileOutputStream("F:\\App\\fnn.png");//这里必须写名称
        os.write(arr);
        os.close();
        is.close();

    }
}

4.4  资源释放

4.4.1  方案一

package cn.hdc.itAdvance.d9.g_资源释放;

import java.io.*;

/*
try-catch-finally
    try {
        ...
    } catch (IOException e) {
        ...
    }finally{
        ...
    }

注意:
    1. finally代码块写在try-catch的最后面
    2. 无论try的代码是否出现问题, 最后一定会执行finally中的代码,除非JVM终止
*/
public class Demo1 {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream("S:\\芙宁娜.jpg");
            byte[] arr = is.readAllBytes();
            os = new FileOutputStream("F:\\App\\fnn.png");//这里必须写名称
            os.write(arr);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.4.2  方案二

package cn.hdc.itAdvance.d9.g_资源释放;

import java.io.*;

/*
try-with-resource
    JDK7开始提供的释放资源方式，编码更简洁


书写格式
    try(资源对象1,资源对象2..){
        ...
    }catch(Exception e){
        处理异常的代码
    }

注意:
    try后面小括号中只能定义资源对象，最终底层会帮我们释放这些对象
*/
public class Demo2 {
    public static void main(String[] args) throws Exception {
        try (
                InputStream is = new FileInputStream("S:\\芙宁娜.jpg");
                OutputStream os = new FileOutputStream("F:\\App\\fnn.png")
                //这里只能放置资源变量
        ) {
            byte[] arr = is.readAllBytes();
            os.write(arr);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

字节流：适合复制文件等，不适合读写文本文件 

4.5  FileReader(文件字符输入流)

package cn.hdc.itAdvance.d9.a_字符流;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/*
字符流
    字符输入流 Reader--FileReader
    字符输出流 Writer--FileWriter

FileReader
    创建对象
        public FileReader(File file);
        public FileReader(string pathname);
    读数据
        public int read() 一次读一个字符，返回字符对应的字，读到文件末尾返回-1
        public int read(char[] buffer) 一次读多个字符，返回本次读取的有效字节个数，读到文件末尾返回-1
*/
public class Demo1 {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("src\\a.txt")) {
//            int len;
//            while ((len = reader.read()) != -1) {
//                System.out.print((char) len);
//            }
            char[] arr = new char[3];
            int len;
            while ((len = reader.read(arr)) != -1) {
                System.out.print(new String(arr, 0, len));
            }
            //性能是比较不错的
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.6  FileWriter(文件字符输出流)

package com.itheima.a_字符流;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/*
字符流
    字符输入流 Reader--FileReader
    字符输出流 Writer--FileWriter

FileWriter
    创建对象
        public FileWriter(File file)	创建字节输出流管道与源文件对象接通
        public FileWriter(String filepath)	创建字节输出流管道与源文件路径接通
        public FileWriter(File file，boolean append)	创建字节输出流管道与源文件对象接通，可追加数据
        public FileWriter(String filepath，boolean append)	创建字节输出流管道与源文件路径接通，可追加数据
    写数据
        void write(int c)	写一个字符
        void write(String str)	写一个字符串
        void write(String str, int off, int len)	写一个字符串的一部分
        void write(char[] cbuf)	写入一个字符数组
        void write(char[] cbuf, int off, int len)	写入字符数组的一部分

注意:
    字符输出流写出数据后,必须刷新流(flush)或者关闭流(close),写出的数据才会生效,原因是有缓存区
    如果要换行, 需要输出"\r\n"字符串
*/
public class Demo2 {
    public static void main(String[] args) {
        try (
                Writer fw = new FileWriter("src\\b.txt", true);
        ) {
            // void write(int c)	写一个字符
            fw.write('a');
            fw.write("\r\n");
            // void write(String str)	写一个字符串
            fw.write("wsnwznwyrzqy");
            fw.write("\r\n");
            // void write(String str, int off, int len)	写一个字符串的一部分
            fw.write("wsnwznwyrzqy", 0, 3);
            // void write(char[] cbuf)	写入一个字符数组
            fw.write("\r\n");
            fw.write(new char[]{'W', 'A', 'N'});
            // void write(char[] cbuf, int off, int len)	写入字符数组的一部分
            fw.write("\r\n");
            fw.write(new char[]{'a', 't', 'm'}, 0, 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.6.*  字符输出流注意事项

        关闭流自动刷新流，关闭包含刷新操作，但是刷新后流还可以使用，关闭后流不可以使用缓冲区装满会自动刷新一部分到文件 

package com.itheima.a_字符流;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/*
字符流
    字符输入流 Reader--FileReader
    字符输出流 Writer--FileWriter

FileWriter
    创建对象
        public FileWriter(File file)	创建字节输出流管道与源文件对象接通
        public FileWriter(String filepath)	创建字节输出流管道与源文件路径接通
        public FileWriter(File file，boolean append)	创建字节输出流管道与源文件对象接通，可追加数据
        public FileWriter(String filepath，boolean append)	创建字节输出流管道与源文件路径接通，可追加数据
    写数据
        void write(int c)	写一个字符
        void write(String str)	写一个字符串
        void write(String str, int off, int len)	写一个字符串的一部分
        void write(char[] cbuf)	写入一个字符数组
        void write(char[] cbuf, int off, int len)	写入字符数组的一部分

注意:
    字符输出流写出数据后,必须刷新流(flush)或者关闭流(close),写出的数据才会生效,原因是有缓存区
    如果要换行, 需要输出"\r\n"字符串
*/
public class Demo2 {
    public static void main(String[] args) {
        try {
            Writer fw = new FileWriter("src\\b.txt", true);
            // void write(int c)	写一个字符
            fw.write('a');
            fw.write("\r\n");
            // void write(String str)	写一个字符串
            fw.write("wsnwznwyrzqy");
            fw.write("\r\n");
            // void write(String str, int off, int len)	写一个字符串的一部分
            fw.write("wsnwznwyrzqy", 0, 3);
            // void write(char[] cbuf)	写入一个字符数组
            fw.write("\r\n");
            fw.write(new char[]{'W', 'A', 'N'});
            // void write(char[] cbuf, int off, int len)	写入字符数组的一部分
            fw.write("\r\n");
            fw.write(new char[]{'a', 't', 'm'}, 0, 1);
            fw.flush();//刷新流
            fw.write("ssssssssssssssssssssssss");
            fw.flush();
            fw.close();//关闭流自动刷新流，关闭包含刷新操作，但是刷新后流还可以使用，关闭后流不可以使用
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.  缓冲流

5.1  字节缓冲流

package cn.hdc.itAdvance.d9.b_缓冲流;

import java.io.*;

/*
字节缓冲流
    自带8KB缓冲区, 减少了内存和硬盘之间的交互，从而提高原始流读、写数据的性能

字节缓冲流
    public BufferedInputStream(InputStream is); 底层提供8K的缓冲区，减少和内存和硬盘的交互，真正干活的还是字节输入流
    public BufferedOutputStream(OutputStream os);底层提供8K的缓冲区，减少和内存和硬盘的交互，真正干活的还是字节输出流
*/
public class Demo1 {
    public static void main(String[] args) {
        try (InputStream is = new FileInputStream("F:\\App\\fnn.png"); OutputStream os = new FileOutputStream("F:\\App\\fnn2.png");//这里必须写名称
             OutputStream bos = new BufferedOutputStream(os, 8192 * 2);//这里必须写名称
             InputStream bis = new BufferedInputStream(is, 8192 * 2)) {

            byte[] arr = bis.readAllBytes();
            bos.write(arr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 5.2  字符缓冲流

5.2.1  字符缓冲输入流

package cn.hdc.itAdvance.d9.b_缓冲流;

import java.io.*;

/*
字符缓冲流
    public BufferedReader(Reader r)	把低级的字符输入流包装成字符缓冲输入流管道，从而提高字符输入流读字符数据的性能
        public String readLine()	读取一行数据返回，如果没有数据可读了，会返回null

    public BufferedWriter(Writer r)	把低级的字符输出流包装成一个高级的缓冲字符输出流，从而提高字符输出流写数据的性能
        public void newLine()	换行
*/
public class Demo3 {
    public static void main(String[] args) {
        try (Reader reader = new FileReader("src\\a.txt");
             BufferedReader br = new BufferedReader(reader, 8192 * 2)) {
//            char[] arr = new char[3];
//            int len;
//            while ((len = br.read(arr)) != -1) {
//                System.out.print(new String(arr, 0, len));
//            }
            String len;
            while ((len = br.readLine()) != null) {
                System.out.println(len);
            }
            //性能是比较不错的

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

5.2.2  字符缓冲输出流

package cn.hdc.itAdvance.d9.b_缓冲流;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;

public class Demo4 {
    public static void main(String[] args) {
        try (Writer fw = new FileWriter("src\\b.txt");
             BufferedWriter bw = new BufferedWriter(fw)
        ) {
            bw.write("wsnwznwyrzqy1");
            bw.newLine();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 6.  缓冲流与原始流性能对比

package cn.hdc.itAdvance.d9.b_缓冲流;

import java.io.*;

//目标：观察原始流和缓冲流的性能。
public class Demo2 {
    // 复制的视频路径
    private static final String SRC_FILE = "F:\\App\\test.mp4";
    // 复制到哪个目的地
    private static final String DEST_FILE = "F:\\App\\SteamLibrary\\t1.mp4";

    public static void main(String[] args) throws IOException {
        copyUseFileInputStream();//不使用缓冲流
        copyUseBufferedInputStream();//使用缓冲流
    }

    private static void copyUseFileInputStream() throws IOException {
        long startTime = System.currentTimeMillis();
        //1. 创建文件字节输入流、输出流
        FileInputStream fis = new FileInputStream(SRC_FILE);
        FileOutputStream fos = new FileOutputStream(DEST_FILE);
        //2. 使用输入流读取内容,使用输出流写出内容
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        //3. 关闭流
        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();
        System.out.println("不使用缓冲流复制耗时：" + (endTime - startTime) + "ms");
    }

    private static void copyUseBufferedInputStream() throws IOException {
        long startTime = System.currentTimeMillis();
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SRC_FILE));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(DEST_FILE));
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bis.close();
        bos.close();
        long endTime = System.currentTimeMillis();
        System.out.println("使用缓冲流复制耗时：" + (endTime - startTime) + "ms");
    }
}

7.  转换流

7.1  引出问题：不同编码读取时会乱码

package cn.hdc.itAdvance.d9.c_转换流;

import java.io.*;

/*
问题描述:
    当程序使用的编码跟操作文档的编码不一致时,会出现乱码问题
    此时可以使用字符转换流
    它的思路是: 先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了
字符输入转换流
    public InputStreamReader(InputStream is ，String charset) 把原始的字节输入流，按照指定字符集编码转成字符输入流
*/
public class Demo1 {
    public static void main(String[] args) {
        //需求: 从c-1.txt读取内容
        //代码编码：UTF-8
//        try (Reader fr = new FileReader("src\\a.txt");//文本UTF-8 不乱码
        try (Reader fr = new FileReader("src\\c.txt");//文本GBK   乱码
             BufferedReader br = new BufferedReader(fr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7.2  字符输入转换流

package cn.hdc.itAdvance.d9.c_转换流;

import java.io.*;

/*
问题描述:
    当程序使用的编码跟操作文档的编码不一致时,会出现乱码问题
    此时可以使用字符转换流
    它的思路是: 先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了
字符输入转换流
    public InputStreamReader(InputStream is ，String charset) 把原始的字节输入流，按照指定字符集编码转成字符输入流
*/
public class Demo1 {
    public static void main(String[] args) {
        //需求: 从c-1.txt读取内容
        try (
                InputStream is = new FileInputStream("src\\c.txt");
                InputStreamReader isr = new InputStreamReader(is, "GBK");
                BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7.3  字符输出转换流

package cn.hdc.itAdvance.d9.c_转换流;

import java.io.*;

/*
问题描述:
    当程序使用的编码跟操作文档的编码不一致时,会出现乱码问题
    此时可以使用字符转换流
    它的思路是: 获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

字符输出转换流
    public OutputStreamWriter(OutputStream os，String charset)	可以把原始的字节输出流，按照指定编码转换成字符输出流
*/
public class Demo2 {
    public static void main(String[] args) {
        //需求: 向c-2.txt写出内容, 字符集为GBK
        try (
                OutputStream os = new FileOutputStream("src\\d.txt");//字节输出流
                OutputStreamWriter osw = new OutputStreamWriter(os, "GBK");//转GBK格式的字符输出流
                BufferedWriter bw = new BufferedWriter(osw);//包装缓冲流
        ) {
            bw.write("asgsb但凡阿萨联系人你确定陈老师搭嘎");
            bw.newLine();
            bw.write("dgdsafha但是股本溢价人不多深V在");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

8.  打印流

8.1  打印输入流

package cn.hdc.itAdvance.d9.d_打印流;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.Charset;

/*
PrintStream/PrintWriter（打印流）
    打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

构造器
    public PrintStream(OutputStream/File/String)	打印流直接通向字节输出流/文件/文件路径
    public PrintWriter(OutputStream/Writer/File/String)	打印流直接通向字符输出流/文件/文件路径

常用方法
    public void println(Xxx xx)	打印任意类型的数据出去
    public void write(int/byte[]/byte[]一部分)	可以支持写字节数据出去（PrintStream）
    public void write(int/String/char[]/..)	可以支持写字符数据出去（PrintWriter）

PrintStream和PrintWriter的区别
    打印数据的功能上是一样的：都是使用方便，性能高效
    PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法
    PrintWriter继承自字符输出流Writer，因此支持写字符数据出去
*/
public class Demo1 {
    public static void main(String[] args) {
        //PrintStream
        try (
//                PrintStream ps =
//                        new PrintStream("src\\F.txt", Charset.forName("GBK"));
                PrintStream ps =
                        new PrintStream("src\\F.txt");
        ) {
            ps.println(97);//写97就是97
            ps.write(97);//写97就是a
            ps.println('a');
            ps.println("safdsga啊沙发");//自动换行
//            ps.write("asKNDAkcjsfan代发惨了覅v".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
        //PrintWriter
    }
}

8.2  打印输出流

package cn.hdc.itAdvance.d9.d_打印流;

public class Demo1 {
    public static void main(String[] args) {
        try (
                PrintWriter pw =
                        new PrintWriter("src\\F.txt");
        ) {
            pw.println(97);//写97就是97
            pw.write("8");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

8.3  区别

8.4  打印流的应用

输出语句的重定向

package cn.hdc.itAdvance.d9.d_打印流;

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Demo2 {
    public static void main(String[] args) {
        try (
                PrintStream ps = new PrintStream("src\\redirect.txt");
        ) {
            System.out.println("这里重定向前输出语句位置是控制台");
            System.setOut(ps);//设置输出位置
            System.out.println("这里重定向了输出语句位置去了redirect.txt");
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

 9.  数据流

9.1  DataOutputStream 

//创建数据输出流,写出数据到文件
        try (
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("src\\d1.txt"));
        ) {
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("好的呢");
        } catch (Exception e) {
            e.printStackTrace();
        }

9.2  DataInputStream

try (DataInputStream dis
                     = new DataInputStream(new FileInputStream("src\\d1.txt"));
        ) {
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        }
package cn.hdc.itAdvance.d9.e_数据流;

import java.io.*;

/*
数据流
    为了保存数据而用的一种数据流, 数据流输出的数据不是给人看的,是为了保存
    数据输出流输出的数据,只能通过数据输入流读回程序

DataOutputStream(数据输出流)
    public DataOutputStream(OutputStream out)	创建新数据输出流包装基础的字节输出流

    public final void writeByte(int v) throws IOException	将byte类型的数据写入基础的字节输出流
    public final void writeInt(int v) throws IOException	将int类型的数据写入基础的字节输出流
    public final void writeDouble(Double v) throws IOException	将double类型的数据写入基础的字节输出流
    public final void writeUTF(String str) throws IOException	将字符串数据以UTF-8编码成字节写入基础的字节输出流
    public void  write(int/byte[]/byte[]一部分)	支持写字节数据出去

DataInputStream(数据输入流)
    public DataInputStream(InputStream is)	创建新数据输入流包装基础的字节输入流

    Public final byte readByte() throws IOException	读取字节数据返回
    public final int readInt() throws IOException	读取int类型的数据返回
    public final double readDouble() throws IOException	读取double类型的数据返回
    public final String readUTF() throws IOException	读取字符串数（UTF-8）据返回
    public int readInt()/read(byte[])	支持读字节数据进来
*/
public class Demo1 {
    public static void main(String[] args) {
        //创建数据输出流,写出数据到文件
        try (
                DataOutputStream dos =
                        new DataOutputStream(new FileOutputStream("src\\d1.txt"));
        ) {
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("好的呢");
        } catch (Exception e) {
            e.printStackTrace();
        }
        //创建数据输入流,读取数据到程序
        try (DataInputStream dis
                     = new DataInputStream(new FileInputStream("src\\d1.txt"));
        ) {
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

10.  序列化流

10.1  ObjectOutputStream

package cn.hdc.itAdvance.d9.f_序列化流;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/*
序列化与反序列化
    序列化: 将内存中的对象保存到磁盘文件
    反序列化: 将磁盘文件中的数据还原成内存对象

ObjectOutputStream(OutputStream out) 可以把Java对象进行序列化：把Java对象存入到文件中去。
    public final void writeObject(Object obj) 把对象写出去

public ObjectInputStream(InputStream is) 创建对象字节输入流，包装基础的字节输入流
    public final Object readObject()	把存储在文件中的Java对象读出来

注意
    对象如果要参与序列化，必须实现序列化接口（java.io.Serializable）
*/
public class Demo1 {
    public static void main(String[] args) {
        //1.创建一个对象字节输出流，包装原始字节输出流
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\a.txt"));
        ) {
            //0. 准备一个Student对象
            Student student = new Student("张三", 18);
            oos.writeObject(student);
            System.out.println("序列化成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//学生类//对象实现序列化必须实现Serializable接口
class Student implements Serializable {
    private String name;
    private Integer age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

10.2  ObjectInputStream

try (
        ObjectInputStream oos = new ObjectInputStream(new FileInputStream("src\\a.txt"));
) {
    //0. 准备一个Student对象
    Object o = oos.readObject();
    System.out.println(o);
} catch (Exception e) {
    e.printStackTrace();
}

10.3  transient

这个关键字修饰后的成员属性将不参与对象序列化。

10.4  补充

package cn.hdc.itAdvance.d9.f_序列化流;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/*
对象存储
    用一个ArrayList集合存储多个对象，然后直接对集合进行序列化即可
    注意：ArrayList集合已经实现了序列化接口！
*/
public class Demo2 {
    public static void main(String[] args) {
        //0. 准备一个Student对象的集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三", 18));
        students.add(new Student("李四", 19));
        students.add(new Student("王五", 20));
        //1. 序列化(f-1.txt)
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\f-1.txt"));
        ) {
            oos.writeObject(students);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //2. 反序列化(f-1.txt)
        try (
                ObjectInputStream oos = new ObjectInputStream(new FileInputStream("src\\f-1.txt"));
        ) {
            Object o = oos.readObject();
            System.out.println(o);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

11.  Commons-io

package com.itheima.h_IO框架;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;

/*
框架的形式
    一般是将类、接口等编译成class文件形式，再压缩成一个jar包发行(供别人使用)

Commons-io
    是Apache开源基金组织提供的一组关于IO操作的小框架，目的是提高IO相关操作开发的效率

使用步骤
    0、从官网下载IO的jar包
    1、在模块下新建Directory文件夹,名字叫lib
    2、将准备好的jar包复制到lib文件夹
    3、对着lib目录右键Add as Library..添加到项日环境中
    4、在需要使用的地方直接调用即可

常用工具类FileUtils
    public static void copyFile(File数据源，File目的地) 复制文件
    public static void copyDirectory(File 数据源，File目的地) 复制文件夹
    public static void deleteDirectory(File 目标文件夹) 删除文件夹(有内容也直接删)
    public static String readFileToString(File 数据源，String encoding) 读数据
    public static void writeStringToFile(File file,String data,String encoding, Boolean append) 写数据

常用工具类IOUtils类
    public static int copy(InputStream inputStream, OutputStream outputStream)	复制文件
    public static int copy(Reader reader, Writer writer) 	复制文件
    public static void write(String data, OutputStream output, String charsetName) 	写数据
*/
public class Demo1 {
    public static void main(String[] args) throws IOException {
//        FileUtils.copyFile(new File("src\\a.txt"), new File("src\\b.txt"));
//        FileUtils.copyDirectory(new File("F:\\App"), new File("src"));
        FileUtils.deleteDirectory(new File("src\\SteamLibrary"));
    }
}

 补充：

        原生Java也提供了一个工具类Files，可以实现一行代码解决问题，但是没有Apache提供的简便。

不再会有谎言
关注
专栏目录
Java进阶13讲__第十讲__精简
I am the light coursing in the soul of the moon.
09-06 272
对IO流的大部分方法进行了总结归纳
java 进阶教程_Java进阶教程 第2版
weixin_42196667的博客
02-25 203
第2版前言第1版前言语言基础篇第1章 Java语言概述1.1 Java语言简介1.1.1 Java语言的发展历程1.1.2 Java的版本历史1.1.3 Java语言与C／C1.1.4 Java的特点1.2 JDK和Java开发环境及工作原理1.2.1 JDK1.2.2 Java开发环境1.2.3 Java工作原理1.3 第一个Java程序1.3.1 Java Application程序第2版前言...
JAVA入门到进阶视频教程_JavaSE从入门到进阶视频教程
weixin_35797090的博客
02-27 150
JavaSE从入门到进阶视频教程，由源码时代(www.itsource.cn)讲师原创录制！转载请注明出处。教程列表：04_常用的DOS命令03_计算机相关常识了解02_今日课程介绍11_JDK的安装10_JDK的卸载09_相关术语了解JVM-JRE-JDK08_Java的跨平台原理07_Java语言的版本介绍06_编程语言了解05_常用的快捷键01_课程介绍21_Editplus配置编译运行Ja...
java进阶_Java核心技术(进阶)
weixin_42468901的博客
02-12 373
spContent=Java不仅是一门程序设计语言，而且发展为一个庞大的生态圈。Java被广泛应用到企业级系统、手机、桌面软件等开发，是就业市场最急需的技术。本课程讲授Java技术进阶部分，涉及多方位应用，并通过大量程序进行佐证讲解。学生学习课程后，可完成常见的功能应用开发。本课程是Java/EE、安卓等的先导课程。—— 课程团队课程概述本课程主要讲授Java核心技术进阶部分，以Java多方位应用...
java进阶篇_Java教程-Java零基础（进阶篇）
weixin_36166988的博客
02-12 750
Hi，大家好，小蛙又来了。小蛙趁着今天阳光明媚，万里无云的好天气就给给大家介绍另一套的基础教程视频是进阶篇的，通俗点讲也就是JavaSE。一般情况下的小萌新通常会问，什么是JavaSE呢？JavaSE能做什么呢？JavaSE是什么呢？能做什么呢？Java SE 是Java平台标准版的简称(Java Platform, Standard Edition) (also known as Java 2 ...
Java进阶学习资料.zip
06-21
在Java进阶学习中，你需要掌握以下几个关键的知识点： 1. 高级数据结构与算法：理解并能熟练运用ArrayList、LinkedList、HashMap等集合框架，深入研究Set、Queue、Stack等接口及其实现类。同时，学习并应用高级排序...
java-ppt.rar_java .ppt_java ppt_java基础 ppt_java基础 ppt_ppt jav
09-21
1. **Java环境搭建**：包括下载JDK（Java Development Kit），设置环境变量如JAVA_HOME, PATH, CLASSPATH，以及如何运行第一个Java程序——经典的"Hello, World!"。 2. **语法基础**：包括数据类型（基本类型如int,...
Java语言程序设计.进阶篇.原书第10版.pdf 电子书下载高清
08-16
Java语言程序设计.进阶篇.原书第10版.pdf java语言程序设计 进阶篇 本书是Java语言的经典教材 Java语言程序设计 进阶篇 原书第10篇版 正版内容下载，超高清，下载的亲们多多好评哦！
Java语言程序设计.进阶篇.原书第10版
10-31
原书第10版》是一本深入探讨Java编程技术的权威书籍，旨在帮助读者提升对Java编程语言的掌握程度。这本书详细讲解了Java的高级特性和应用，是Java程序员进阶学习的理想教材。 在Java语言中，进阶篇通常涵盖以下关键...
java进阶提高学习教程-13JVM与多线程.pptx
10-30
Java进阶学习教程中的第13章主要涵盖了JVM（Java虚拟机）和多线程两个核心概念。JVM是Java程序运行的基础，它负责解释执行字节码文件，并提供了Java语言的跨平台特性。Java程序通过JVM与操作系统交互，使得程序可以...
《Java语言程序设计（进阶篇）》 课后习题第25章代码chapter25.rar
07-04
以下将详细介绍第25章可能涉及的知识点，并根据通常的Java进阶内容进行扩展。 第25章可能涵盖的主题包括但不限于： 1. **多线程**：Java提供了强大的多线程支持，这可能是第25章的重点。学生可能需要理解和掌握`...
JAVA进阶资料 进阶资料
03-01
【Java进阶资料详解】 Java作为一款广泛应用的编程语言，其进阶学习涵盖了多个关键领域。这份资料集合了关于数据库管理、内存管理、服务器配置、性能优化以及消息中间件等多个主题，旨在帮助开发者深入理解Java技术...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 190
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 295
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 286
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 473
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 299
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 216
【代码】JAVA学习接口案例实例。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 691
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Spring资源加载模块，原来XML就这，活该被注解踩在脚下 手写Spring第六篇了
mkii_hong的博客
11-11 703
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值