Java基础之IO流

救救孩子把2024-09-20 8:45

什么是IO流？

它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流都包括了。输入流从文件中读取数据存储到进程(process)中，输出流从进程中读取数据然后写入到目标文件。

Java中有几种类型的流？

按照流的方向：

  • 输入流（inputStream）
  • 输出流（outputStream）。

按照实现功能分：

  • 节点流（可以从或向一个特定的地方（节点）读写数据。如FileReader）
  • 处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。）

按照处理数据的单位：

  • 字节流
  • 字符流

字节流继承于InputStream和OutputStream

字符流继承于InputStreamReader和OutputStreamWriter

字节流和字符流的区别？

字节流在JDK1.0中就被引进了，用于操作包含ASCII字符的文件。JAVA也支持其他的字符如Unicode，为了读取包含Unicode字符的文件，JAVA语言设计者在JDK1.1中引入了字符流。ASCII作为Unicode的子集，对于英语字符的文件，可以可以使用字节流也可以使用字符流。

字节流有了为什么还要有字符流？

字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

FileInputStream和FileOutputStream是什么？

这是在拷贝文件操作的时候，经常用到的两个类。在处理小文件的时候，它们性能表现还不错，在大文件的时候，最好使用BufferedInputStream (或 BufferedReader) 和 BufferedOutputStream (或 BufferedWriter)

Files的常用方法都有哪些？

  • Files. size()：查看文件个数。
  • Files. read()：读取文件。
  • Files. write()：写入文件。
  • Files. exists()：检测文件路径是否存在。
  • Files. createFile()：创建文件。
  • Files. createDirectory()：创建文件夹。
  • Files. delete()：删除一个文件或目录。
  • Files. copy()：复制文件。
  • Files. move()：移动文件。

什么是 java 序列化，如何实现 java 序列化？

序列化

是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现

将需要被序列化的类实现Serializable接口 ，该接口没有需要 实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造

一个 ObjectOutputStream(对象流)对象，接着，使用 ObjectOutputStream 对象的 writeObject(Object obj)方法就可以将参数为 obj的对象写出(即保存其状态)，要恢复的话则用输入流。

如何将一个 java 对象序列化到文件里?

在 java 中能够被序列化的类必须先实现Serializable接口，该接口没有任何抽象方法只是起到一个标记作用。

如何实现对象克隆？

两种方式:

  • 实现 Cloneable 接口并重写 Object 类中的 clone()方法；
  • 实现 Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用 Object 类的 clone

方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

什么是BIO？

同步阻塞式IO，服务端创建一个ServerSocket，然后客户端用一个Socket去连接那个ServerSocket，然后ServerSocket接收到一个Socket的连接请求就创建一个Socket和一个线程去跟那个Socket进行通信。

java 复制代码 
public class BioServer {  
    public static void main(String[] args) {
        // 服务端开启一个端口进行监听
        int port = 8080;
        ServerSocket serverSocket = null;   //服务端
        Socket socket;  //客户端
        InputStream in = null;
        OutputStream out = null;
        try {
            serverSocket = new ServerSocket(port);  //通过构造函数创建ServerSocket，指定监听端口，如果端口合法且空闲，服务器就会监听成功
            // 通过无限循环监听客户端连接，如果没有客户端接入，则会阻塞在accept操作
            while (true) {
                System.out.println("Waiting for a new Socket to establish" + " ," + new Date().toString());
                socket = serverSocket.accept();//阻塞  三次握手
                in = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int length = 0;
                while ((length = in.read(buffer)) > 0) {//阻塞
                    System.out.println("input is:" + new String(buffer, 0, length) + " ," + new Date().toString());
                    out = socket.getOutputStream();
                    out.write("success".getBytes());
                    System.out.println("Server end" + " ," + new Date().toString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 必要的清理活动
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

什么是NIO？

同步非阻塞

包括Selector，这是多路复用器，selector会不断轮询注册的channel，如果某个channel上发生了读写事件，selector就会将这些channel获取出来，通过SelectionKey获取有读写事件的channel，就可以进行IO操作。一个Selector就通过一个线程，就可以轮询成千上万的channel，这就意味着服务端可以接入成千上万的客户端。

java 复制代码 
public class NioDemo implements Runnable {
    public int id = 100001;
    public int bufferSize = 2048;
    @Override
    public void run() {
        init();
    }
    public void init() {
        try {
            // 创建通道和选择器
            ServerSocketChannel socketChannel = ServerSocketChannel.open();
            Selector selector = Selector.open();
            InetSocketAddress inetSocketAddress = new InetSocketAddress(
                InetAddress.getLocalHost(), 4700);
            socketChannel.socket().bind(inetSocketAddress);
            // 设置通道非阻塞 绑定选择器
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_ACCEPT).attach(
                id++);
            System.out.println("Server started .... port:4700");
            listener(selector);
        } catch (Exception e) {
        }
    }
    public void listener(Selector in_selector) {
        try {
            while (true) {
                Thread.sleep(1 * 1000);
                in_selector.select(); // 阻塞 直到有就绪事件为止
                Set<SelectionKey> readySelectionKey = in_selector
                    .selectedKeys();
                Iterator<SelectionKey> it = readySelectionKey.iterator();
                while (it.hasNext()) {
                    SelectionKey selectionKey = it.next();
                    // 判断是哪个事件
                    if (selectionKey.isAcceptable()) {// 客户请求连接
                        System.out.println(selectionKey.attachment()
                                           + " - 接受请求事件");
                        // 获取通道 接受连接,
                        // 设置非阻塞模式（必须），同时需要注册 读写数据的事件，这样有消息触发时才能捕获
                        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey
                            .channel();
                        serverSocketChannel
                            .accept()
                            .configureBlocking(false)
                            .register(
                            in_selector,
                            SelectionKey.OP_READ
                            | SelectionKey.OP_WRITE).attach(id++);
                        System.out
                            .println(selectionKey.attachment() + " - 已连接");
                        // 下面这种写法是有问题的 不应该在serverSocketChannel上面注册
                        /*
                         * serverSocketChannel.configureBlocking(false);
                         * serverSocketChannel.register(in_selector,
                         * SelectionKey.OP_READ);
                         * serverSocketChannel.register(in_selector,
                         * SelectionKey.OP_WRITE);
                         */
                    }
                    if (selectionKey.isReadable()) {// 读数据
                        System.out.println(selectionKey.attachment()
                                           + " - 读数据事件");
                        SocketChannel clientChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer receiveBuf = ByteBuffer.allocate(bufferSize);
                        clientChannel.read(receiveBuf);
                        System.out.println(selectionKey.attachment()
                                           + " - 读取数据：" + getString(receiveBuf));
                    }
                    if (selectionKey.isWritable()) {// 写数据
                        System.out.println(selectionKey.attachment()
                                           + " - 写数据事件");
                        SocketChannel clientChannel = (SocketChannel) selectionKey.channel();
                        ByteBuffer sendBuf = ByteBuffer.allocate(bufferSize);
                        String sendText = "hello\n";
                        sendBuf.put(sendText.getBytes());
                        sendBuf.flip();        //写完数据后调用此方法
                        clientChannel.write(sendBuf);
                    }
                    if (selectionKey.isConnectable()) {
                        System.out.println(selectionKey.attachment()
                                           + " - 连接事件");
                    }
                    // 必须removed 否则会继续存在，下一次循环还会进来,
                    // 注意removed 的位置，针对一个.next() remove一次
                    it.remove();
                }
            }
        } catch (Exception e) {
            System.out.println("Error - " + e.getMessage());
            e.printStackTrace();
        }
    }
    /**
     * ByteBuffer 转换 String
     *
     * @param buffer
     * @return
     */
    public static String getString(ByteBuffer buffer) {
        String string = "";
        try {
            for (int i = 0; i < buffer.position(); i++) {
                string += (char) buffer.get(i);
            }
            return string;
        } catch (Exception ex) {
            ex.printStackTrace();
            return "";
        }
    }
}

什么是AIO？

异步非阻塞

每个连接发送过来的请求，都会绑定一个buffer，然后通知操作系统去异步完成读，此时程序是会去干别的事儿的，等操作系统完成数据读取之后，就会回调接口，给操作系统异步读完的数据。

java 复制代码 
public class AIOServer {
    public final static int PORT = 9888;
    private AsynchronousServerSocketChannel server;
    public AIOServer() throws IOException {
        server = AsynchronousServerSocketChannel.open().bind(
            new InetSocketAddress(PORT));
    }
    public void startWithFuture() throws InterruptedException,
    ExecutionException, TimeoutException {
        while (true) {// 循环接收客户端请求
            Future<AsynchronousSocketChannel> future = server.accept();
            AsynchronousSocketChannel socket = future.get();// get() 是为了确保 accept 到一个连接
            handleWithFuture(socket);
        }
    }
    public void handleWithFuture(AsynchronousSocketChannel channel) throws InterruptedException, ExecutionException, TimeoutException {
        ByteBuffer readBuf = ByteBuffer.allocate(2);
        readBuf.clear();
        while (true) {// 一次可能读不完
            //get 是为了确保 read 完成，超时时间可以有效避免DOS攻击，如果客户端一直不发送数据，则进行超时处理
            Integer integer = channel.read(readBuf).get(10, TimeUnit.SECONDS);
            System.out.println("read: " + integer);
            if (integer == -1) {
                break;
            }
            readBuf.flip();
            System.out.println("received: " + Charset.forName("UTF-8").decode(readBuf));
            readBuf.clear();
        }
    }
    public void startWithCompletionHandler() throws InterruptedException,
    ExecutionException, TimeoutException {
        server.accept(null,
                      new CompletionHandler<AsynchronousSocketChannel, Object>() {
                          public void completed(AsynchronousSocketChannel result, Object attachment) {
                              server.accept(null, this);// 再此接收客户端连接
                              handleWithCompletionHandler(result);
                          }
                          @Override
                          public void failed(Throwable exc, Object attachment) {
                              exc.printStackTrace();
                          }
                      });
    }
    public void handleWithCompletionHandler(final AsynchronousSocketChannel channel) {
        try {
            final ByteBuffer buffer = ByteBuffer.allocate(4);
            final long timeout = 10L;
            channel.read(buffer, timeout, TimeUnit.SECONDS, null, new CompletionHandler<Integer, Object>() {
                @Override
                public void completed(Integer result, Object attachment) {
                    System.out.println("read:" + result);
                    if (result == -1) {
                        try {
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        return;
                    }
                    buffer.flip();
                    System.out.println("received message:" + Charset.forName("UTF-8").decode(buffer));
                    buffer.clear();
                    channel.read(buffer, timeout, TimeUnit.SECONDS, null, this);
                }
                @Override
                public void failed(Throwable exc, Object attachment) {
                    exc.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String args[]) throws Exception {
        //        new AIOServer().startWithFuture();
        new AIOServer().startWithCompletionHandler();
        Thread.sleep(100000);
    }
}

什么是epoll？

把一个磁盘文件映射到内存里来，然后把映射到内存里来的数据通过socket发送出去 。

有一种mmap技术，也就是内存映射，直接将磁盘文件数据映射到内核缓冲区，这个映射的过程是基于DMA引擎拷贝的，同时用户缓冲区是跟内核缓冲区共享一块映射数据的，建立共享映射之后，就不需要从内核缓冲区拷贝到用户缓冲区了。

光是这一点，就可以避免一次拷贝，但是这个过程中还是会用户态切换到内核态去进行映射拷贝，接着再次从内核态切换到用户态， 建立用户缓冲区和内核缓冲区的映射 ，

接着把数据通过Socket发送出去，还是要再次切换到内核态 ，

接着直接把内核缓冲区里的数据拷贝到Socket缓冲区里去，然后再拷贝到网络协议引擎里，发送出去就可以了，最后切换回用户态 。

减少一次拷贝，但是并不减少切换次数，一共是4次切换，3次拷贝

什么是零拷贝技术？

linux提供了sendfile，也就是零拷贝技术

这个零拷贝技术，就是先从用户态切换到内核态，在内核态的状态下，把磁盘上的数据拷贝到内核缓冲区，同时从内核缓冲区拷贝一些 offset和length到Socket缓冲区；接着从内核态切换到用户态，从内核缓冲区直接把数据拷贝到网络协议引擎里去

同时从Socket缓冲区里拷贝一些offset和length到网络协议引擎里去，但是这个offset和length的量很少，几乎可以忽略

只要2次切换，2次拷贝

说一下select，poll，epoll的区别？

select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。epoll也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在"醒着"的时候要遍历整个fd集合，而epoll在"醒着"的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。

select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。

相关推荐
zxctsclrjjjcph12 分钟前
【C语言】常见的C语言概念
c语言·开发语言
小灰灰爱代码17 分钟前
C++——求3个数中最大的数（分别考虑整数、双精度数、长整数的情况），用函数模板来实现。
开发语言·c++·算法
严文文-Chris20 分钟前
【设计模式-享元】
android·java·设计模式
Eiceblue24 分钟前
Python 复制Excel 中的行、列、单元格
开发语言·python·excel
项目題供诗28 分钟前
尚品汇-秒杀商品存入缓存、Redis发布订阅实现状态位（五十一）
开发语言·php
m0_7145902636 分钟前
汇编（实现C语言程序的调用）
c语言·开发语言·汇编
Flying_Fish_roe37 分钟前
浏览器的内存回收机制&监控内存泄漏
java·前端·ecmascript·es6
做技术的Pandaer39 分钟前
Go 第二期
开发语言·golang
新知图书40 分钟前
Rust编程的作用域与所有权
开发语言·后端·rust
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04Coze扣子平台完整体验和实践（附国内和国际版对比）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10借助 LocatorJS ，快速定位本地代码