IO流回顾解析详解

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量133 收藏 2
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43869435/article/details/108484872
版权

IO流回顾解析详解

概述：
  • 什么是流？
    在计算机的世界中计算机只有0和1，我们所看到的所有东西（图片，视频，文字…）都是由这两个数字所组成的，经过二进制转换成的一个文字，一张图片，一条视频。而我们需要将一个文件（文本，图片，视频…）copy到一个文件夹中，而文件copy的过程我们称之为流，过程就是将一个文件转化成二进制的数据集，把数据一点点地传递到文件夹中，类似于水流一般，所以这种数据集就为一个数据流。
  • IO流特点：
    1. 顺序读写：
      读写数据时，一般都是顺序执行的，从文件的第一个字节到最后一个字节，写出时也是也如此（RandomAccessFile 可以实现随机读写）。
    2. 字节数组：
      读写数据本质都是对字节做读取和写出操作，字节流就是在流的基础上转化为一个个字符，所以字节数组是IO流读写数据的本质。
  • 流的种类：
    1. 输入流（InputStream）- Reader：从磁盘或者设备数据输入到应用进程中。
    2. 输出流（outputStream）- Writer：将应用进程中的数据输入到磁盘或者其他的设备上保存。
  • 数据的基础单位：字节流 与 字符流
    1. 字节流：以字节（8bit）为单位做数据传输。
    2. 字符流：以字符为单位（1-3字符）做数据传输。
    注：
    (1). Java中的字符采用Unicode 标准，在读取与输出的过程，以字符为单位，查找对应的码表将字节转换为对应的字符。
    (2). 文本格式的数据优先采用字符流，除此之外其它类型的数据文件（图片，音频…）使用字节流。
    (3). Stream 就知道是字节流，看到 Reader / Writer 就知道是字符流。
    /** 
 *  字节流 -- 输入
 */
public static void byteStreamIn() {
    InputStream inputStream = null;
    try {
        inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\io.txt");
        byte[] bytes = new byte[1024];
        int read = inputStream.read(bytes);
        String str = new String(bytes);
        System.out.println(str);
        System.out.println(read);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputStream != null) inputStream.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}

 /**
 * 字节流 -- 输出
 */
public static void byteStreamOut() {
    OutputStream outputStream = null;
    InputStream inputStream = null;
    try {
        outputStream = new FileOutputStream("D:\\桌面\\静电式图片\\img\\妹2.jpg");
        inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\妹1.jpg");
        byte[] bytes = new byte[1024];
        //3、操作 (读取)
        int temp;
        while ((temp = inputStream.read(bytes)) != -1) {
            System.out.println(temp);
            String str = new String(bytes);
            System.out.println(str);
            outputStream.write(bytes);
        }
        System.out.println("OK");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (outputStream != null) // 不为默认值 null
                outputStream.close();
            if (inputStream != null) // 不为默认值 null
                inputStream.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}

/**
 * 字符流 -- 输入
 */
public static void charStreamIn() {
    try {
        Reader reader = new FileReader("D:\\桌面\\静电式图片\\img\\io1.txt");
        char[] chars = new char[1024];
        int temp;
        while ((temp = reader.read(chars)) != -1) {
            System.out.println(temp);
            String str = new String(chars);
            System.out.println(str);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

 /**
 * 字符流 -- 输出
 */
public static void charStreamOut() {
    Reader reader = null;
    Writer writer = null;
    try {
        writer = new FileWriter("D:\\桌面\\静电式图片\\img\\io2.txt");
        reader = new FileReader("D:\\桌面\\静电式图片\\img\\io1.txt");
        char[] chars = new char[1024];
        int temp;
        while ((temp = reader.read(chars)) != -1) {
            System.out.println(temp);
            String str = new String(chars);
            System.out.println(str);
            writer.append(str);
        }
        System.out.println("OK");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (reader != null) reader.close();
            if (writer != null) writer.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}
/**
 * 字节流 -- 缓冲流 -- 输入
 */
public static void BufferedIntPutStreamByte() {
    InputStream inputStream = null;
    try {
        inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\io1.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        byte[] bytes = new byte[1024];
        int temp;
        while ((temp = bufferedInputStream.read(bytes)) != -1) {
            System.out.println(temp);
            String string = new String(bytes);
            System.out.println(string);
        }
        bufferedInputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputStream != null) inputStream.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}

/**
 * 字节流 -- 缓冲流 -- 输出
 */
public static void BufferedOutPutStreamByte() {
    InputStream inputStream = null;
    OutputStream outputStream = null;
    try {
        inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\io1.txt");
        outputStream = new FileOutputStream("D:\\桌面\\静电式图片\\img\\io99.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        byte[] bytes = new byte[1024];
        int temp;
        while ((temp = bufferedInputStream.read(bytes)) != -1) {
            System.out.println(temp);
            String string = new String(bytes);
            System.out.println(string);
            bufferedOutputStream.write(bytes);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
        System.out.println("ok");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputStream != null) inputStream.close();
            if (outputStream != null) outputStream.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}

/**
 * 字符流 -- 缓冲流 -- 输入
 */
public static void BufferedIntPutStreamChar() {
    Reader reader = null;
    try {
        reader = new FileReader("D:\\桌面\\静电式图片\\img\\io1.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        char[] chars = new char[1024];
        int temp;
        int tot_count = 0;
        while ((temp = bufferedReader.read(chars)) != -1) {
            System.out.println(temp);
            tot_count += temp;
            String str = new String(chars);
            System.out.println(str);
        }
        System.out.println("总数："+tot_count);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 字符流 -- 缓冲流 -- 输出
 */
public static void BufferedOutPutStreamChar() {
    Reader reader = null;
    Writer writer = null;
    try {
        reader = new FileReader("D:\\桌面\\静电式图片\\img\\222.txt");
        writer = new FileWriter("D:\\桌面\\静电式图片\\img\\333.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        char[] chars = new char[1024];
        int temp;
        int tot_count = 0;
        while ((temp = bufferedReader.read(chars)) != -1) {
            System.out.println(temp);
            tot_count += temp;
            String str = new String(chars);
            System.out.println(str);
            bufferedWriter.append(str);
        }
        System.out.println("总数：" + tot_count);
        bufferedReader.close();
        bufferedWriter.close();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (reader != null) reader.close();
            if (writer != null) writer.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}

/**
 * 字符流 -- 缓冲流 -- 输入 -- readLine
 */
public static void BufferedIntPutStreamCharLine() {
    Reader reader = null;
    try {
        reader = new FileReader("D:\\桌面\\静电式图片\\img\\222.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        int tot_count = 0;
        String line ;
        while ((line = bufferedReader.readLine()) != null) {
            if (StringUtils.isNotBlank(line)) {
                if (line.contains("　　")) {
                    String replace = line.replace("　　", "");
                    System.out.println(replace);
                } else {
                    System.out.println(line);
                }
                tot_count += 1;
            }
        }
        System.out.println("行数："+tot_count);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 字符流 -- 缓冲流 -- 输入 -- readLine
 */
public static void BufferedOutPutStreamCharLine() {
    Reader reader = null;
    Writer writer = null;
    try {
        reader = new FileReader("D:\\桌面\\静电式图片\\img\\222.txt");
        writer = new FileWriter("D:\\桌面\\静电式图片\\img\\555.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        int tot_count = 0;
        String line ;
        while ((line = bufferedReader.readLine()) != null) {
            if (StringUtils.isNotBlank(line)) {
                if (line.contains("　　")) {
                    String replace = line.replace("　　", "");
                    System.out.println(replace);
                    bufferedWriter.append(replace);
                    bufferedWriter.newLine();
                } else {
                    System.out.println(line);
                    bufferedWriter.append(line);
                    bufferedWriter.newLine();
                }
                tot_count += 1;
            }
        }
        bufferedReader.close();
        bufferedWriter.close();
        System.out.println("行数："+tot_count);
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        try {
            if (reader != null) reader.close();
            if (writer != null) writer.close();
        } catch (IOException io) {
            io.printStackTrace();
        }
    }
}
  • 转换流
转换流 / 数据类型字节流与字符流之间的转换
（输入）字节流 => 字符流InputStreamReader
（输出）字符流 => 字节流OutputStreamWriter
1. InputStreamReader：从字节流转换为字符流，将字节数据转换为字符数据读入到内存。
2. OutputStreamWriter：从字符流转换为字节流，将字符数据转换为字节数据写出到指定位置。
     /**
     * 字节流转字符流 -- 输入
     */
    public static void InputStreamReadeByte(){
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\555.txt");
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            char[] chars = new char[1024];
            int temp;
            while ((temp = inputStreamReader.read(chars)) != -1) {
                System.out.println(temp);
                String str = new String(chars);
                System.out.println(str);
            }
            inputStreamReader.close();
            System.out.println("OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) inputStream.close();
            } catch (IOException io) {
                io.printStackTrace();
            }
        }
    }

    /**
     * 字节流转字符流 -- 输出
     */
    public static void OutputStreamReadeByte(){
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("D:\\桌面\\静电式图片\\img\\555.txt");
            outputStream = new FileOutputStream("D:\\桌面\\静电式图片\\img\\666.txt");
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
            char[] chars = new char[1024];
            int temp;
            while ((temp = inputStreamReader.read(chars)) != -1) {
                System.out.println(temp);
                String str = new String(chars);
                System.out.println(str);
                outputStreamWriter.write(str);
            }
            inputStreamReader.close();
            outputStreamWriter.close();
            System.out.println("OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) inputStream.close();
                if (outputStream != null) outputStream.close();
            } catch (IOException io) {
                io.printStackTrace();
            }
        }
    }
  • BIO NIO 和 AIO 的区别
类型烧开水
BIO (同步阻塞 I/O)一直监测着某个水壶，该水壶烧开水后再监测下一个水壶
NIO（同步非阻塞 I/O）每隔一段时间就看看所有水壶的状态，哪个水壶烧开水就去处理哪个水壶
AIO（异步非阻塞 I/O）不用监测水壶，每个水壶烧开水后都会主动通知线程说：“我的水烧开了，来处理我吧”
1. BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
2. NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
3. AIO(NIO.2)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
BIO
1. 同步阻塞式IO，相信每一个学习过操作系统网络编程或者任何语言的网络编程的人都很熟悉，在while循环中服务端会调用accept方法等待接收客户端的连接请求，一旦接收到一个连接请求，就可以建立通信套接字在这个通信套接字上进行读写操作，此时不能再接收其他客户端连接请求，只能等待同当前连接的客户端的操作执行完成。
2. 如果BIO要能够同时处理多个客户端请求，就必须使用多线程，即每次accept阻塞等待来自客户端请求，一旦受到连接请求就建立通信套接字同时开启一个新的线程来处理这个套接字的数据读写请求，然后立刻又继续accept等待其他客户端连接请求，即为每一个客户端连接请求都创建一个线程来单独处理，大概原理图就像这样：

在这里插入图片描述

3. 虽然此时服务器具备了高并发能力，即能够同时处理多个客户端请求了，但是却带来了一个问题，随着开启的线程数目增多，将会消耗过多的内存资源，导致服务器变慢甚至崩溃，NIO可以一定程度解决这个问题。
NIO
BIO 与 NIO 的区别，BIO 是面向流的 IO，它建立的通道都是单向的，所以输入和输出流的通道不相同，必须建立2个通道，通道内的都是传输==0101001···==的字节数据。而在 NIO 中，不再是面向流的 IO 了，而是面向缓冲区，它会建立一个通道（Channel），该通道我们可以理解为铁路，该铁路上可以运输各种货物，而通道上会有一个缓冲区（Buffer）用于存储真正的数据，缓冲区我们可以理解为一辆火车。通道（铁路）只是作为运输数据的一个连接资源，而真正存储数据的是缓冲区（火车）。即通道负责传输，缓冲区负责存储。
BIONIO
面向流（Stream）面向缓冲区（Buffer）
单向通道双向通道
阻塞非阻塞
选择器（Selectors）
  • 同步非阻塞式IO，关键是采用了事件驱动的思想来实现了一个多路转换器。
  • NIO与BIO最大的区别就是只需要开启一个线程就可以处理来自多个客户端的IO事件，这是怎么做到的呢？
  • 就是多路复用器，可以监听来自多个客户端的IO事件：
A. 若服务端监听到客户端连接请求，便为其建立通信套接字(java中就是通道)，然后返回继续监听，若同时有多个客户端连接请求到来也可以全部收到，依次为它们都建立通信套接字。
B. 若服务端监听到来自已经创建了通信套接字的客户端发送来的数据，就会调用对应接口处理接收到的数据，若同时有多个客户端发来数据也可以依次进行处理。
C. 监听多个客户端的连接请求和接收数据请求同时还能监听自己时候有数据要发送。
总之就是在一个线程中就可以调用多路复用接口（java中是select）阻塞同时监听来自多个客户端的IO请求，一旦有收到IO请求就调用对应函数处理。

在这里插入图片描述

  • 创建NIO服务端的主要步骤如下：
1. 打开ServerSocketChannel，监听客户端连接
2. 绑定监听端口，设置连接为非阻塞模式
3. 创建Reactor线程，创建多路复用器并启动线程
4. 将ServerSocketChannel注册到Reactor线程中的Selector上，监听ACCEPT事件
5. Selector轮询准备就绪的key
6. Selector监听到新的客户端接入，处理新的接入请求，完成TCP三次握手，简历物理链路
7. 设置客户端链路为非阻塞模式
8. 将新接入的客户端连接注册到Reactor线程的Selector上，监听读操作，读取客户端发送的网络消息
9. 异步读取客户端消息到缓冲区
10. 对Buffer编解码，处理半包消息，将解码成功的消息封装成Task
11. 将应答消息编码为Buffer，调用SocketChannel的write将消息异步发送给客户端
  • 所以不能保证一次能吧需要发送的数据发送完，此时就会出现写半包的问题。我们需要注册写操作，不断轮询Selector将没有发送完的消息发送完毕，然后通过Buffer的hasRemain()方法判断消息是否发送完成。
AIO(NIO.2)
  • NIO 2.0引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。
  • 异步的套接字通道时真正的异步非阻塞I/O，对应于UNIX网络编程中的事件驱动I/O（AIO）。他不需要过多的Selector对注册的通道进行轮询即可实现异步读写，从而简化了NIO的编程模型。API比NIO的使用起来真的简单多了，主要就是监听、读、写等各种CompletionHandler。此处本应有一个WriteHandler的，确实，我们在ReadHandler中，以一个匿名内部类实现了它。
  • AIO是真正的异步非阻塞的，所以，在面对超级大量的客户端，更能得心应手
(02)Cartographer源码无死角解析-(81) ROS栅格地图→服务接收子图、cairo图像绘详解、OccupancyGrid地图发布
江南才尽江南山，年少无知年少狂！
07-12 1423
疑问1疑问1src/cartographer/cartographer/mapping/2d/probability_grid.cc 文件中的 ProbabilityGrid::DrawToSubmapTexture 函数的 proto::SubmapQuery::Response::SubmapTexture* 示例对象 texture 中texture->mutable_slice_pose() 的含义具体是什么。
【C语言趣味教程】(8) 标准 IO 流：输入和输出 | 标准输入 stdin | 标准输出 stdout | 详解 printf 和 scanf | 探讨 scanf 缓冲区问题和安全性问题
有道无术, 术尚可求。有术无道, 止于术。
09-06 4379
C 语言中标准 I/O 流为 stdin 和 stdout，它们分别用于标准输入和标准输出。
深入理解Java中的IO
热门推荐
二丁目的丰功笔记
04-21 2万+
深入理解Java中的IO,个人学习总结。
IO流详解
weixin_30468137的博客
08-19 347
目录 IO流 IO流概述及其分类 IO概念 流按流向分为两种: 流按操作类型分为两种: 常用的IO流类 字节流的抽象父类： 字符流的抽象父类： InputStream & F...
详解IO流
蛙广志
02-19 458
Java IO详解IO概述1.什么是IO2.流及流的分类2.1什么是流?2.2流的分类3.IO流对象3.1字节流4.IO流方法4.1字符流方法4.2字节流方法5.代码实例5.1使用`FileReader`和`FileWriter`实现文本的复制5.2使用`FileInputStream`和`FileOutputStream`实现图片的复制 IO概述 1.什么是IO I/O是Input/Out普通的缩写，I/O技术是非常使用的技术，用于处理设备之间的数据传输。 在Java程序中，对于数据的输入/输出操作以“流
IO流的概述
hfskghirua的博客
07-23 367
io流的i代表input(输入),o也就是out代表输出,流就是流动的意思,输入端流动到输出端
golang将多路复异步io转成阻塞io的方法详解
09-21
### Golang将多路复用异步IO转成阻塞IO的方法详解 #### 前言 在Golang中处理网络通信时，开发者通常利用语言内置的高效并发机制（如goroutines和channels）来实现非阻塞IO或多路复用IO。然而，在某些场景下，我们...
操作系统之IO设备详解
帅枫的博客
02-26 4750
操作系统⑤ 一、I/O设备的概念和分类 一、I/O设备的基本概念和分类 二、什么是I/O设备 “I/O" 就是”输入/输出“（Input/Output) I/O设备就是可以将数据输入到计算机，或者可以接收计算机输出数据的外设，属于计算机中的硬件部分。 三、I/O设备的分类–按使用特性 四、I/O设备的分类–按传输速率分类 五、I/O设备的分类–按信息交换的单位分类 六、知识回顾 二、I/O控制器 一、知识总览 二、I/O设备的机械部件 I/O设备的机械部件主要用来执行具体I/O操作。
Go标准库之log使用详解和源码解析
perfume
12-03 2366
## 简介 log包实现了简单的日志打印功能，支持日志输出到控制台或者日志文件。log包里核心的数据结构只有1个Logger，定义如下 ```go // A Logger represents an active logging object that generates lines of // output to an io.Writer. Each logging operation makes a single call to // the Writer's Write method. A L..
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 887
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 926
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 349
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1204
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 849
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1071
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 417
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
Netty 5.0架构详解：从异步IO到源码解析
本书针对Java的IO发展历史进行了详尽的回顾，特别强调了传统BIO通信方式的局限性，如同步阻塞模式导致的性能瓶颈和可靠性问题，这些问题在高并发场景下尤为突出，使得许多大型应用服务器转向使用C或C++等更为底层的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值