Java NIO学习——Buffer学习

最新推荐文章于 2023-06-09 21:25:34 发布
最新推荐文章于 2023-06-09 21:25:34 发布
阅读量1k 收藏
点赞数
分类专栏： java 文章标签： java nio Buffer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuanghujushi/article/details/52074107
版权

概述

基本属性

一个缓冲区Buffer有四个属性，容量(Capacity)，上界(limit)，位置(position)，标记(mark)。

属性名读模式含义写模式含义备注
容量(Capacity)Buffer的容量就是一个Buffer所最多能容纳的数据长度。同读模式Buffer在创建之后，容量便不会再变化
上界(limit)limit表示Buffer最多能读到多少数据。limit表示最多能往Buffer写入的数据量，此时，limit等于Buffer的capacity当切换Buffer到读模式时，limit会被设置成写模式下的position值；表示可读数据的结束位置
位置(position)position表示开始读取数据的位置，当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。当position=limit时，表示Buffer已无数据可读position表示当前待写入的位置。初始position值为0，当数据写入后，position会递增，position的max值为capacity – 1
标记(mark)mark（标记）是一个备忘位置，在初始化的时候，mark是未定义的值，在调用mark()函数后，设置mark=postion；等Buffer的position变化后，通过reset()函数，可以重新设置position=mark读写模式相同mark只是提供了一种position备份功能

Buffer模式

在Java中，一个缓冲区有两种模式，写模式(write mode)和读模式(Read Mode)。
当Buffer处于写模式的时候，表示当前Buffer等待写入数据，当一个Buffer初始化的时候，是处于写模式的。当Buffer达到容量最大值时，Buffer便不能再写入数据，如果继续写入，则会抛出BufferOverflowException异常，表示，Buffer已经写满。

当Buffer写完数据之后，可以切换到读模式，读模式表示可以从Buffer读取数据。如果Buffer内容已经读完，继续读取Buffer，则会抛出BufferUnderflowException异常。

模式切换函数

函数名作用
filp将Buffer从写模式切换到读模式
clear将Buffer从读模式切换到写模式，同时清空Buffer内所有数据
compact将Buffer从读模式切换到写模式,只清空已读数据，保留未读数据

例子

下面以CharBuffer为例看下Buffer基本读写方式，以及对应的属性。

public class LearnBuffer {
    static void bufferP(){
        CharBuffer charBuffer = CharBuffer.allocate(64);
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position());
        charBuffer.append("This is a test.");
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        System.out.println("\nBegin test read mode. ---------");
        charBuffer.flip();
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        System.out.print(charBuffer.get());
        System.out.println(charBuffer.get());
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        // mark当前位置
        charBuffer.mark();
        while (charBuffer.hasRemaining()){
            System.out.print(charBuffer.get());
        }
        System.out.println();
        try {
            System.out.println(charBuffer.get());
        }catch (java.nio.BufferUnderflowException e){
            System.out.println("Get a java.nio.BufferUnderflowException.");
        }

        System.out.println("\nBegin test mark,reset. ---------");
        // 将位置重置为之前mark的位置
        charBuffer.reset();
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        while (charBuffer.hasRemaining()){
            System.out.print(charBuffer.get());
        }
        System.out.println();

        System.out.println("\nBegin test compact. ---------");
        // 将位置重置为之前mark的位置
        charBuffer.reset();
        // 将已读数据清除,保留未读数据
        charBuffer.compact();
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        charBuffer.flip();
        while (charBuffer.hasRemaining()){
            System.out.print(charBuffer.get());
        }
        System.out.println();

        System.out.println("\nBegin test clear. ---------");
        //读完数据之后,可以调用clear将Buffer切换到写模式,同时删除之前所有数据
        charBuffer.clear();
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
    }

    public static void main( String[] args ) throws IOException {
        bufferP();
    }
}

下面是上面程序的输出结果

Capacity:64, limit:64, position:0
Capacity:64, limit:64, position:15

Begin test read mode. ---------
Capacity:64, limit:15, position:0
Th
Capacity:64, limit:15, position:2
is is a test.
Get a java.nio.BufferUnderflowException.

Begin test mark,reset. ---------
Capacity:64, limit:15, position:2
is is a test.

Begin test compact. ---------
Capacity:64, limit:64, position:13
is is a test.

Begin test clear. ---------
Capacity:64, limit:64, position:0

创建缓冲区

Java语言提供了8种缓存区。除了MappedByteBuffer是内存映射，其他7种对应了Java的7种内置类型。7种对应内置类型的Buffer都是抽象类，不能直接用new进行实例化。这7个类提供了相应的静态工厂方法来创建相应的类。每个类的工厂方法名都是相同的。

Java提供了静态工厂方法，用于新建Buffer对象。

allocate 方法可以分配一个指定容量的Buffer，
wrap 会直接传入一个数组，则Buffer并不会再分配新的内存创建缓冲区，而是直接使用传入的数组作为缓存区，创建的Buffer类的capacity为数组的长度，使用Buffer类的操作，都会直接影响到传入的数组，比如，Buffer.put了一个字符，则可以直接通过数组得到。

public class LearnBuffer {
    static void createBuffer(){
        char[] chars = new char[64];
        CharBuffer charBuffer = CharBuffer.wrap(chars);
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        charBuffer.append('a');
        System.out.println(chars[0]);
    }

    public static void main( String[] args ) {
        createBuffer();
    }
}

wrap 函数有两个版本，一个是直接传入一个数组，则buffer的position为0，limit为capacity；还有一种带有offset和length的版本，则buffer的position为offset,limit为length。

public class LearnBuffer {
    static void createBuffer(){
        char[] chars = new char[64];
        CharBuffer charBuffer = CharBuffer.wrap(chars, 2, 16);
        System.out.println("Capacity:"+charBuffer.capacity()+", limit:"+charBuffer.limit()
                +", position:"+charBuffer.position() );
        charBuffer.append('a');
        System.out.println(chars[2]);

        CharBuffer charBuffer1 = CharBuffer.wrap(chars);
        System.out.println("Capacity:"+charBuffer1.capacity()+", limit:"+charBuffer1.limit()
                +", position:"+charBuffer1.position());
    }

    public static void main( String[] args ) {
        createBuffer();
    }
}

复制缓存区

duplicate 函数

duplicate()函数创建一个与原始缓冲区相似的新缓冲区，新缓冲区共享旧缓冲区的数据和容量，但却有自己的position和limit。

public class LearnBuffer {
    static void duplicateBuffer(){
        CharBuffer charBuffer = CharBuffer.allocate(64);
        charBuffer.append("This is a duplicate test.");
        System.out.println("charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        CharBuffer newBuffer = charBuffer.duplicate();
        System.out.println("newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        charBuffer.flip();
        System.out.println("After charBuffer flip, charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("After charBuffer flip, newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        System.out.println(charBuffer.get(0));
        newBuffer.put(0, 'H');
        System.out.println(charBuffer.get(0));
    }

    public static void main( String[] args ) {
        duplicateBuffer();
    }
}

asReadOnlyBuffer()函数生成一个只读的缓冲区，和duplicate函数一样，新的只读缓冲区，和之前缓冲区共享数据和容量，各自拥有自己的position和limit。但只读缓冲区是不能调用put函数，否则会抛出ReadOnlyBufferException异常。

public class LearnBuffer {
    static void readOnlyBuffer(){
        CharBuffer charBuffer = CharBuffer.allocate(64);
        charBuffer.append("This is a readonly test.");

        CharBuffer newBuffer = charBuffer.asReadOnlyBuffer();

        System.out.println("charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        charBuffer.flip();
        System.out.println("After charBuffer flip, charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("After charBuffer flip, newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        try {
            newBuffer.append('a');
        }catch (ReadOnlyBufferException e){
            System.out.println("Get an java.nio.ReadOnlyBufferException");
        }
    }

    public static void main( String[] args ) {
        readOnlyBuffer();
    }
}

slice()函数也是产生新的缓冲区，并且与旧缓冲区共享数据，但slice()产生的缓冲区的容量是原缓冲区limit-position

static public void sliceBuffer(){
        CharBuffer charBuffer = CharBuffer.allocate(64);
        charBuffer.append("This is a slice test.");

        CharBuffer newBuffer = charBuffer.slice();

        System.out.println("charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        charBuffer.append("Add new string.");
        System.out.println(newBuffer.get(0));

        System.out.println("charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("newBuffer capacity:"+newBuffer.capacity()+", position:"+newBuffer.position()+", limit:"+newBuffer.limit());

        charBuffer.flip();
        CharBuffer newBuffer2 = charBuffer.slice();
        System.out.println("charBuffer capacity:"+charBuffer.capacity()+", position:"+charBuffer.position()+", limit:"+charBuffer.limit());
        System.out.println("newBuffer2 capacity:"+newBuffer2.capacity()+", position:"+newBuffer2.position()+", limit:"+newBuffer2.limit());
    }
雙湖之梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【NIO】学习系列（一）Buffer
雨天的麦子的博客
10-13 223
NIO概念 我们知道常见的IO是阻塞的且效率低下的，为了解决这个问题引入了NIO，NIO在IO的基础上使用了cha[] 、byte[]进行了封装，采用ByteBuffer类来操作数据，而且针对File和Socket的channel，使用同步非阻塞实现高性能处理。网上一大堆，这里不做过多阐述 Buffer类 buffer类是一个抽象类已知子类（除了boolean类型，其他基本类型都有对应的buffer） StringBuffer在NIO没有涉及，字符缓冲可用CharBuffer来做。 ByteBuffer
文件系统基本概念——高速缓冲 buffer.c学习笔记
weixin_46199479的博客
03-17 1056
文件系统中的高速缓冲区操作。
NIO学习教程
Andrew_Yuan的博客
05-07 3199
文件传输传统的IO通信：磁盘→系统→程序→socket→协议引擎NIO：磁盘→系统→socket→协议引擎NIO注意几个关键词：Java NIO: Channels and Buffers（通道和缓冲区）、Non-blocking IO（非阻塞IO）、Selectors（选择器）。标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是...
java nio 2_5种调优Java NIO和NIO.2的方式
weixin_36011776的博客
02-16 181
Java NIO(New Input/Output)——新的输入/输出API包——是2002年引入到J2SE 1.4里的。Java NIO的目标是提高Java平台上的I/O密集型任务的性能。过了十年，很多Java开发者还是不知道怎么充分利用NIO，更少的人知道在Java SE 7里引入了更新的输入/输出 API(NIO.2)。这篇教程展示了5个在Java编程的一些常见场景里使用NIO和NIO.2包...
NIO学习总结
weixin_45472766的博客
03-20 137
NIO，零拷贝
Java NIO Buffer过程详解
08-25
Java NIO Buffer 过程详解 Java NIO Buffer 是 Java NIO 中的一种重要组件，负责数据的存储和传输。缓冲区是数组，用于存储不同数据类型的数据。在与 NIO 通道交互时，Java NIO Buffer plays a crucial role. 基本...
JAVA NIO学习笔记.docx
最新发布
09-02
IO 是主存和外部设备 ( 硬盘、终端和网络等 ) 拷贝数据的过程。 IO 是操作系统的底层功能实现，底层通过 I/O 指令进行完成。 所有语言运行时系统提供执行 I/O 较高级别的... (c 的 printf scanf,java 的面向对象封装 )
Java NIO学习笔记——ByteBuffer用法
03-24
NULL 博文链接：https://zheng12tian.iteye.com/blog/1094811
Java NIO详解（学习资料）
06-20
Java NIO，全称为Non-Blocking Input/Output，即非阻塞I/O，是Java从1.4版本开始引入的一种I/O模型，旨在提供一种更高效的数据读写方式，尤其适用于处理大量并发连接的情况。传统的Java IO基于BIO（ Blocking I/O）...
Java NIO学习资料+代码.zip
07-07
Java NIO学习资料+代码.zip
【Java进阶】NIO（二）＜Buffer＞
行为产生结果
06-09 941
Buffer缓冲区实际上就是一个数组，把数组的内容和信息包装成一个Buffer对象，它提供了一组访问这些信息的方法在NIO中关键的Buffer① ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer，这些Buffer覆盖了能够通过I/O发送的所有基本类型byte、char、double、float、int、long、short等② 实际上使用较多的是ByteBuffer、CharBuffer。
Java语言进阶：Buffer类（缓冲区）
weixin_48351326的博客
05-28 4706
Java语言进阶：Buffer类（缓冲区） Buffer类（缓冲区） 概述:Buffer是一个抽象类，它是对某种基本类型的数组进行了封装。 作用: 在NIO中，就是通过 Buffer 来读写数据的。所有的数据都是用Buffer来处理的，它是NIO读写数据的中转池, 通常使用字节数组。 Buffer主要有如下几种： ByteBuffer CharBuffer DoubleBuffer FloatBuffer IntBuffer LongBuffer ShortBuffer 创建ByteBuffer 路径
Buffer类的详解(转)
ahu6741的博客
05-10 2046
这篇蚊帐转自：http://zachary-guo.iteye.com/blog/1457542，作者写的非常好，是我看到的写nio最好的几篇蚊帐，但原文中有一些错误，还有我自己对这方面的一些理解，在这里一并更改了。 Buffer 类是 java.nio 的构造基础。一个 Buffer 对象是固定数量的数据的容器，其作用是一个存储器，或者分段运输区，在这里，数据可被存储并在之后用于检索...
Java NIO 模型代码示例
qq_33471737的博客
12-12 1811
在高并发（持续大量的连接同时请求）场景中，之前的两种 BIO 优化方案都需要消耗大量的线程来维持连接。并且 CPU 在线程切换上消耗很大。 Java NIO 模型的主要优势：少量的线程就可以处理大量连接的请求。 主要组成： Channel 通道：IO 传输发生时数据通过的入口 Buffer 缓冲区：可以理解为数据在管道传输时的起点和终点 Selector 选取器（IO监听器）：负责监听 IO 事件 所用通道都向 Selector 注册，Selector 负责轮询检测，然后服务端进程会阻塞在 Select
CharBuffer
思睿-Sirui
05-11 3649
CharBuffer public abstract class CharBuffer extends Buffer implements Comparable<CharBuffer>, Appendable, CharSequence, Readable { /** * 间接buffer，使用heap buffers备份数组 */ fi...
CharBuffer源码解读
默默的小熊
07-27 580
public abstract class CharBuffer extends Buffer implements Comparable<CharBuffer>, Appendable, CharSequence, Readable { final char[] hb; //指向缓冲区的数据存储的引用 final int offset; boolea...
攻破JAVA NIO技术壁垒
weixin_33738555的博客
05-19 5687
现在使用NIO的场景越来越多，很多网上的技术框架或多或少的使用NIO技术，譬如Tomcat，Jetty。学习和掌握NIO技术已经不是一个JAVA攻城狮的加分技能，而是一个必备技能。再者，现在互联网的面试中上点level的都会涉及一下NIO或者AIO的问题（AIO下次再讲述，本篇主要讲述NIO）,掌握好NIO也能帮助你获得一份较好的off...
彻底搞懂NIO效率高的原理
全菜工程师小辉的博客
07-29 5810
前言 这篇文章读不懂的没关系，可以先收藏一下。笔者准备介绍完epoll和NIO等知识点，然后写一篇Java网络IO模型的介绍，这样可以使Java网络IO的知识体系更加地完整和严谨。初学者也可以等看完IO模型介绍的博客之后，再回头看这些博客，会更加有收获。 NIO相比BIO的优势 NIO（Non-blocking I/O，在Java领域，也称为New I/O），是一种同步非阻塞的I/O模型，也...
java buffer简单介绍和使用
qq_40628645的博客
10-12 1357
1.两个gat set实现方法 2.remark reset
java.nio API学习
05-01
Java NIO（New I/O）是一个可以替代标准 Java I/O API 的 Java API。NIO 提供了更快速、更高效的 I/O 操作方式，也可以进行非阻塞 I/O 操作。 下面是几个 NIO 核心类和接口： - Buffer：缓冲区，用于数据的读取和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值