Java NIO系列3 缓冲区

时间:2019-01-18
本文章向大家介绍Java NIO系列3 缓冲区,主要包括Java NIO系列3 缓冲区使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。
                     

前言

一直想把NIO系列的文章更新下去,只不过发现在入职支付宝后工作实在是忙,所以一直拖到现在。直接从一个学生过狗成为一名加班狗,好吧,这就是互联网公司的现状吧,但是每天都是充实的,而且发现其他的员工也基本非常乐意加班,难道这就是阿里的文化熏陶?!

废话不多说,还是进入今天的正题,在前面的文章中,我们已经对Java的NIO有了一个粗浅的认识——主要之为了支持非阻塞I/O的操作,之前的BIO则是阻塞的。因为异步性的引入,大大提高了Java在处理异步任务的效率。下面认识下NIO中的缓冲区:

认识缓冲区

缓冲区可以理解为存储固定数量的容器,这些数据可以在存储后被检索,缓冲区的数据可以被写满或者被释放,而这些操作的实现需要认识缓冲区的属性:容量(capacity)、上界(limit)、位置(position)和标记(mark)。这四个属性的关系可以用下图来表示:

理解好这张图,缓冲区的精髓就掌握的四五分了,还有四五分从哪里来呢?当然是实践中来了。这张图传达了如下的信息:

0 <= mark <= position <= limit <= capacity
  • 1

容量
容量是指缓冲区可以容纳的最大元素个数,这一容量在缓冲区被创建的时候就被指定了。

上界
就是缓冲区现存元素的计数

位置
下一个要被读取的元素的索引

标记
由于在读取过程中position的值是动态变化,如果在读到某一个位置的时候需要做一个标记以便下次继续读,就可以做一个“书签”,让mark的值等于当前读到的position的值。

在java.nio包中Buffer类是缓冲区的顶层类,其他的缓冲区类都是基于这个类展开的。一个缓冲区类的主要方法如下:

public abstract class Buffer {    // 获取缓冲区的容量    public final int capacity( );    // 获取下一个将要被读取的元素的索引    public final int position( );    // 设置缓冲区的位置为新位置    public final Buffer position (int newPositio);    // 返回上界    public final int limit( );    // 设置新的上界    public final Buffer limit (int newLimit);    // 返回标记的值    public final Buffer mark( );    // 将position重置为mark的值    public final Buffer reset( );    // 清空对上界和位置的操作    public final Buffer clear( );    // 重置position为0并将上界设为远position的值    public final Buffer flip( );    // 将position设置0    public final Buffer rewind( );    // 返回剩余未读的元素个数    public final int remaining( );    // 判断是否还有未读的元素    public final boolean hasRemaining( );    // 判断是否是只读    public abstract boolean isReadOnly( );}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

作为一个缓冲区,肯定是需要存取数据的,但是在Buffer类中并没有get和put类似的方法,实际上Java 设计者将get和put方法放到子类实现了。这样设计主要是考虑到在只需要关心缓冲区钟部分数据的情况,因为在这种情况可能有不同的存取策略。

缓冲区实战

现在已经对缓冲区有了一个基本认识,缓冲区的操作主要涉及以下几个部分:

 

存取
  翻转
  释放
  压缩
  标记
  比较
  批量移动

存取、翻转和释放

在缓冲区存取元素,需要创建缓冲区,存取操作的两个核心方法是:get和put方法,完成翻转只需要调用flip方法。下面是一个简单示例:

package com.rhwayfun.patchwork.nio.buffer;import java.nio.CharBuffer;/** * @description: Buffer缓冲区演示 * @author: rhwayfun * @since: 2016-05-21 */public class BufferFillDrain {    // 位置    private static int index = 0;    // 需要填充入缓冲区字符串数组    private static String[] strings = new String[]{            "Hello, this is a buffer",            "I am learning buffer",            "It is a wonderful world"    };    public static void main(String[] args) {        // 申请100字节的缓冲区        CharBuffer buffer = CharBuffer.allocate(100);        // 如果缓存区没有达到上界则可以继续填充        while (fillBuffer(buffer)){            // 缓冲区翻转            // flip可以将上界设为当前position的位置            // 并将position重置为0            buffer.flip();            // 从缓冲区释放数据            drainBuffer(buffer);            // 清空缓冲区            // 调用clear方法可本质上干了两件事            // 一:将上界limit设为容量大小的位置            // 二:将position重置为0            buffer.clear();        }    }    private static void drainBuffer(CharBuffer buffer) {        // 得到剩余的元素个数        int count = buffer.remaining();        for (int i = 0; i < count; i++){            System.out.println(i + "--->" + buffer.get());        }    }    private static boolean fillBuffer(CharBuffer buffer) {        if (index >= strings.length) {            return false;        }        // 依次放入每个字符串数组        String s = strings[index++];        for (int i = 0; i < s.length(); i++){            buffer.put(s.charAt(i));        }        return true;    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

压缩
压缩使用在需要释放缓冲区的空间的场景,执行压缩需要调用compact方法。该方法的会首先将position位置之后的元素(如果没有调用flip方法的话)复制从0开始的位置上,而position位置及之后的元素保持不变,在进行元素复制的过程中position的值也会发生改变。压缩的过程可以用如下的图表示:

下面的代码有演示了这个过程:

package com.rhwayfun.patchwork.nio.buffer;import java.nio.CharBuffer;/** * @description: 使用compact方法释放一部分数据 * @author: rhwayfun * @since: 2016-05-21 */public class BufferCompact {    public static void main(String[] args) {        String s = "hello";        CharBuffer buffer = CharBuffer.allocate(10);        for (int i = 0; i < s.length(); i++){            buffer.put(s.charAt(i));        }        // 将第一个位置的字符h换为M,并填入一个新的字符w        buffer.put(0,'M').put('w');        // 现在缓冲区的元素是Mellow,position的位置是6,limit和capacity都是10        // 调用flip方法得到有效元素的位置,其实也就是position的位置        buffer.flip();        // 将M和e两个个字符释放掉        System.out.println("release char " + buffer.get());        System.out.println("release char " + buffer.get());        // 调用compact方法可以回收M和e字符占用的空间        // 调用compact后position位置是4,        // 0-3位置的字符依次是llow,4-5位置的字符依次是ow        // 虽然4-5位置有字符,但是调用put方法后会被重写        // 并且调用compact方法后limit又回到了capacity的位置,也就是10        buffer.compact();        // 将4-5位置的字符修改为ab        buffer.put('a').put('b');        // 输出缓冲区的元素,根据上面的分析,最后输出的字符应该是llowab        // 需要先调用flip方法将position设为0,这样才能读到完整的字符        buffer.flip();        while (buffer.hasRemaining()){            System.out.println("print output " + buffer.get());        }    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

比较
缓冲区的比较可以使用equals方法,进行缓冲区的比较的意义在于检测缓冲区包含的数据是否相同。当然,缓冲区的比较也支持使用compareTo方法进行比较。如果buffer1.equals(buffer2)要返回true,那么需要满足以下条件才可以:

  • 两个对象类型相同。包含不同数据类型的 buffer 永远不会相等,而且 buffer绝不会等于非 buffer 对象。
  • 两个对象都剩余同样数量的元素。Buffer 的容量不需要相同,而且缓冲区中剩余数据的索引也不必相同。但每个缓冲区中剩余元素的数目(从位置到上界)必须相同。
  • 在每个缓冲区中应被 Get()函数返回的剩余数据元素序列必须一致。

下面的代码演示了进行缓冲区比较的过程:

package com.rhwayfun.patchwork.nio.buffer;import java.nio.CharBuffer;/** * @description: 使用equals方法比较两个缓冲区是否相等 * @author: rhwayfun * @since: 2016-05-21 */public class BufferCompareWithEquals {    public static void main(String[] args) {        String s1 = "two com";        String s2 = "com";        CharBuffer buffer1 = CharBuffer.allocate(10);        CharBuffer buffer2 = CharBuffer.allocate(10);        for (int i = 0; i < s1.length(); i++){            buffer1.put(s1.charAt(i));        }        // 调用flip方法后limit为7        buffer1.flip();        // 继续往缓冲区放入一个字符,当前position的位置是1        buffer1.put('A');        // 将当前位置设为4,也就是字符c开始的位置        buffer1.position(4);        /*System.out.print("buffer1: ");        while (buffer1.hasRemaining()){            System.out.print(buffer1.get() + " ");        }*/        for (int i = 0; i < s2.length();i++){            buffer2.put(s2.charAt(i));        }        // limit的位置是3,position的位置是0        buffer2.flip();        // 现在执行put方法会把位置0的字符c替换为B        buffer2.limit(4);        buffer2.put(3,'B');        buffer2.position(0);        buffer2.limit(3);        /*System.out.print("buffer2: ");        while (buffer2.hasRemaining()){            System.out.print(buffer2.get() + " ");        }*/        // 使用equals方法比较两个缓冲区是否相等        // 必须满足三个条件才能返回true        // 1)两个缓冲区的对象的类型必须相同        // 2)缓冲区的元素不必完全相同,但是如果position到limit之间的元素不相同,也返回false        // 3)每个缓冲区get方法得到元素序列必须一致        System.out.println(buffer1.equals(buffer2));        // 还可以使用compareTo方法比较两个缓冲区,但是如果两个缓冲区的元素的类型不一致,equals方法返回false        // 而compareTo方法则直接抛出ClassCastException的异常    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

批量操作
在之前的get和put方法,一次只能支持操作一个元素,从效率的角度讲还是很低的,那么有没有批量操作的方法呢?在Buffer API中可以使用重载的get和put方法进行批量的操作。下面的代码演示了如何进行缓冲区的批量操作:

package com.rhwayfun.patchwork.nio.buffer;import java.nio.CharBuffer;/** * @description: 批量操作缓冲区 * @author: rhwayfun * @since: 2016-05-21 */public class BufferBatchOperation {    public static void main(String[] args) {        copyToBigArray();        copyToSmallArray();        System.out.println();        putStringToBuffer();    }    private static void copyToBigArray() {        // 将一个缓冲区释放到一个大数组中        String s = "hello,rhwayfun";        CharBuffer buffer = CharBuffer.allocate(20);        for (int i = 0; i < s.length(); i++){            buffer.put(s.charAt(i));        }        buffer.flip();        // 创建一个大数组        char[] array = new char[100];        // 如果直接使用get方法将元素释放到array数组中        // 则实际上将数组的0位置到最后一个位置,这里是        // 99,依次将缓冲区的元素释放到数组中。由于缓冲        // 区的元素根本不够,所以会抛出BufferUnderflowException异常        // buffer.get(array);        int remaining = buffer.remaining();        buffer.get(array,0,remaining);        // 测试array数组        for (char c : array){            System.out.print(c + " ");        }    }    private static void copyToSmallArray(){        // 将一个缓冲区释放到一个大数组中        String s = "hello,rhwayfun";        CharBuffer buffer = CharBuffer.allocate(20);        for (int i = 0; i < s.length(); i++){            buffer.put(s.charAt(i));        }        buffer.flip();        char[] array = new char[10];        while (buffer.hasRemaining()){            int length = Math.min(array.length,buffer.remaining());            buffer.get(array,0,length);        }    }    private static  void putStringToBuffer(){        String s = "Good morning";        CharBuffer buffer = CharBuffer.allocate(20);        buffer.put(s);        buffer.flip();        while (buffer.hasRemaining()) {            System.out.print(buffer.get() + " ");        }    }}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67

小结

通过以上的叙述以及针对缓冲区的也也演示操作,我们对缓冲区的掌握也更加深入了,其实对缓冲区的理解最关键的还是缓冲区的模型图。这个图理解了,掌握Buffer类的API也就驾轻就熟了。