Java高级教程秘籍-13章_IO流上

于 2024-08-19 11:31:25 发布
阅读量399 收藏 6
点赞数 11
分类专栏： Java基础&高级教程秘籍 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41171614/article/details/141320710
版权

📌Java高级教程秘籍-13章_IO流上

一、File类的使用

1.File类的理解

  1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
  2. File类声明在java.io包下
  3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
  4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".

2.File的实例化

2.1 常用构造器

【这个只是创建一个文件对象，而不是创建文件！】
File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)

2.2 路径的分类

相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径

说明：
IDEA中：
如果大家开发使用JUnit中的单元测试方法测试，相对路径即为当前Module下。
如果大家使用main()测试，相对路径即为当前的Project下。

Eclipse中：
不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

2.3 路径分隔符

windows和DOS系统默认使用“\”来表示
UNIX和URL使用“/”来表示

3.File类的常用方法

File类的获取功能
 public String getAbsolutePath()： 获取绝对路径
 public String getPath() ： 获取路径
 public String getName() ： 获取名称
 public String getParent()： 获取上层文件目录路径。若无，返回null
 public long length() ： 获取文件长度（即：字节数）。不能获取目录的长度。
 public long lastModified() ： 获取最后一次的修改时间，毫秒值
 public String[] list() ： 获取指定目录下的所有文件或者文件目录的名称数组
 public File[] listFiles() ： 获取指定目录下的所有文件或者文件目录的File数组

File类的重命名功能
 public boolean renameTo(File dest):把文件重命名为指定的文件路径

File类的判断功能
 public boolean isDirectory()： 判断是否是文件目录
 public boolean isFile() ： 判断是否是文件
 public boolean exists() ： 判断是否存在
 public boolean canRead() ： 判断是否可读
 public boolean canWrite() ： 判断是否可写
 public boolean isHidden() ： 判断是否隐藏

File类的判断功能
 public boolean isDirectory()： 判断是否是文件目录
 public boolean isFile() ： 判断是否是文件
 public boolean exists() ： 判断是否存在
 public boolean canRead() ： 判断是否可读
 public boolean canWrite() ： 判断是否可写
 public boolean isHidden() ： 判断是否隐藏

File类的创建功能
 public boolean createNewFile() ： 创建文件。 若文件存在， 则不创建， 返回false
 public boolean mkdir() ： 创建文件目录。 如果此文件目录存在， 就不创建了。
如果此文件目录的上层目录不存在， 也不创建。
 public boolean mkdirs() ： 创建文件目录。 如果上层文件目录不存在， 一并创建

注意事项：如果你创建文件或者文件目录没有写盘符路径， 那么， 默认在项目路径下。

File类的删除功能
 public boolean delete()： 删除文件或者文件夹

删除注意事项：
Java中的删除不走回收站。
要删除一个文件目录， 请注意该文件目录内不能包含文件或者文件目录

二、IO流概述

1.流的分类

1.操作数据单位：字节流【图片、视频，非文本数据】、字符流【文本】
2.数据的流向：输入流、输出流
3.流的角色：

  • 节点流【直接在文件上造一个流】、
  • 处理流【在直接流的基础上包了多层流，加快流的传输速度！】
    【处理流包括】
    缓冲流、转换流、标准输入输出流、数据流、打印流、对象流

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

2.流的体系结构

在这里插入图片描述

说明：红框对应的是IO流中的4个抽象基类。
蓝框的流需要大家重点关注。

3.重点说明的几个流结构

在这里插入图片描述

4.输入、输出的标准化过程

4.1 输入过程

① 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）
② 创建相应的输入流，将File类的对象作为参数，传入流的构造器中
③ 具体的读入过程：
创建相应的byte[] 或 char[]。
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。

4.2 输出过程

① 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）
② 创建相应的输出流，将File类的对象作为参数，传入流的构造器中
③ 具体的写出过程：
write(char[]/byte[] buffer,0,len)
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。

三、节点流（或文件流）

【节点流需要掌握！】

1.FileReader/FileWriter的使用：

1.1 FileReader的使用

将day09下的hello.txt文件内容读入程序中，并输出到控制台

说明点：

  1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
  2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
  3. 读入的文件一定要存在，否则就会报FileNotFoundException。
@Test
    public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
				// 这个一定要加上
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

1.2 FileWriter的使用

从内存中写出数据到硬盘的文件里。

说明：

  1. 输出操作，对应的File可以不存在的。并不会报异常
  2. File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    File对应的硬盘中的文件如果存在：
    如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原文件的覆盖 【append】
    如果流使用的构造器是：FileWriter(file,true):不会对原文件覆盖，而是在原文件基础上追加内容
@Test
public void testFileWriter() {
    FileWriter fw = null;
    try {
        //1.提供File类的对象，指明写出到的文件
        File file = new File("hello1.txt");

        //2.提供FileWriter的对象，用于数据的写出
        fw = new FileWriter(file,false);

        //3.写出的操作
        fw.write("I have a dream!\n");
        fw.write("you need to have a dream!");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.流资源的关闭
        if(fw != null){

            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.3 文本文件的复制：

@Test
    public void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File destFile = new File("爱情与友情1.jpg");


            //2.创建输入流和输出流的对象
             fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);


            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.FileInputStream / FileOutputStream的使用：

  1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
    【也可以用字节流复制文本文件，但是不能看！！】
  2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,…)，使用字节流处理
/*
实现对图片的复制操作
 */
@Test
public void testFileInputOutputStream()  {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //1.造文件
        File srcFile = new File("爱情与友情.jpg");
        File destFile = new File("爱情与友情2.jpg");

        //2.造流
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        //3.复制的过程
        byte[] buffer = new byte[5];
        int len;
        while((len = fis.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fos != null){
            //4.关闭流
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

【注意】
相对路径在IDEA和Eclipse中使用的区别？

IDEA:
如果使用单元测试方法，相对路径基于当前的Module的。
如果使用main()测试，相对路径基于当前Project的。

Eclipse:
单元测试方法还是main(),相对路径都是基于当前Project的。

【文件复制！】

// FileInputStream、 FileOutputStream指定路径下文件的复制
public void copyFile(String srcPath, String destPath) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    // FileReader fis=null;
    // FileWriter fos=null;
    try {
        //造文件对象
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);

        //造流
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        // fis = new FileReader(srcFile);
        // fos = new FileWriter(destFile);

        //复制的过程
        //数组的长度会直接影响复制的时间
        byte[] buffer = new byte[1024];
        // char[] buffer = new char[1024];
        int len;
        while ((len = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, len);
            System.out.println(buffer);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (fos != null) {
            //
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、缓冲流的使用

【缓冲流是处理流的一种！！；掌握】

1.缓冲流涉及到的类：

  • BufferedInputStream
  • BufferedOutputStream
  • BufferedReader
  • BufferedWriter

2.作用：

作用：提高流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区。默认情况下是8kb

3.处理流，就是“套接”在已有的流的基础上。

在这里插入图片描述

【记事本中的编码集是uft-8！】

3.典型代码

3.1 使用BufferedInputStream和BufferedOutputStream:处理非文本文件

//实现文件复制的方法
    public void copyFileWithBuffered(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

3.2 使用BufferedReader和BufferedWriter：处理文本文件

    @Test
    public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("dbcp.txt")));
            bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//    //            bw.flush();
//            }

            //方式二：使用String
            String data;
            while((data = br.readLine()) != null){
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data);  //data中不包含换行符
                bw.newLine();    //提供换行的操作
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(bw != null){

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

【文件复制！】

// BufferedInputStream、 BufferedOutputStream实现文件复制的方法
    public void copyFileWithBuffered(String srcPath, String destPath) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            //2.造流
            //2.1 造节点流
            FileInputStream fis = new FileInputStream((srcFile));
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制的细节：读取、写入
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

/*
    使用BufferedReader和BufferedWriter实现文本文件的复制
*/
    @Test
    public void testBufferedReaderBufferedWriter() {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("dbcp.txt")));
            bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

            //读写操作
            //方式一：使用char[]数组
   //         char[] cbuf = new char[1024];
   //         int len;
   //         while((len = br.read(cbuf)) != -1){
   //             bw.write(cbuf,0,len);
   // //            bw.flush();
   //         }

            //方式二：使用String
            String data;
            while ((data = br.readLine()) != null) {
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二：
                bw.write(data); //data中不包含换行符
                bw.newLine(); //提供换行的操作
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

五、转换流的使用

【转换流掌握】

1.转换流涉及到的类：属于字符流

InputStreamReader：将一个字节的输入流转换为字符的输入流
解码：字节、字节数组 —>字符数组、字符串

OutputStreamWriter：将一个字符的输出流转换为字节的输出流
编码：字符数组、字符串 —> 字节、字节数组

说明：编码决定了解码的方式

【控制台，】

2.作用：提供字节流与字符流之间的转换

3.图示：

在这里插入图片描述

4.典型实现：

@Test
    public void test1() throws IOException {

        FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
        //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }

        isr.close();

    }

/*
此时处理异常的话，仍然应该使用try-catch-finally

综合使用InputStreamReader和OutputStreamWriter
 */
@Test
public void test2() throws Exception {
    //1.造文件、造流
    File file1 = new File("dbcp.txt");
    File file2 = new File("dbcp_gbk.txt");

    FileInputStream fis = new FileInputStream(file1);
    FileOutputStream fos = new FileOutputStream(file2);

    InputStreamReader isr = new InputStreamReader(fis,"utf-8");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

    //2.读写过程
    char[] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf)) != -1){
        osw.write(cbuf,0,len);
    }

    //3.关闭资源
    isr.close();
    osw.close();
}

5.说明：

文件编码的方式（比如：GBK），决定了解析时使用的字符集（也只能是GBK）。

1）编码集

1.常见的编码表

  • ASCII：【注意读音】美国标准信息交换码。【只适合英文字符集】
    用一个字节的7位可以表示。
  • ISO8859-1：拉丁码表。欧洲码表
    用一个字节的8位表示。
  • GB2312：中国的中文编码表。最多两个字节编码所有字符
  • GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
    【首位为0，一个字节表示一个字符，首位为1，两个字节表示一个中文字符！！】
  • Unicode：国际标准码，融合了目前人类使用的所字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
    在这里插入图片描述

2.对后面学习的启示

客户端/浏览器端 <----> 后台(java,GO,Python,Node.js,php) <----> 数据库

要求前前后后使用的字符集都要统一：UTF-8.

整理不易🚀🚀，关注和收藏后拿走📌📌欢迎留言🧐👋📣✨
快来关注我的公众号🔎AdaCoding 和 GitHub🔎 AdaCoding123
在这里插入图片描述

AdaCoding
关注
  • 11
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础教程秘籍-1章_Java语言概述
weixin_41171614的博客
05-01 779
Java基础教程秘籍-1章_Java语言概述
java io 字节流替换_Java基础17：Java IO流总结
weixin_31499919的博客
02-16 255
更多内容请关注微信公众号【Java技术江湖】这是一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！(关注公众号后回复”资料“即可领取 3T 免费技术学习资源以及我我原创的程序员校招指南、Java学习指...
Java高级--IO流
weixin_42450862的博客
09-29 467
Java高级--IO流
【JavaSE学习】04-2Java高级（文件处理-IO流）
weixin_48074431的博客
03-24 420
JavaSE（B站黑马）学习笔记 04-2Java高级（文件处理-IO流）
Java基础第十三章----IO流
qq_43562041的博客
04-16 771
说明：本文是跟着视频教程做的笔记 教程来源：java基础到高级_零基础自学Java–尚硅谷–宋红康 教程视频地址：java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibili 目录 一、File类的使用 1.File类的理解 2.File的实例化 3.File类的常用方法 二、IO流概述 1.流的分类 2.流的体系结构 3.重点说明的几个流结构 4.输入、输出的标准化过程 三、节点流（或文件流） 1.FileReader/FileWriter...
Java高级编程——IO流
qq_61524266的博客
06-16 609
Java高级编程——IO流
视频教程-IO流高级用法-Java
weixin_33576477的博客
05-28 112
IO流高级用法 工科硕士，持有高校计算机教师资格证书，从事计算机科学少儿分级...
Java 基础进阶篇（十五）：IO 流总结（全网最全面）
秀岩的博客
05-18 1300
前置内容：字符集 一、IO 流概述 二、字节流 三、字符流 四、缓冲流 五、转换流 六、序列化流 七、打印流 补充：Commons-IO 框架
java io目录_系统学习 Java IO ---- 目录，概览
weixin_31776191的博客
02-24 55
Java IO 类的系统教程，原创。主要参考自英文教程 Java IO Tutorial 和 Java Doc。http://tutorials.jenkov.com/java-io/index.html目的：掌握 Java IO 几乎所有类的基础用法，完全知道什么时候应该使用什么类。分开学习，先系统学习 IO 所有的类，再另外学习 NIO 。目录：先放一张 IO 类图，看着有点多(本教程还包含了...
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 13万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
Introduction-to-Java-IO.rar_Java IO Tutorial
09-19
通过学习“Introduction-to-Java-IO”教程，开发者不仅可以掌握基本的文件操作，还能深入了解Java NIO的高级特性，提升应用程序的性能和并发处理能力。而压缩包中的"Introduction-to-Java-IO.pdf"很可能是教程的详细...
guancg-j13_corejava_teacher-master_java_
10-04
标题中的"guancg-j13_corejava_teacher-master_java_"暗示了这是一个关于Java核心编程的教育项目，可能是某个在线课程或教程的代码库。描述提到的是"大型分布式，高并发，高可用，微服务，集群化商城项目"，这表明这...
尚硅谷_宋红康_第13章_IO流.pdf
07-05
·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千...
qing-hua-java-study.rar_better_hua_java 清华_java教程
09-23
此外，为了使学习者能更好地适应实际开发环境，教程还会涵盖IO流、多线程、网络编程、数据库操作等进阶主题。IO流允许程序进行输入输出操作，多线程则能实现程序的并发执行，提高系统效率；网络编程部分讲解了如何...
java IO流 教程宝典
05-24
Java IO流教程宝典 Java中的IO流是用于在程序与外部资源（如磁盘、网络、内存等）之间传输数据的重要工具。流的概念源于计算机科学中的数据流思想，它代表了数据的有序传输。在Java中，IO流提供了一种标准化的方式...
JAVA进阶补充
2301_80150315的博客
08-15 927
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Spring Boot实现简单的Oracle数据库操作
最新发布
beautiful77moon的博客
08-18 222
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
【Spring框架】
m0_71941456的博客
08-18 605
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 824
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值