精华内容
下载资源
问答
  • 我们原有 IO 读写文件应该不会陌生了,顺带回顾一下,大致两种:1....2. 包装成 Reader/Writer 可以直接读写字符串,进一步包装到 BufferedReader/BufferedWriter 就可以按行读写了。readLine() 时看...

    我们用原有 IO 读写文件应该不会陌生了,顺带回顾一下,大致两种:

    1. 在 InputStream 或 OutputStream 上读写字节或字节数组,读 InputStream 时用是否返回 -1 来判断是否到达末尾。

    2. 包装成 Reader/Writer 可以直接读写字符串,进一步包装到 BufferedReader/BufferedWriter 就可以按行读写了。readLine() 时看是否返回 null 断定是否读完了最后一行。

    现在我们要用 NIO 来读写文件,肯定是要用到 Channel 和 Buffer 了。一句话描述过程就是从 FileInputStream 得到的 FileChannel 中读取数据到 Buffer 中,再处理 Buffer 中的数据。看代码:

    01.public static void main(String[] args) throws Exception {

    02.    FileInputStream fis = new FileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    03.

    04.    //得到文件通道

    05.    FileChannel fc = fis.getChannel();

    06.

    07.    //分配与文件尺寸等大的缓冲区

    08.    ByteBuffer bf = ByteBuffer.allocate((int) fc.size());

    09.

    10.    //整个文件内容全读入缓冲区,即是内存映射文件

    11.    fc.read(bf);

    12.

    13.    //把缓冲中当前位置回复为零

    14.    bf.rewind();

    15.

    16.    //输出缓冲区中的内容

    17.    while (bf.hasRemaining()) {

    18.        System.out.print((char) bf.get());

    19.    }

    20.}

    复制代码

    上面程序使用了一个与文件尺寸等大的缓冲区,正好能一次性把文件内容全部读入内存,如果文件过多将是十分耗费的内存的,所以我们可能须手工指定某个大小(如 1024,2048) 的缓冲区,然后分多次读入文件内容到缓冲区中。这时候程序就是下面那样子了:

    01.public static void main(String[] args) throws Exception {

    02.    FileInputStream fis = new FileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    03.

    04.    // 得到文件通道

    05.    FileChannel fc = fis.getChannel();

    06.

    07.    // 指定大小为 1024 的缓冲区

    08.    ByteBuffer bf = ByteBuffer.allocate(1024);

    09.

    10.    // 读取通道中的下一块数据到缓冲区中

    11.    // 缓冲区的 position 即为当前缓冲区中最后有效位置

    12.    while (fc.read(bf) != -1) {

    13.

    14.        //把缓冲中当前位置回复为零,前把缓冲区的 limit 设置为之前 position 值

    15.        bf.flip();

    16.

    17.        // 输出缓冲区中的内容

    18.        while (bf.hasRemaining()) {

    19.            System.out.print((char) bf.get());

    20.        }

    21.

    22.        // 清理缓冲区,准备再次读取数据

    23.        bf.clear();

    24.    }

    25.}

    留意对缓冲区的 rewind()/flip()/clear() 操作所产生的影响,即对 position/limit/mark 等标志的影响。最后提醒操作完之后,要关闭通道和输入流。

    用 ByteBuffer 知道了怎么读文件内容(当然,还未涉及到中文内容)并打印到屏幕后,再来看看 NIO 怎么写文件:

    view source

    print?

    01.public static void main(String[] args) throws FileNotFoundException, IOException{

    02.    FileOutputStream fos = new FileOutputStream("c:/nio.tst");

    03.

    04.    // 得到文件通道

    05.    FileChannel fc = fos.getChannel();

    06.

    07.    // 指定大小为 1024 的缓冲区

    08.    ByteBuffer bf = ByteBuffer.allocate(1024);

    09.

    10.    // 要写入文件的字符串

    11.    String greeting = "Hello, Java NIO";

    12.

    13.    //把以上字符串逐字放入缓冲区

    14.    for (int i = 0; i < greeting.length(); i++) {

    15.        bf.putChar(greeting.charAt(i));

    16.    }

    17.

    18.    // 记得执行这个方法,使得 position=0, limit=30, 才能写入正确的数据

    19.    // 否则 position 为 30, limit 为 1024,将会把 30 之后的全部空数据(0) 填到文件中

    20.    bf.flip();

    21.

    22.    // 缓冲区数据写入到文件中,会把缓冲区中从 position 到 limit 之间的数据写入文件

    23.    fc.write(bf);

    24.

    25.    fc.close(); //关闭文件通道

    26.    fos.close(); //关闭文件输出流

    27.}

    复制代码

    同样的,如果是写入中文内容,也需要进行字符集的相关处理。执行后在 C 盘根目录下产生 nio.tst 文件,内容就是 Hello, Java NIO。此代码的关键之处就是对缓冲的 flip() 调用,你可以在调试模式下观察到 flip() 方法调用前后,缓冲区 bf 的 position/limit 属性的变化。试着注释掉 flip() 代码,看看两次生成的 nio.tst 文件内容是不是大相径庭。

    所以,要用好 NIO,缓冲区的 mark/position/limit/capacity 属性应理解,以及 clear()/flip()/rewind() 分别会怎么影响到以上属性。

    还有,虽然说通道是双向的,字面上不像流那样区分输入通道或是输出通道,但实际通道也存在只读或只写的特性,例如由 FileInputStream.getChannel() 获得的通道是无法写入内容的,由 FileOutputStream.getChannel() 获得的通道是不能读的,否则会抛出相应的异常 NonWritableChannelException 和 NonReadableChannelException。而且 Buffer 也存在着是否只读的属性。

    前面的代码在这里只是说明用 NIO 读写文件应如何处理,并不是说比起用旧 IO 流式的写法效率就更高了。NIO 的高效率只会体现在有些时候,并非任何时候都优于旧 IO,那是块操作和字节操作的区别,用 NIO 时要小心内存。伸手就能摘到的梨用不着搬个凳子,何况旧 IO 实现起来还更简洁些呢!

    展开全文
  • Java.nio-随机读写汉字

    2017-05-05 19:19:00
    笔者最近在多线程来计算中文文本的标点符号数目,遇到了以下问题: 在Windows下,文本中汉字通常采用Unicode编码,这就导致需要随机(RandomAccessFile)读取文本时,产生乱码现象。 多线程计算前(假设有2个线程)...

    笔者最近在用多线程来计算中文文本的标点符号数目,遇到了以下问题:

    • 在Windows下,文本中汉字通常采用Unicode编码,这就导致需要随机(RandomAccessFile)读取文本时,产生乱码现象。
    • 多线程计算前(假设有2个线程),需要将文本内容尽量等分成2份,并输出到新的文件中,再进行计算。

    总体思路:

    • 规定一次读取的字节数,再在存储和输出时转化成GBK编码
      • 由于RandomAccessFile可以随机定位读取起始点,当规定了一次读取的字节数,也就规定了读取结束点。
      • 按行读取,每一行的字节有对应的数组保存,转化成GBK后,写入输出文本。
    • 引入java.nio,在读取文件和转化编码时方便很多,笔者认为java.io也可以实现。
      • 关于NIO的详细教程可以参考:NIO系列教程
      • 本文引入java.nio.ByteBuffer,java.nio.channels.FileChannel,前者无需解释,后者为通道,相当于流。

    具体代码实现如下:

    package Yue.IO;
    
    import java.io.*;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /**
     * 将文本内容尽量分成n份,使n个线程处理对应的文本
     */
    public class SplitFile {
        int fileNum;                                                    //分离的文件数
        File fileIn = new File("E:\\白夜行.txt");
        int bufSize;
    
        SplitFile(int threadsNum) {
            fileNum = threadsNum;
            bufSize = (int) (fileIn.length() / fileNum);                //一次读取的字节数
        }
    
        FileChannel fileChaIn, fileChaOut;
        ByteBuffer rBuffer, wBuffer;
    
        /*设置缓冲区,读文件时,最后一行往往不完整,需要将存在断点的那一行保存,与下一次读文本时的第一行合并*/
        byte[] temp = new byte[0];
    
        /**
         * 按行具体读出每一个线程所要处理的文本内容
         *
         * @param NO    Thread-NO
         */
        public void readByLine(int NO) {
            String enter = "\n";
            byte[] lineByte;                                            //保存每一行读取内容
    
            /*确认读取范围*/
            try {
                RandomAccessFile raf = new RandomAccessFile(fileIn, "r");
                raf.seek(NO * bufSize);                                 //根据分离文本进程定位
                fileChaIn = raf.getChannel();
                rBuffer = ByteBuffer.allocate(bufSize);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            try {
                if (fileChaIn.read(rBuffer) != -1) {
                    /*生成输出文件Part-No.txt*/
                    try {
                        fileChaOut = new RandomAccessFile("E:\\Part-" + NO + ".txt", "rws").getChannel();
                        wBuffer = ByteBuffer.allocateDirect(bufSize);
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
    
                    /*根据一次读取,确定本次输出的字节长度*/
                    int rSize = rBuffer.position();
                    byte[] bs = new byte[rSize];
                    rBuffer.rewind();
                    rBuffer.get(bs);
                    rBuffer.clear();
    
                    int startNum = 0;
                    int LF = 10;                                        //换行符
                    int CR = 13;                                        //回车符
                    boolean hasLF = false;                              //是否有换行符
                    for (int i = 0; i < rSize; i++) {
                        if (bs[i] == LF) {
                            hasLF = true;
                            int tempNum = temp.length;
                            int lineNum = i - startNum;
                            lineByte = new byte[tempNum + lineNum];     //数组大小已经去掉换行符
    
                            /*把上一次读取保存在缓冲区的内容和本次读取的这一行的内容合并,保存到lineByte[]中*/
                            System.arraycopy(temp, 0, lineByte, 0, tempNum);
                            temp = new byte[0];
                            System.arraycopy(bs, startNum, lineByte, tempNum, lineNum);
    
                            /*把该行内容转换成String类型,写入输出文件中*/
                            String line = new String(lineByte, 0, lineByte.length, "GBK");
                            writeByLine(line + enter);
    
                            /*过滤回车和换行*/
                            if (i == rSize - 1 && bs[i + 1] == CR) {
                                startNum = i + 2;
                            } else {
                                startNum = i + 1;
                            }
                        }
                    }
    
                    /*对每次读取的最后一行做特殊处理,将未读完整的当前行不输出,保存在缓冲区中,与下一次读取时合并*/
                    if (hasLF) {
                        temp = new byte[bs.length - startNum];
                        System.arraycopy(bs, startNum, temp, 0, temp.length);
                    } else {
                        /*兼容单次读取不足一行的情况*/
                        byte[] toTemp = new byte[bs.length + temp.length];
                        System.arraycopy(temp, 0, toTemp, 0, temp.length);
                        System.arraycopy(bs, 0, toTemp, temp.length, bs.length);
                        temp = toTemp;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    fileChaIn.close();
                    fileChaOut.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 写入输出文件
         *
         * @param line 已转换成String类型的当前行文本内容
         */
        public void writeByLine(String line) {
            try {
                fileChaOut.write(wBuffer.wrap(line.getBytes("GBK")), fileChaOut.size());
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    转载于:https://www.cnblogs.com/duyue6002/p/6814606.html

    展开全文
  • 我们原有 IO 读写文件应该不会陌生了,顺带回顾一下,大致两种:1....2. 包装成 Reader/Writer 可以直接读写字符串,进一步包装到 BufferedReader/BufferedWriter 就可以按行读写了。readLine() 时看...

    我们用原有 IO 读写文件应该不会陌生了,顺带回顾一下,大致两种:

    1. 在 InputStream 或 OutputStream 上读写字节或字节数组,读 InputStream 时用是否返回 -1 来判断是否到达末尾。

    2. 包装成 Reader/Writer 可以直接读写字符串,进一步包装到 BufferedReader/BufferedWriter 就可以按行读写了。readLine() 时看是否返回 null 断定是否读完了最后一行。

    现在我们要用 NIO 来读写文件,肯定是要用到 Channel 和 Buffer 了。一句话描述过程就是从 FileInputStream 得到的 FileChannel 中读取数据到 Buffer 中,再处理 Buffer 中的数据。看代码:

    public static void main(String[] args) throws Exception {

    FileInputStream fis = new FileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    //得到文件通道

    FileChannel fc = fis.getChannel();

    //分配与文件尺寸等大的缓冲区

    ByteBuffer bf = ByteBuffer.allocate((int) fc.size());

    //整个文件内容全读入缓冲区,即是内存映射文件

    fc.read(bf);

    //把缓冲中当前位置回复为零

    bf.rewind();

    //输出缓冲区中的内容

    while (bf.hasRemaining()) {

    System.out.print((char) bf.get());

    }

    }

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    publicstaticvoidmain(String[]args)throwsException{

    FileInputStreamfis=newFileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    //得到文件通道

    FileChannelfc=fis.getChannel();

    //分配与文件尺寸等大的缓冲区

    ByteBufferbf=ByteBuffer.allocate((int)fc.size());

    //整个文件内容全读入缓冲区,即是内存映射文件

    fc.read(bf);

    //把缓冲中当前位置回复为零

    bf.rewind();

    //输出缓冲区中的内容

    while(bf.hasRemaining()){

    System.out.print((char)bf.get());

    }

    }

    上面程序使用了一个与文件尺寸等大的缓冲区,正好能一次性把文件内容全部读入内存,如果文件过多将是十分耗费的内存的,所以我们可能须手工指定某个大小(如 1024,2048) 的缓冲区,然后分多次读入文件内容到缓冲区中。这时候程序就是下面那样子了:

    public static void main(String[] args) throws Exception {

    FileInputStream fis = new FileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    // 得到文件通道

    FileChannel fc = fis.getChannel();

    // 指定大小为 1024 的缓冲区

    ByteBuffer bf = ByteBuffer.allocate(1024);

    // 读取通道中的下一块数据到缓冲区中

    // 缓冲区的 position 即为当前缓冲区中最后有效位置

    while (fc.read(bf) != -1) {

    //把缓冲中当前位置回复为零,前把缓冲区的 limit 设置为之前 position 值

    bf.flip();

    // 输出缓冲区中的内容

    while (bf.hasRemaining()) {

    System.out.print((char) bf.get());

    }

    // 清理缓冲区,准备再次读取数据

    bf.clear();

    }

    }

    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

    publicstaticvoidmain(String[]args)throwsException{

    FileInputStreamfis=newFileInputStream("C:/Java/jdk1.6.0_18/LICENSE");

    // 得到文件通道

    FileChannelfc=fis.getChannel();

    // 指定大小为 1024 的缓冲区

    ByteBufferbf=ByteBuffer.allocate(1024);

    // 读取通道中的下一块数据到缓冲区中

    // 缓冲区的 position 即为当前缓冲区中最后有效位置

    while(fc.read(bf)!=-1){

    //把缓冲中当前位置回复为零,前把缓冲区的 limit 设置为之前 position 值

    bf.flip();

    // 输出缓冲区中的内容

    while(bf.hasRemaining()){

    System.out.print((char)bf.get());

    }

    // 清理缓冲区,准备再次读取数据

    bf.clear();

    }

    }

    留意对缓冲区的 rewind()/flip()/clear() 操作所产生的影响,即对 position/limit/mark 等标志的影响。最后提醒操作完之后,要关闭通道和输入流。

    用 ByteBuffer 知道了怎么读文件内容(当然,还未涉及到中文内容)并打印到屏幕后,再来看看 NIO 怎么写文件:

    public static void main(String[] args) throws FileNotFoundException, IOException{

    FileOutputStream fos = new FileOutputStream("c:/nio.tst");

    // 得到文件通道

    FileChannel fc = fos.getChannel();

    // 指定大小为 1024 的缓冲区

    ByteBuffer bf = ByteBuffer.allocate(1024);

    // 要写入文件的字符串

    String greeting = "Hello, Java NIO";

    //把以上字符串逐字放入缓冲区

    for (int i = 0; i < greeting.length(); i++) {

    bf.putChar(greeting.charAt(i));

    }

    // 记得执行这个方法,使得 position=0, limit=30, 才能写入正确的数据

    // 否则 position 为 30, limit 为 1024,将会把 30 之后的全部空数据(0) 填到文件中

    bf.flip();

    // 缓冲区数据写入到文件中,会把缓冲区中从 position 到 limit 之间的数据写入文件

    fc.write(bf);

    fc.close(); //关闭文件通道

    fos.close(); //关闭文件输出流

    }

    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

    publicstaticvoidmain(String[]args)throwsFileNotFoundException,IOException{

    FileOutputStreamfos=newFileOutputStream("c:/nio.tst");

    // 得到文件通道

    FileChannelfc=fos.getChannel();

    // 指定大小为 1024 的缓冲区

    ByteBufferbf=ByteBuffer.allocate(1024);

    // 要写入文件的字符串

    Stringgreeting="Hello, Java NIO";

    //把以上字符串逐字放入缓冲区

    for(inti=0;i<greeting.length();i++){

    bf.putChar(greeting.charAt(i));

    }

    // 记得执行这个方法,使得 position=0, limit=30, 才能写入正确的数据

    // 否则 position 为 30, limit 为 1024,将会把 30 之后的全部空数据(0) 填到文件中

    bf.flip();

    // 缓冲区数据写入到文件中,会把缓冲区中从 position 到 limit 之间的数据写入文件

    fc.write(bf);

    fc.close();//关闭文件通道

    fos.close();//关闭文件输出流

    }

    同样的,如果是写入中文内容,也需要进行字符集的相关处理。执行后在 C 盘根目录下产生 nio.tst 文件,内容就是 Hello, Java NIO。此代码的关键之处就是对缓冲的 flip() 调用,你可以在调试模式下观察到 flip() 方法调用前后,缓冲区 bf 的 position/limit 属性的变化。试着注释掉 flip() 代码,看看两次生成的 nio.tst 文件内容是不是大相径庭。

    所以,要用好 NIO,缓冲区的 mark/position/limit/capacity 属性应理解,以及 clear()/flip()/rewind() 分别会怎么影响到以上属性。

    还有,虽然说通道是双向的,字面上不像流那样区分输入通道或是输出通道,但实际通道也存在只读或只写的特性,例如由 FileInputStream.getChannel() 获得的通道是无法写入内容的,由 FileOutputStream.getChannel() 获得的通道是不能读的,否则会抛出相应的异常 NonWritableChannelException 和 NonReadableChannelException。而且 Buffer 也存在着是否只读的属性。

    前面的代码在这里只是说明用 NIO 读写文件应如何处理,并不是说比起用旧 IO 流式的写法效率就更高了。NIO 的高效率只会体现在有些时候,并非任何时候都优于旧 IO,那是块操作和字节操作的区别,用 NIO 时要小心内存。伸手就能摘到的梨用不着搬个凳子,何况旧 IO 实现起来还更简洁些呢!

    展开全文
  • 在JDK5之后,原始IO系统底层用NIO进行了优化,这可以通过sun公布的源码中找到,但是,NIO系统性还是比IO强。 3. 在稍微研究了IO源码以及部分sun源码,我觉得IO系统的性能瓶颈主要是由于原始的IO架构因素导致。原始...

    1. NIO采用更接近操作系统执行IO的方式:通道和缓存器;顾名思义,数据源的数据由缓存器通过通道进行传输。 2. 在JDK5之后,原始IO系统底层用NIO进行了优化,这可以通过sun公布的源码中找到,但是,NIO系统性还是比IO强。 3. 在稍微研究了IO源码以及部分sun源码,我觉得IO系统的性能瓶颈主要是由于原始的IO架构因素导致。原始的IO系统使用适配器模式,在JDK开发之初貌似是一个很不错的想法,但随着适配器嵌套的越来越多,IO的使用不但让人很烦,而且会影响性能,因为动态实现肯定是要降低性能的。 4. 为了能够尽量准确的验证我的想法,在IO部分的代码也是显示的用缓冲器进行读写。 5. 本地测试:50M文件:IO耗时1031ms,NIO耗时640ms;500M文件:IO耗时18900ms,NIO耗时13500ms。它们的时间差并不会因为文件大小的改变而产生剧烈变化,这说明不管是NIO还是IO在底层处理数据流应该是相似的,导致IO性能约束的是它原始的适配器模型的架构。 主干部分代码:

    1.IO系统

    5f44669d9023f819b9cfa4031178418d.png

    2.NIO系统

    5f44669d9023f819b9cfa4031178418d.png

    由最代码官方编辑于2015-10-15 9:40:51

    展开全文
  • 最近突然用nio来做些东西。nio的好处我来说一下:第一,读写都是基于块的,效率高。第二,通过引入selector,简化了网络编程模型,异步非阻塞。既然有这么多好处,那就写个NIO TCP网络聊天室来练练手吧。因为没有写...
  • Javanio

    2011-02-15 10:52:10
    Java NIO API所在位置:[url]... 1.java New IO的简称。 ... 2.Java NIO非堵塞应用通常适用在I/O读写等方面,...
  • 我们原有 IO 读写文件应该不会陌生了,顺带回顾一下,大致两种: ...2. 包装成 Reader/Writer 可以直接读写字符串,进一步包装到 BufferedReader/BufferedWriter 就可以按行读写了。readLine(...
  • Java Nio

    2014-07-17 16:01:00
    (1)NIO a)Nio之所以比旧的io速度快是因为,nio使用的结构更...(2)如何操作nio读写数据 Nio读写方式可以想象成:数据源和数据目的地是煤矿与煤场,通道想象成告诉公路,缓冲器是卡车,nio中的FileChannel是装卸煤的...
  • 在JDK5之后,原始IO系统底层用NIO进行了优化,这可以通过sun公布的源码中找到,但是,NIO系统性还是比IO强。 3. 在稍微研究了IO源码以及部分sun源码,我觉得IO系统的性能瓶颈主要是由于原始的IO架构因素导致。原始...
  • BIO:JDK1.4以前的都是BIO,阻塞IO。阻塞到我们的读写方法。BIO,如果有一台服务器,能承受简单的客户端请求,那么使用io和net中的同步、阻塞式API应该是可以实现了。但是为了一个用户的请求而单独启动一个线程,...
  • 1.阻塞与非阻塞 (1)传统的 IO 流都是阻塞式的。也就是说,当一个线程...(2)Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时,若没有数 据可用时,该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时 间
  • Java NIO读书笔记2

    2016-02-01 23:18:00
     Selector(选择器)是Java NIO中能够检测一到多个NIO通道,并能够知晓通道是否为诸如读写事件做好准备的组件。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接。 (1) 为什么使用Selector?  仅...
  • java.nio的学习笔记

    2011-09-22 11:28:04
    1.背景:java.nio相对于java.io中的一些缺点,比如block服务,传送效率,提供了一些新的特点比如多线程的存取安全性、提供缓存buffered、字符集编码解决...2.本质上channel和buffer来实现数据的读写。buffer是I/O...
  • 尝试多种方法读取属性文件。 测试打印系统属性; 测试读取、写入用户属性文件; 测试读取类库中的属性文件。 2. 示范代码 package com.clzhang.sample.io; import java.io.*; import java.util.*;...
  • java NIO ByteBuffer 学习

    2018-06-20 15:15:25
    java NIO ByteBuffer 学习 ByteBuffer看过很多资料。看完很久没有便忘记了,今天遇到了需要ByteBuffer的场景,就需要复习,于是便写点博客或者程序加深印象,下次直接使用不再需要复习资料。 ByteBuffer介绍 ...
  • Java 多线程NIO

    千次阅读 2018-07-04 21:12:12
    IO模型 1. 阻塞IO如果数据没有...3. 多路复用IO NIO多路复用IO,会有一个线程不断地去轮询多个socket的状态,当socket有读写事件的时候才会调用IO读写操作。一个线程管理多个socket,是通过selector.select(...
  • Java多线程NIO学习

    2019-05-13 11:52:01
    原文链接:juejin.im/post/5cb2f8… ...多路复用IO NIO 多路复用IO,会有一个线程不断地去轮询多个socket的状态,当socket有读写事件的时候才会调用IO读写操作。 一个线程管理多个socket,是通过...
  • javaNIO笔记一

    2014-02-11 15:45:53
    一,Buffer读写数据时,一般分为四个步骤:  (1)写入数据  (2)调用buffer.flip()方法  (3)读取数据  (4)调用buffer.clear()或buffer.compact()方法  注:buffer.clear()与buffer.compact()方法的...
  • 很多的小伙伴,也被nio这个名词搞晕了,一会儿javanio 不叫 非阻塞io,一会儿java nio 又是非阻塞io,到底是啥呢? 很多的小伙伴,被异步和非阻塞搞晕了。都非阻塞了,难道不是异步的吗?这这,好难呀。 此文,...
  • RandomAccessFile是用来访问那些保存数据记录的文件的,你就可以seek( )方法来访问记录,并进行读写了。这些记录的大小不必相同;但是其大小和位置必须是可知的。但是该类仅限于操作文件。RandomAccessFile不属于...
  • Java IO/NIO【总结】

    2021-04-10 14:26:34
    一、Java IO/NIO: 1、阻塞IO模型: 最传统的一种 IO 模型,即在读写数据过程中会发生阻塞现象。当用户线程发出 IO 请求之后,内核会去查看数据是否就绪,如果没有就绪就会等待数据就绪,而用户线程就会处于阻塞...
  • 1.首先我们先说一说什么是NIONIO是JDK1.4 New IO JDK1.7 在 nio包下又增加了一些API... NIO 将以更加高效的方式进行文件的读写 2.通道和缓冲区 Java NIO 系统的核心在于:通道 (Channel) 和缓冲区(Buffer) 。...
  • NIO/AIO

    2017-04-22 19:58:00
    1 NIO NEW IO 的简称,新的java I/O标准,jdk1.4纳入,有以下特点: ... (2)为各个基本类型类型提供缓存支持(buffer),最常用的是byteBuffer,字节读写数据。 (3)使用通道channel,作为io抽象。旧i...
  • NIO和AIO的了解

    2020-05-12 15:19:28
    java IO模型 BIO: JDK1.4以前的都是BIO 堵塞IO 堵塞到我们的读写方法,堵塞到线程来提供性能,对于线程的开销本来就是浪费 NIO:JDK1.4 linux 多路复用技术(select 模式) ...AIO:JDK1.7(NIO2) 才是实现实现真正的aio;
  • NIO缺点: NIO服务器端是在一个线程下运行,当有多个请求时,将会排队操作,但进行大并发量大数据量读写时,会导致其他请求无法处理,因此考虑将NIO读写单独线程处理。 1、NIO 基础 ...2NIO多线程实现 ...

空空如也

空空如也

1 2 3 4 5
收藏数 92
精华内容 36
关键字:

java用nio2读写

java 订阅