JavaIO流：BIO梳理_java io是bio

最新推荐文章于 2025-08-18 11:55:45 发布
原创 最新推荐文章于 2025-08-18 11:55:45 发布 · 798 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

BIO 通信模型图：

img

二、Java BIO 工作机制

BIO模式下的基础工作机制

对 BIO 编程流程的梳理

  1. 服务端启动一个 ServerSocket，注册端口，调用 accpet 方法监听客户端的 Socket 连接。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯

网络编程的基本模型是 Client/Server 模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于 TCP 协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。

传统的同步阻塞模型开发中，服务端 ServerSocket 负责绑定 IP 地址，启动监听端口；客户端 Socket 负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。

基于 BIO 模式下的通信，客户端 - 服务端是完全同步，完全耦合的。

三、BIO 案例

1、实例1：传统的BIO编程

服务端：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/\*\*
 \* 服务端
 \*\*/
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==服务器的启动==");
        // （1）注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
        Socket socket = serverSocket.accept();
        //（3）从Socket管道中得到一个字节输入流。
        InputStream is = socket.getInputStream();
        //（4）把字节输入流包装成自己需要的流进行数据的读取。
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //（5）读取数据
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println("服务端收到：" + line);
        }
    }
}

客户端：

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/\*\*
 \* 目标: Socket 网络编程。
 \*
 \* Java 提供了一个包：java.net 下的类都是用于网络通信。
 \* Java 提供了基于套接字（端口）Socket 的网络通信模式，我们基于这种模式就可以直接实现TCP通信。
 \* 只要用 Socke t通信，那么就是基于 TCP 可靠传输通信。
 \*
 \* 功能1：客户端发送一个消息，服务端接口一个消息，通信结束！！
 \*
 \* 创建客户端对象：
 \* (1）创建一个 Socket 的通信管道，请求与服务端的端口连接。
 \* （2）从 Socket 管道中得到一个字节输出流。
 \* （3）把字节流改装成自己需要的流进行数据的发送
 \* 创建服务端对象：
 \* （1）注册端口
 \* （2）开始等待接收客户端的连接,得到一个端到端的Socket管道
 \* （3）从 Socket 管道中得到一个字节输入流。
 \* （4）把字节输入流包装成自己需要的流进行数据的读取。
 \*
 \* Socket的使用：
 \* 构造器：public Socket(String host, int port)
 \* 方法： public OutputStream getOutputStream()：获取字节输出流
 \* public InputStream getInputStream() :获取字节输入流
 \*
 \* ServerSocket的使用：
 \* 构造器：public ServerSocket(int port)
 \*
 \* 小结：
 \* 通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！
 \*/
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // （1）创建一个Socket的通信管道，请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",8888);
        // （2）从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // （3）把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // （4）开始发送消息
        ps.println("我是客户端，我想约你吃小龙虾！！！");
        ps.println("我是客户端，我想约你吃大闸蟹！！！");
        Thread.sleep(1000);
        ps.println("我是客户端，我想约你吃油泼面！！！");
        ps.flush();
    }
}
  • 在以上通信中，服务端会一致等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态。
  • 同时服务端是按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！
2、实例2：BIO模式下多发和多收消息

服务端：同实例1

客户端：

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/\*\*
 \* 目标: Socket网络编程。
 \* 功能：客户端可以反复发消息，服务端可以反复收消息
 \* 小结：通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！
 \*/
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // （1）创建一个Socket的通信管道，请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",8888);
        // （2）从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // （3）把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // （4）开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}
3、实例3：接受多个客户端

服务端（同上）：

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/\*\*
 \* 目标: Socket网络编程。
 \* 功能：客户端可以反复发，一个服务端可以接收无数个客户端的消息！！
 \* 小结：服务器如果想要接收多个客户端，那么必须引入线程，一个客户端一个线程处理！！
 \*/
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // （1）创建一个Socket的通信管道，请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",7777);
        // （2）从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // （3）把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // （4）开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务端：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/\*\*
 \* 服务端
 \*
 \* @author liziheng
 \* @version 1.0.0
 \* @date 2022-06-23 11:23 上午
 \*/
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==服务器的启动==");
        // （1）注册端口
        ServerSocket serverSocket = new ServerSocket(7777);
        while (true) {
            //（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
            Socket socket = serverSocket.accept();
            new ServerReadThread(socket).start();
            System.out.println(socket.getRemoteSocketAddress() + "上线了！");
        }
    }
}

class ServerReadThread extends Thread {

    private final Socket socket;

    public ServerReadThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //（3）从Socket管道中得到一个字节输入流。
            InputStream is = socket.getInputStream();
            //（4）把字节输入流包装成自己需要的流进行数据的读取。
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //（5）读取数据
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println("服务端收到：" + socket.getRemoteSocketAddress() + ":" + line);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！");
        }
    }
}
  • 每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能；
  • 每个线程都会占用栈空间和CPU资源；
  • 并不是每个 socket 都进行 IO 操作，无意义的线程处理；
  • 客户端的并发访问增加时。服务端将呈现 1:1 的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。
4、实例4：伪异步 I/O 编程

在上述案例（实例3）中：客户端的并发访问增加时。服务端将呈现 1:1 的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

接下来我们采用一个伪异步 I/O 的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的 Socket 封装成一个 Task（该任务实现 java.lang.Runnable 线程任务接口）交给后端的线程池中进行处理。JDK 的线程池维护一个消息队列和 N 个活跃的线程，对消息队列中 Socket 任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

image-20200619085953166
客户端：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {
    public static void main(String[] args) {
        try {
            // 1.简历一个与服务端的Socket对象：套接字
            Socket socket = new Socket("127.0.0.1", 9999);
            // 2.从socket管道中获取一个输出流，写数据给服务端
            OutputStream os = socket.getOutputStream() ;
            // 3.把输出流包装成一个打印流
            PrintWriter pw = new PrintWriter(os);
            // 4.反复接收用户的输入
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = null ;
            while((line = br.readLine()) != null){
                pw.println(line);
                pw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

线程池：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/\*\*
 线程池处理类
 \*\*/
public class HandlerSocketThreadPool {

    // 线程池
    private ExecutorService executor;

    public HandlerSocketThreadPool(int maxPoolSize, int queueSize){

        this.executor = new ThreadPoolExecutor(
                3, // 8
                maxPoolSize,
                120L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize) );
    }

    public void execute(Runnable task){
        this.executor.execute(task);
    }
}

服务端：

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("----------服务端启动成功------------");
            ServerSocket ss = new ServerSocket(9999);

            // 一个服务端只需要对应一个线程池
            HandlerSocketThreadPool handlerSocketThreadPool =
                    new HandlerSocketThreadPool(3, 1000);

            // 客户端可能有很多个
            while(true){
                Socket socket = ss.accept() ; // 阻塞式的！
                System.out.println("有人上线了！！");
                // 每次收到一个客户端的socket请求，都需要为这个客户端分配一个
                // 独立的线程 专门负责对这个客户端的通信！！
                handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
            }

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

}
class ReaderClientRunnable implements Runnable{

    private Socket socket ;

    public ReaderClientRunnable(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            // 读取一行数据
            InputStream is = socket.getInputStream() ;
            // 转成一个缓冲字符流
            Reader fr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(fr);
            // 一行一行的读取数据
            String line = null ;
            while((line = br.readLine())!=null){ // 阻塞式的！！
                System.out.println("服务端收到了数据："+line);
            }
        } catch (Exception e) {
            System.out.println("有人下线了");
        }

    }
}
  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。
5、实例5：基于 BIO 形式下的文件上传

客户端：

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;

/\*\*
 \* 目标：实现客户端上传任意类型的文件数据给服务端保存起来。
 \*/
public class Client {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("/Users/lizhengi/Downloads/BIO模式下的基础工作机制.png");
            ){
            // 1、请求与服务端的Socket链接
            Socket socket = new Socket("127.0.0.1", 8888);
            // 2、把字节输出流包装成一个数据输出流
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            // 3、先发送上传文件的后缀给服务端
            dos.writeUTF(".png");
            // 4、把文件数据发送给服务端进行接收
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) > 0) {
                dos.write(buffer, 0, len);
            }
            dos.flush();
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端线程：

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.UUID;

public class ServerReaderThread extends Thread {

    private final Socket socket;

en = is.read(buffer)) > 0) {
                dos.write(buffer, 0, len);
            }
            dos.flush();
            Thread.sleep(10000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

服务端线程：

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.UUID;

public class ServerReaderThread extends Thread {

    private final Socket socket;
标签
#java #网络 #开发语言
Java BIO Socke示例
11-24
Java BIO Socke示例，从简单socket到采用线程池处理socket
Java BIO从入门示例到多线程示例
lovoo的博客
04-10 1060
Java BlO就是传锤的Java IO编程，其相关的类和接口在Java.io 包中BIO同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器 端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销【简单示意图 】
java bio例子_Java BIO 编程
weixin_34827675的博客
02-24 321
Java BIO 基本介绍Java BIO 就是传统的java io 编程，其相关的类和接口在 java.ioBIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。BIO方式适用于连接数目比较小且固定的架构，这种方式...
Java IO
保持热爱，持续学习
11-29 385
java中IO流分类： 按数据流向： 输入流：数据流向程序 输出流：数据从程序流出。 按处理单位: 字节流和字符流 JDK 中后缀是 Stream 是字节流；后缀是 Reader，Writer 是字符流 按功能功能: 节点流和处理流 节点流：直接与数据源相连，读入或写出 处理流：与节点流一块使用，在节点流的基础上，再套接一层 最根本的四大类：InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流） 四大类的扩展，按处理单位区分 I
BIO示例代码
tiantiantbtb的博客
07-27 358
也可以自己编写Socket Client。通过send命令发送数据。然后window+R。
基于BIO的Java Socket通信
热门推荐
千与的专栏
03-16 1万+
BIO，即阻塞IO，在基于Socket的消息通信过程中，Socket服务端向外部提供服务，而Socket客户端可以建立到Socket服务端的连接，进而发送请求数据，然后等待Socket服务端处理，并返回处理结果（响应）。基于BIO的通信，Socket服务端会发生阻塞，即在监听过程中每次accept到一个客户端的Socket连接，就要处理这个请求，而此时其他连接过来的客户端只能阻塞等待。可见，这种模式下Socket服务端的处理能力是非常有限的，客户端也只能等待，直到服务端空闲时进行请求的处理。下面基于BIO模
JavaIO流：BIO梳理
栗筝i的博客
11-24 3771
BIO（blocking I/O） ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。 本篇内容包括：Java BIO 介绍、Java BIO 工作机制、BIO 案例。
梳理Java IO流，攻破NIO的堡垒!
qq_35598736的博客
09-23 1261
前言 在上一篇的文章获取不错的浏览量后，继续加更的念头一直徘徊在心中，本来是想花段时间深入学习tomcat的，可是tomcat的源码中就有至关重要的NIO,于是得先整一下NIO,但是NIO的基础是BIO，于是这篇文章就先写IO流吧。 学习NIO(非阻塞IO),千万不能被IO阻塞住哇! IO流在java中其实是很重要的一块知识点，难度还好，但是容易被忽视，因为工作中真正写IO的代码少之又少。 IO的难点在于 IO流api很多，各种基础的流，包装的流嵌套使用很难记忆 基本每个方法都要抛出非运行时异常 导致
javaio流_万字长文+思维导图帮你梳理Java IO流，还学不会你来打我
weixin_39765057的博客
11-29 92
前言在上一篇的文章获取不错的浏览量后，继续加更的念头一直徘徊在心中，本来是想花段时间深入学习tomcat的，可是tomcat的源码中就有至关重要的NIO,于是得先整一下NIO,但是NIO的基础是BIO，于是这篇文章就先写IO流吧。学习NIO(非阻塞IO),千万不能被IO阻塞住哇!IO流在java中其实是很重要的一块知识点，难度还好，但是容易被忽视，因为工作中真正写IO的代码少之又少。IO的难点在于...
深入剖析JavaIO面试题: 详细剖析了字节流与字符流的用法与区别以及BIO、NIO、AIO之间的区别与联系
以0和1为基因，在赛博空间搭建诗意的代码迷宫；用AI与算法作羽翼，在数字穹顶下翱翔创新的无垠天际。这里有前沿技术的深度拆解，有编程美学的多维探索，邀您共赴一场科技与诗意交织的未来盛宴。
04-22 5914
本文系统梳理了Java I/O核心知识，对比了字节流与字符流的差异及适用场景，分析了缓冲机制的作用。深入讲解了Java I/O模型的演进历程：从同步阻塞的BIO（单连接单线程）、到同步非阻塞的NIO（多路复用），再到异步非阻塞的AIO（回调驱动）。详细解析了NIO三大核心组件（Buffer、Channel、Selector）和AIO的架构设计（异步通道、回调处理器）。通过代码示例展示了不同I/O模型的实现方式，并提供了性能对比和选型建议，帮助开发者根据连接数、业务特性和团队能力选择适合的I/O方案。
javaio流_万字长文+思维导图帮你梳理 Java IO 流，还学不会你来打我（值得收藏）...
weixin_39664696的博客
11-20 110
前言在上一篇的文章获取不错的浏览量后，继续加更的念头一直徘徊在心中，本来是想花段时间深入学习tomcat的，可是tomcat的源码中就有至关重要的NIO,于是得先整一下NIO,但是NIO的基础是BIO，于是这篇文章就先写IO流吧。学习NIO(非阻塞IO),千万不能被IO阻塞住哇!IO流在java中其实是很重要的一块知识点，难度还好，但是容易被忽视，因为工作中真正写IO的代码少之又少。IO的难点在于...
Java实习模拟面试之IO流：从基础概念到NIO深入解析
最新发布
吾为热爱计科，致力于知识分享的践行者，此博客是我在这条道路上留下的足迹。
08-18 710
在Java开发中，IO（Input/Output）操作是基础且核心的知识点，无论是文件处理、网络通信还是系统交互，都离不开IO。对于Java实习生而言，深入理解IO流体系、掌握常用API以及了解NIO等高级特性，是面试官考察的重点。本文将通过一场模拟面试，带你系统梳理Java IO的核心知识点，并应对面试官的连环追问。候选人回答：好的面试官，Java中的IO流主要可以分为两大类：字节流和字符流，它们都位于包下。字节流（Byte Stream）：以字节（8位）为单位进行数据的读写。最核心的抽象基类是（输入）和
Java网络编程 全面理解BIO
qq_38472465的博客
11-06 171
01 BIO、NIO、AIO网络编程详解 02 网络层的详解(url,dns,七层网络层详解)与网络协议协议 03 java.io流与socket、同步异步阻塞、线程池详解 04 BIO阻塞模型与Socket实例 05 BIO与基于BIO的开发多人聊天室实践 06 利用NIO模型复制本地文件 07 NIO改造多人聊天室实践 8 AIO异步通信模型介绍与案例实践 09 AIO改造多人聊天室 10 利用网络模型开发一个web服务器 11 JavaIO原理、适用场景与优缺点分析 12 层层理清知识点梳理 htt
02-Java BIO编程
彼岸舞的博客
01-21 122
I/O 模型 I/O 模型基本说明 I/O 模型简单的理解: 就是用什么样的通道进行数据的发送和接收,很大程度上决定了程序通信的性能 Java共支持三种网络编程模型 I/O模式: BIO NIO AIO Java BIO: 同步并阻塞(传统阻塞型), 服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销[简...
视频教程-IO模型、NIO与AIO入门-Java
weixin_33850538的博客
05-28 263
IO模型、NIO与AIO入门 钟洪发，于2008年7月毕业于西南交通大学。2...
对IO流和NIO的区别写个总结（二）：
qq_44775783的博客
10-05 294
温习了I\O流部分的知识点，对IO流和NIO的区别写个总结： 首先，NIO是在Jdk1.4之后适用. NIO主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比...
Java进阶 - IO框架
luxd1994的博客
03-15 311
作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty构建，比如RPC框架、zookeeper等。新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。本文主要介绍Java IO常见类的使用，包括：磁盘操作，字节操作，字符操作，对象操作和网络操作。本文主要对IO多路复用，Ractor模型以及Java NIO对其的支持。
Java IO 系列总纲&系统IO模型
BASK2312的博客
05-11 151
或许您在开发中不再直接使用JDK中的API完成IO部分的功能，但仍有必要了解相关知识。JAVA的IO，通过虚拟机建立在操作系统的IO之上，在梳理JAVA的IO时，可适当了解操作系统部分IO的相关知识，但本系列不会深究。
2024最新常见200+Java面试题汇总（含答案解析）
2401_84024148的博客
04-28 1235
14. 接口和抽象类有什么区别？15. Java 中 IO 流分为几种？16. BIO、NIO、AIO 有什么区别？17. Files的常用方法都有哪些？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值