Java-IO流知识整理

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量36 收藏
点赞数
分类专栏： JAVA 文章标签： java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Today_SEA/article/details/132895945
版权

Java-IO流知识整理

一、文件

1.1 概念

  • 保存数据的地方；

1.2 文件流

  • 文件在程序中是以流的形式来操作的；

  • 流：数据在 数据源(文件) 和 程序（内存） 之间经历的路径；

    • 输入流： 数据源(文件) ==> 程序（内存）
    • 输出流： 数据源(文件) <== 程序（内存）

    IOStream_1

1.3 常用的文件操作

  • （1）文件创建

    • 三种方式
    static void createFile_1(){//1.根据文件路径创建
        String  filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news01.txt";
        File file = new File(filePath);//在内存中，创建了File文件对象；

        try {
            file.createNewFile();//此时才会在磁盘对应位置创建文件并写入；
            System.out.println("文件" + file.getName() + "已创建");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static void createFile_2(){//2.根据父目录文件 + 文件名创建
        File parent = new File("D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile");
        String fileName = "news02.txt";

        File file = new File(parent, fileName);

        try {
            file.createNewFile();
            System.out.println("文件" + file.getName() + "已创建");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    static void createFile_3(){//3.根据父目录文件路径 + 文件名创建
        String parentPath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile";
        String fileName = "news03.txt";

        File file = new File(parentPath, fileName);

        try {
            file.createNewFile();
            System.out.println("文件" + file.getName() + "已创建");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

  • （2）获取文件信息

    • 常用的几个：
    static void getInfo(){
    File file = new File("D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news01.txt");

    System.out.println(" 文件名 ===== " + file.getName());

    System.out.println(" 绝对路径 ===== " + file.getAbsolutePath());

    System.out.println(" 父级目录 ===== " + file.getParent());

    System.out.println(" 文件大小（byte） ===== " + file.length());

    System.out.println(" 文件是否存在 ===== " + file.exists());

    System.out.println(" 是不是一个文件 ===== " + file.isFile());

    System.out.println(" 文件是不是一个目录 ===== " + file.isDirectory());
}

  • （3）目录操作和文件删除

    • 删除文件
    @Test
public void m1() {
    //1.判断 指定路径的文件是否存在，存在则删除；
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news01.txt";
    File file = new File(filePath);
    if (file.exists()) {
        if (file.delete()) {
            System.out.println("文件删除成功！");
        } else {
            System.out.println("文件删除失败！");
        }
    } else {
        System.out.println("文件不存在！");
    }
}
    • 删除（目录）文件
    @Test
public void m2() {
    //2.判断 指定目录 是否存在，存在则删除；
    //  目录也是一种文件!!
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile02";
    File file = new File(filePath);
    if (file.exists()) {
        if (file.delete()) {
            System.out.println("目录删除成功！");
        } else {
            System.out.println("目录删除失败！");
        }
    } else {
        System.out.println("该目录不存在！");
    }
}
    • 创建目录
    @Test
public void m3() {
    //3.判断 指定目录 是否存在，存在则提示存在，否则创建该目录；
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\a";
    File file = new File(filePath);
    if (file.exists()) {
        System.out.println("该目录已存在！");
    } else {
        if(file.mkdirs()){//创建多级目录mkdirs()，即在当前已存在的目录下，创建多级目录文件（...\\a\\b\\c\\d）
            // if(file.mkdir()){//创建一级目录mkdir()，即在当前已存在的目录下，创建一级目录文件(...\\a)
            System.out.println("该目录创建成功！");
        }
        else {
            System.out.println("该目录创建失败！");
        }
    }
}

二、IO流原理及流的分类

2.1 I/O原理

  • I/O技术：用于处理数据传输，如文件读/写，网络通讯等；
  • Java程序中，对于数据输入/输出操作以“流（stream）”的方式进行；
    • 输入流（input）：读取外部数据（可以是磁盘、光盘、另一个程序等等）到程序（内存）中；
    • 输出流（output）：将程序（内存）数据输出到外部存储设备或另一个程序
  • java.io包中提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法进行数据的输入或输出；

2.2 流的分类

  • 按操作数据单位不同：
    • 字节流(8 bit)
      • InputStream 和 OutputStream
      • 如：操作二进制文件（如视频，音频）时，使用字节流操作不会产生损失；
    • 字符流(字符，大小与文件编码有关)
      • Reader 和 Writer
      • 如：操作文本文件(文本文件里面都是字符)时，使用字符流操作比较好；
  • 按数据流的流向不同：
    • 输入流
    • 输出流
  • 按流的角色不同
    • 节点流
    • 处理流/包装流
（抽象基类）字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

上述四个类都是抽象类，可以通过实现子类来创建相应的对象，I/O流的子类都是以抽象父类作为后缀的

2.3 输入流

2.3.1 InputStream
  • 抽象类 ==> 输入流 ==> 字节流
  • 以字节为单位进行I/O操作
FileInputStream

  • 文件输入流（字节流）

  • new FileInputStream(File/String)

    • 一个字节一个字节读取
    @Test
public void read_FileInputStream_byte() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\hello1.txt";
    int read_index = 0;
    FileInputStream fi = null;
    try {
        fi = new FileInputStream(filePath);
        read_index = fi.read();
        while(read_index != -1){//read_index == -1时，文件到达末尾，读取结束！
            System.out.print((char)read_index);
            read_index = fi.read();
        }
        System.out.println();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {
        //这里不能直接访问trycatch子句中定义的流对象
        if(fi != null)
            fi.close();
    }
}
    • 通过byte数组，指定每次最多读取的字节数
    @Test
public void read_FileInputStream_byteArray() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\hello1.txt";
    int read_len = 0;
    byte[] buf = new byte[8];//让字节流一次最多读取8个字节
    FileInputStream fi = null;
    try {
        fi = new FileInputStream(filePath);

        while ((read_len = fi.read(buf)) != -1){//read(byte[])返回读取到的字节数
            System.out.print(new String(buf, 0, read_len));
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {
        //这里不能直接访问trycatch子句中定义的流对象
        if(fi != null)
            fi.close();
    }
}
BufferedInputStream

  • 继承关系：BufferedInputStream 继承 FliterInputStream 继承 InputStream

  • 带缓冲字节输入流（包装流，可以包装任意InputStream字节输入流及其实现子类）

ObjectInputStream
  • 对象字节输入流（节点-处理-输入流）
  • new ObjectInputStream(InpuSteam)
2.3.2 Reader
  • 抽象类 ==> 输入流 ==> 字符流
  • 以字符为单位进行I/O操作
FileReader

  • 继承关系：FileReader 继承 InputStreamReader 继承 Reader

  • 文件输入流（字符流）

  • new FileReader(File/String)

    • 一个字符一个字符读取
    @Test
public void read_FileReader_char() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news04.txt";
    int read_index = 0;
    FileReader fr = null;

    try {
        fr = new FileReader(filePath);
        while((read_index = fr.read()) != -1){
            System.out.print((char)read_index);
        }
        System.out.println();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {//记得关闭流！！
        if(fr != null)
            fr.close();
    }
}
    • 通过char数组读取
    @Test
public void read_FileReader_charArr() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news04.txt";
    int read_len = 0;
    char[] buf = new char[8];
    FileReader fr = null;

    try {
        fr = new FileReader(filePath);
        while((read_len = fr.read(buf)) != -1){
            //                System.out.print(new String(buf));
            System.out.print(new String(buf, 0, read_len));
        }
        System.out.println();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {//记得关闭流！！
        if(fr != null)
            fr.close();
    }
}
BufferedReader

  • 带缓冲字符输入流（包装流，可以包装不同的节点流）

  • new BufferedReader(new xxxReader)

    • 读取文件
    import java.io.*;

/**
 * @author: sea-365
 * @date: 2023/4/21 15:06
 */
public class FileIO_BufferedReader01 {
    public static void main(String[] args) throws IOException {
        String filePath = "./hsp_ch19/FileIO_create/FileIO_create01.java";
        //创建BufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(filePath)));
        //读取文件
        String line = bufferedReader.readLine();
        while(line != null){
            System.out.println(line);
            line = bufferedReader.readLine();
        }

        //关闭流
        bufferedReader.close();

    }
}
InputStreamReader
  • 转换流

2.4 输出流

2.4.1 OutputStream
  • 抽象类 ==> 输出流 ==> 字节流
  • 以字节为单位进行I/O操作
FileOutputStream

  • 文件输出流（字节流）

    • 若指定的文件不存在但所在目录存在，则会先创建该文件然后写入数据；
    @Test
public void write_FileOutputStream() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\hello2.txt";
    FileOutputStream fo = null;

    try {
        fo = new FileOutputStream(filePath, true);//true表示追加模式，默认为false覆盖模式；

        fo.write('a');//写入单个字节；

        fo.write("\nhello，北京\n".getBytes());//通过字节数组写入

        fo.write("\n1234567890\n".getBytes(), 3, 9);//写入字节数组指定范围内的数据

    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {
        if(fo != null)
            fo.close();
    }
}
BufferedOutputStream
  • 继承关系：BufferedOutputStream 继承 FliterOutputStream 继承 OutputStream
  • 带缓冲字节输出流（包装流，可以包装任意OutputStream字节输入流及其实现子类）
ObjectOutputStream
  • 对象字节输出流（节点-处理-输出流）
  • new ObjectOutputStream(OutputStream)
2.4.2 Writer

  • 抽象类 ==> 输入流 ==> 字符流

  • 以字符为单位进行I/O操作

FileWriter

  • 继承关系：FileWriter 继承 OutputStreamWriter 继承 Writer

  • 文件输出流（字符流）

  • FileWriter在使用结束后，必须使用close()关闭方法或flush()刷新方法，否则写入不到指定文件（还在内存中！！！）

    • 顺序：先flush()，后close()！

    • 两个方法的实现中都会将流里面的内容写入文件；

  • new FileWriter(File/String, true);//true表示追加内容，默认是false，覆盖模式；

    • 一个字符一个字符写入
    @Test
public void writer_FileWriter_char() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news05.txt";
    FileWriter fw = null;

    try {
        //fw = new FileWriter(filePath);//覆盖模式
        fw = new FileWriter(filePath, true);//追加模式
        fw.write('a');
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {//记得关闭或刷新流！！
        if(fw != null)
            fw.close();
    }
}
    • 指定char数组写入
    @Test
public void writer_FileWriter_charArr() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news05.txt";
    FileWriter fw = null;
    try {
        //fw = new FileWriter(filePath);//覆盖模式
        fw = new FileWriter(filePath, true);//追加模式
        fw.write("abcdefg\n".toCharArray());
        fw.write("abcdefgh\n".toCharArray(), 0, 3);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {//记得关闭或刷新流！！
        if(fw != null)
            fw.close();
    }
}
    • 字符串写入
    @Test
public void writer_FileWriter_String() throws IOException {
    String filePath = "D:\\JavaCode\\projects\\JavaDemo\\hsp_ch19\\testfile\\news05.txt";
    FileWriter fw = null;
    try {
        //fw = new FileWriter(filePath);//覆盖模式
        fw = new FileWriter(filePath, true);//追加模式
        fw.write("abcdefg\n");
        fw.write("abcdefgh\n", 0, 3);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    finally {//记得关闭或刷新流！！
        if(fw != null)
            fw.close();
    }
}
BufferedWriter

  • 带缓冲字符输出流

  • new BufferedWriter(new xxxWriter)

    • 字符串写入文件
    import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author: sea-365
 * @date: 2023/4/21 16:52
 */
public class FileIO_BufferedWriter01 {
    public static void main(String[] args) throws IOException {
        String filePath = "./hsp_ch19/testfile/bufferedwriter01.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(filePath)));

        bufferedWriter.write("我现在在学Java IO流，感觉不是很有意思啊。。。。");
        bufferedWriter.newLine();//插入一个和系统相关的换行符
        bufferedWriter.write("还是得学习！！！");

        bufferedWriter.close();
    }
}
OutputStreamWriter
  • 转换流

2.5 节点流和处理流

分类字节输入流字节输出流字符输入流字符输出流分类
抽象基类InputStreamOutputStreamReaderWriter
访问文件FileInputStreamFileOutputStreamFileReaderFileWriter节点流
访问数组ByteArrayInputStream节点流
访问管道PipedInputStream节点流
访问字符串节点流
缓冲流BufferedInputStream处理(包装)流
转换流处理(包装)流
对象流ObjectInputStream处理(包装)流
抽象基类
(继承自第二行的基类)		FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
打印流PrintStreamPrintWriter处理(包装)流
推回输入流PushbackInputStreamPushbackReader处理(包装)流
特殊流DataInputStreamDataOutputStream处理(包装)流
2.5.1 节点流
  • 节点流可以从一个**特定的数据源（存放数据的地方）**读写数据；
    • 如FileReader、FileWriter是从某个文件中读写数据；
2.5.2 处理流
  • 处理流也叫包装流，是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能；
    • 如BufferedReader、BufferedWriter；
  • 优点：
    • 1.性能的提升：主要以增加缓冲的方式来提高输入输出的效率；
    • 2.操作的便捷：处理流 可能提供一系列便捷的方法来一次性输入输出大批量数据，使用更加灵活；
2.5.3 区别和联系
  • 1.节点流是底层（低级）流，直接跟数据源相接；
  • 2.处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更加方便的输入输出方法；
  • 3.处理流对节点流进行包装，使用了修饰器设计模式，不与数据源直接相连；
2.5.4 标准输入输出流
流类型默认设备描述编译类型运行类型
System.inInputStream键盘标准输入InputStreamBufferedInputStream
System.outOutputStream显示器标准输出PrintStreamPrintStream
/**
 * @author: sea-365
 * @date: 2023/4/26 20:35
 */
public class FileIO_System01 {
    public static void main(String[] args) {
        System.out.println(System.in.getClass());
        System.out.println(System.out.getClass());
    }
}
  • 输出：

在这里插入图片描述

2.5.5 转换流

  • InputStreamReader

    • new InputStreamReader(InputStream)
    • new InputStreamReader(InputStream, Charset);//可以指定字符集将字节流转换为字符流;

  • OutputStreamWriter

    • new OutputStreamWriter(OutputStream)
    • new OutputStreamWriter(OutputStream, Charset)

  • 是Reader/Writer的子类，是字符流；

  • 处理纯文本数据时，使用字符流效率较高，可以有效解决中文乱码问题；

2.5.6 打印流
  • PrintStream/PrintWriter
  • 继承关系：
    • PrintStream 继承 FilterOutputStream 继承 OutputStream;
    • PrintWriter 继承 Wirter;
  • 字节流，只有输出流，没有输入流；

2.6 Properties

  • 例子：读取配置文件中的值
  • 配置文件如下：
ip=192.168.0.1
user=root;
password=123456
  • 不使用Properties类时
/**
 * @author: sea-365
 * @date: 2023/4/26 21:40
 */
public class FileIO_Properties01 {
    public static void main(String[] args) throws IOException {
        
        //不使用Properties类
        String filePath = "./hsp_ch19/testfile/mysql.properties";
        BufferedReader br = new BufferedReader(new FileReader(filePath));

        String line = "";

        while((line = br.readLine()) != null){
            String[] split = line.split("=");
            System.out.println(split[0] + "=" + split[1]);
        }
    }
}

  • Properties类介绍

    • 专门用于读写配置文件的集合类；
      • 格式：键=值
    • 注意：键值对中不需要空格，值不需要用引号，默认类型是String；

  • 使用Properties类

/**
 * @author: SEA
 * @date: 2023/4/27
 */
public class FileIO_Properties02{
    public static void main(String[] args) throws IOException {
        String filePath_1 = "./hsp_ch19/testfile/mysql.properties";
        String filePath_2 = "./hsp_ch19/testfile/mysql2.properties";
        //new一个Propertes对象
        Properties properties = new Properties();
        //加载指定的配置文件
        properties.load(new FileReader(filePath_1));
        //将指定配置文件中的配置信息打印到标准输出（显示器）
        properties.list(new PrintStream(System.out));


        Properties properties1 = new Properties();
        properties1.setProperty("email", "123456@163.com");
        properties1.setProperty("call", "123456789");
        properties1.setProperty("name", "张三");//出现中文，将会转换成Unicode编码进行保存
        properties1.store(new FileOutputStream(filePath_2), "");

        properties1.list(new PrintStream(System.out));

    }
}
SEA-365
关注
专栏目录
Java基础知识——JavaIO
weixin_45680007的博客
02-01 1万+
Java io IO的基本分类 同步和异步的区别：同步是线程去查看是否完成，异步是完成的数据去提醒线程已经完成 参考资料 data = socket.read();socket本意为套接字，为ip+端口，我理解为一个数据载体 (BIO)阻塞io：未请求到数据即让出cpu (NIO not block io)非阻塞io：在 while 循环中不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非...
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
Java IO流是Java平台中用于处理输入输出操作的重要部分，对于任何Java开发者，尤其是准备面试或希望在大型公司如阿里、腾讯工作的候选人来说，掌握IO流的知识是必不可少的。以下是对Java IO流的详细解析： **一、为...
Java中commons-IO
a1901149的博客
05-04 969
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
知识体系整理 -- Java的IO
Danny_idea的博客
04-09 762
Java领域的io模块是一个非常庞大的知识体系，在大家求职面试的过程中通常也是被问到比较多的一个模块，今天我特意整理了一份关于IO知识体系相关的干货和大家分享，希望各位读者们喜欢。 如何理解io流 io可以理解为是input 和 output的两个缩写，分别代表了数据的**”输入“和”输出“**。io流则是描述了将数据从内存和数据源之间拷贝的一个过程。 输入：数据从数据源加载到内存。 输出：数据从内存写回到数据源。 这里我所说的数据源是一个比较泛的名称，它可以是指 txt，图片，SQL，mp4等格式的文件。
Java基础---IO知识以及常用的API整理
stu_kk的博客
02-05 1097
自己整理的Java IO 知识
Java高频面试基础知识点整理
热门推荐
张彦峰的博客
11-04 167万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
Java——IO流超详细总结
ywb201314的专栏
08-18 6348
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。 在初学Java时，IO流是我遇到的一个很头疼的东西，Java IO 体系看起来类很多，感觉很复杂，但其实是 IO 涉及的因素太多了。在设计 IO 相关的类时，编写者也不是从同一个方面考虑的，所以会给人一种很乱的感觉，并且还有设计模式的使用，更加难以使用这些 IO 类，所以特地对 Java 的 IO 做一个总结。 1|0
【Java中IO流】面试知识点总结
02-02 5465
好久不见的IO流 对IO流的学习，我记得还是初学Java基础的时候，后来找工作过程中经常看到有些招聘信息中写到熟悉IO流，现在想想IO流，真的是一脸懵逼，不说这么多废话了，IO流这次好好整理一下。 说说IO流的类别 在说流的类别之前，先说说什么是流，流其实就是对输入输出设备的抽象，可以把输入输出流理解为是一个通道，输入输出是相对程序而言的，如果是输出流，也就是往文件中写文件，而输入流，则是从文件中读取文件。从三个方面对IO流进行总结，一、字节流（一般都是xxxStream），二、字符流（xxxRead、xx
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java中IO流体系
交换一个思想，能得到俩思想
10-08 1966
转载: https://mp.weixin.qq.com/s?__biz=MzA5NzgzODI5NA==&mid=2454030958&idx=1&sn=df27aadb92e575e96115ec809506245a&chksm=872b9fd7b05c16c10f265b495b7204b843f6825771292b30a9124f6d32367d2d9485493316ea&scene=
韩顺平老师-IO流
想握住此生辽阔
07-27 3193
视频地址：【韩顺平讲Java】Java IO流专题 -io流 io机制 字符流 字节流 节点流 处理流 等 课程资料：课程资料：链接：https://pan.baidu.com/s/1GKg1SZicHhDXCQRNiSOhEA 提取码：x10f 文章目录文件基础知识创建文件获取文件信息目录操作IO流原理和分类FileInputStreamFileOutputStream文件拷贝文件字符流说明 文件基础知识 文件,对我们并不陌生,文件是保存数据的地方,比如大家经常使用的word文档,txt文件,excel
j0601IO_chicken_Java-IO_prettyjtt_
10-01
"javax小菜鸡io"描述了这个资源是面向对Java IO不太熟悉的开发者，特别是那些在Java世界中相对初级的程序员，"with vegetablesIO"可能是形象地表示将通过实例来丰富和理解IO知识。 Java IO库提供了一组丰富的类和...
java 基础-面向对象-线程-集合-IO流-网络 思维导图大全
05-09
这几个思维导图详细的整理了相关知识点的总结,以尽可能详细全面的进行总结.
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
2021面试必备--JAVA核心知识点整理.pdf
07-07
Java I/O模型包括阻塞IO模型、非阻塞IO模型、多路复用IO模型、信号驱动IO模型和异步IO模型。Java NIO是Java提供的一种面向缓冲区、基于通道的I/O操作方法。它支持面向缓冲区的、基于通道的I/O操作，以及多路复用的I/...
spring事务详细讲解-深入浅出
小电玩
09-08 490
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1474
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 544
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 727
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
Java基础教程：IO流详解
"Java基础知识，特别是关于IO流的整理，涵盖了File类的使用以及字节流和字符流的概念。这份文档包含对不同读取文件方法的示例代码，旨在帮助学习者理解Java中的输入/输出操作。" 在Java中，IO（Input/Output）流是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SEA-365

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值