某某茶叶有限公司欢迎您!
金沙棋牌在线 > 金沙棋牌在线 > Java I/O操作

Java I/O操作

时间:2019-12-29 06:38

Java I/O

I/O,即 Input/Output(输入/输出) 的简称。就 I/O 而言,概念上有 5 种模型:blocking I/O,nonblocking I/O,I/O multiplexing (select and poll),signal driven I/O (SIGIO),asynchronous I/O (the POSIX aio_functions)。不同的操作系统对上述模型支持不同,UNIX 支持 IO 多路复用。不同系统叫法不同,freebsd 里面叫 kqueue,Linux 叫 epoll。而 Windows2000 的时候就诞生了 IOCP 用以支持 asynchronous I/O。

Java 是一种跨平台语言,为了支持异步 I/O,诞生了 NIO,Java1.4 引入的 NIO1.0 是基于 I/O 复用的,它在各个平台上会选择不同的复用方式。Linux 用的 epoll,BSD 上用 kqueue,Windows 上是重叠 I/O。

Java I/O 的相关方法如下所述:

  • 同步并阻塞 (I/O 方法):服务器实现模式为一个连接启动一个线程,每个线程亲自处理 I/O 并且一直等待 I/O 直到完成,即客户端有连接请求时服务器端就需要启动一个线程进行处理。但是如果这个连接不做任何事情就会造成不必要的线程开销,当然可以通过线程池机制改善这个缺点。I/O 的局限是它是面向流的、阻塞式的、串行的一个过程。对每一个客户端的 Socket 连接 I/O 都需要一个线程来处理,而且在此期间,这个线程一直被占用,直到 Socket 关闭。在这期间,TCP 的连接、数据的读取、数据的返回都是被阻塞的。也就是说这期间大量浪费了 CPU 的时间片和线程占用的内存资源。此外,每建立一个 Socket 连接时,同时创建一个新线程对该 Socket 进行单独通信 (采用阻塞的方式通信)。这种方式具有很快的响应速度,并且控制起来也很简单。在连接数较少的时候非常有效,但是如果对每一个连接都产生一个线程无疑是对系统资源的一种浪费,如果连接数较多将会出现资源不足的情况;
  • 同步非阻塞 (NIO 方法):服务器实现模式为一个请求启动一个线程,每个线程亲自处理 I/O,但是另外的线程轮询检查是否 I/O 准备完毕,不必等待 I/O 完成,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。NIO 则是面向缓冲区,非阻塞式的,基于选择器的,用一个线程来轮询监控多个数据传输通道,哪个通道准备好了 (即有一组可以处理的数据) 就处理哪个通道。服务器端保存一个 Socket 连接列表,然后对这个列表进行轮询,如果发现某个 Socket 端口上有数据可读时,则调用该 Socket 连接的相应读操作;如果发现某个 Socket 端口上有数据可写时,则调用该 Socket 连接的相应写操作;如果某个端口的 Socket 连接已经中断,则调用相应的析构方法关闭该端口。这样能充分利用服务器资源,效率得到大幅度提高;
  • 异步非阻塞 (AIO 方法,JDK7 发布):服务器实现模式为一个有效请求启动一个线程,客户端的 I/O 请求都是由操作系统先完成了再通知服务器应用去启动线程进行处理,每个线程不必亲自处理 I/O,而是委派操作系统来处理,并且也不需要等待 I/O 完成,如果完成了操作系统会另行通知的。该模式采用了 Linux 的 epoll 模型。

在连接数不多的情况下,传统 I/O 模式编写较为容易,使用上也较为简单。但是随着连接数的不断增多,传统 I/O 处理每个连接都需要消耗一个线程,而程序的效率,当线程数不多时是随着线程数的增加而增加,但是到一定的数量之后,是随着线程数的增加而减少的。所以传统阻塞式 I/O 的瓶颈在于不能处理过多的连接。非阻塞式 I/O 出现的目的就是为了解决这个瓶颈。非阻塞 IO 处理连接的线程数和连接数没有联系,例如系统处理 10000 个连接,非阻塞 I/O 不需要启动 10000 个线程,你可以用 1000 个,也可以用 2000 个线程来处理。因为非阻塞 IO 处理连接是异步的,当某个连接发送请求到服务器,服务器把这个连接请求当作一个请求“事件”,并把这个“事件”分配给相应的函数处理。我们可以把这个处理函数放到线程中去执行,执行完就把线程归还,这样一个线程就可以异步的处理多个事件。而阻塞式 I/O 的线程的大部分时间都被浪费在等待请求上了。

一、概述

  Java的IO支持通过java.io包下的类和接口来完成,在java.io包下主要有包括输入、输出两种IO流,每种输入输出流又可分为字节流和字符流两大类。从JDK1.4以后,Java在java.nio包下提供了系列的全新API,通过java.nio,程序可以更高效的进行输入、输出操作。

  • 主要就是对各种输入输出流使用的总结
  • 字节流使用情况:对流中的数据以字节为单位进行读取写入操作,不关心内容
  • 字符流使用情况:对流中的数据以字符为单位进行读取和写入

Java NIO

Java.nio 包是 Java 在 1.4 版本之后新增加的包,专门用来提高 I/O 操作的效率。

表 1 所示是 I/O 与 NIO 之间的对比内容。

二、Java I/O类和接口 

  1. #### File类

  File类直接处理文件和文件系统,它没有指定如何获取信息或将信息保存到文件中,只描述了文件本身的属性。File对象用于获得或者操作与磁盘文件相关联的信息,如存取权限、时间、日期和目录路径等,并且还可以浏览子目录的层次结构。

下面的构造函数可用来创建File对象:

构造方法摘要

File(File parent, String child)
          根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname)
          通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child)
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri)
          通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

  File类定义了许多可以得到File对象标准属性的方法

public class Demo
{
    public static void main(String[] args)
    {
        File f=new File("D://hello.java");
        System.out.println(f.getParent());//返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 null
        System.out.println(f.getName());//返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.exists());//测试此抽象路径名表示的文件或目录是否存在
        System.out.println(f.getAbsoluteFile());// 返回此抽象路径名的绝对路径名形式
        System.out.println(f.getAbsolutePath());//返回此抽象路径名的规范路径名字符串
        System.out.println(f.getPath());//将此抽象路径名转换为一个路径名字符串
        System.out.println(f.hashCode());//计算此抽象路径名的哈希码
        System.out.println(f.length());//返回由此抽象路径名表示的文件的长度
        System.out.println(f.list());// 返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录
        System.out.println(f.mkdir());//创建此抽象路径名指定的目录
    }
}

字节流

表 1. I/O VS NIO
I/O NIO
面向流 面向缓冲
阻塞 IO 非阻塞 IO
选择器

NIO 是基于块 (Block) 的,它以块为基本单位处理数据。在 NIO 中,最为重要的两个组件是缓冲 Buffer 和通道 Channel。缓冲是一块连续的内存块,是 NIO 读写数据的中转地。通道标识缓冲数据的源头或者目的地,它用于向缓冲读取或者写入数据,是访问缓冲的接口。Channel 是一个双向通道,即可读,也可写。Stream 是单向的。应用程序不能直接对 Channel 进行读写操作,而必须通过 Buffer 来进行,即 Channel 是通过 Buffer 来读写数据的。

使用 Buffer 读写数据一般遵循以下四个步骤:

  1. 写入数据到 Buffer;
  2. 调用 flip() 方法;
  3. 从 Buffer 中读取数据;
  4. 调用 clear() 方法或者 compact() 方法。

当向 Buffer 写入数据时,Buffer 会记录下写了多少数据。一旦要读取数据,需要通过 flip() 方法将 Buffer 从写模式切换到读模式。在读模式下,可以读取之前写入到 Buffer 的所有数据。

一旦读完了所有的数据,就需要清空缓冲区,让它可以再次被写入。有两种方式能清空缓冲区:调用 clear() 或 compact() 方法。clear() 方法会清空整个缓冲区。compact() 方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处,新写入的数据将放到缓冲区未读数据的后面。

Buffer 有多种类型,不同的 Buffer 提供不同的方式操作 Buffer 中的数据。

  2. 流类

  Java中把不同的输入输出源抽象画为“流”,通过流的方式允许?Java程序使用相同的方式来访问不同的输入输出源。

  字节流类:提供了处理针对字节的IO的丰富环境,顶部类是InputStream和OutputStream,它们均是抽象类。

  字符流类:字节流类不能处理Unicode字符,字符流类操作的数据单元为字符,,顶部类是Reader和Writer。

  字节流类和字符流类的功能基本一样,只是操作的数据单元不同,其中InputStream和Reader都是将数据抽象为一根水管,程序可以通过read()方法每次抽取一个“水滴”,也可以通过read(char[] cbuf)方法来读取多个“水滴”,程序通过read()方法返回-1来判断是否到了输入流的结束点。

  eg.读取文件,统计文件字符数:

public class FileDemo
{
    public static void main(String[] args)
    {
        int b=0;
        try
        {
            FileInputStream in=null;
            in =new FileInputStream("D:\a.txt");
            long num=0;
            while((b=in.read())!=-1)
            {
                System.out.print((char)b);
                num++;
            }
            in.close();    
            System.out.println(num);
        } 
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }

    }
}

  FileInputStream类创建一个InputStream,可以用来从文件中读取文件。

  eg.将一个文件内容拷贝至另一个文件:

public class FileOutStream
{
    public static void main(String[] args)
    {
        int b=0;
        try
        {
            FileInputStream in =new FileInputStream("D:\Eclipse\workSpace\day_041602\src\day_041602\TestMain.java");
            FileOutputStream out=new FileOutputStream("D:\hello.java");
            while((b=in.read())!=-1)
            {
                out.write(b);
            }
            in.close();
            out.close();
            System.out.println("执行完成");
        } 
        catch (FileNotFoundException e)
        {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (IOException e)
        {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

  BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter称为缓冲流,它们通过缓冲输入输出来提高性能。

  eg.在hello.java文本中输入100个随机数,并在屏幕上显示:

public class BufferWriterDemo
{
    public static void main(String[] args)
    {
        try
        {
            String s;
            BufferedWriter bw=new BufferedWriter(new FileWriter("D:\hello.java"));
            BufferedReader br=new BufferedReader(new FileReader("D:\hello.java"));
            for(int i=0;i<100;i++)
            {
                s=String.valueOf(Math.random());  //产生随机数
                bw.write(s);//写入hello.java文件中
                bw.newLine();//写入一个换行符
            }
            bw.flush();//刷新缓冲
            while((s=br.readLine()) != null)//读取一个文本行
                {
                        System.out.println(s);
                }
            bw.close();
            br.close();
        } 
        catch (IOException e)
        {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

字节输入流 InputStream

InputStream 抽象类

---- FileInputStream
----------BufferedInputStream
----------DataInputStream

---- ByteArrayInputStream
---- ObjectInputStream

图 1 Buffer 接口层次图

图片 1

Buffer 写数据有两种情况:

  1. 从 Channel 写到 Buffer,如例子中 Channel 从文件中读取数据,写到 Channel;
  2. 直接调用 put 方法,往里面写数据。

从 Buffer 中读取数据有两种方式:

  1. 从 Buffer 读取数据到 Channel;
  2. 使用 get() 方法从 Buffer 中读取数据。

Buffer 的 rewin 方法将 position 设回 0,所以你可以重读 Buffer 中的所有数据。limit 保持不变,仍然表示能从 Buffer 中读取多少个元素(byte、char 等)。

clear() 和 compact() 方法

一旦读完 Buffer 中的数据,需要让 Buffer 准备好再次被写入。可以通过 clear() 或 compact() 方法来完成。

如果调用的是 clear() 方法,position 将被设回 0,limit 被设置成 capacity 的值。换句话说,Buffer 被清空了。Buffer 中的数据并未清除,只是这些标记告诉我们可以从哪里开始往 Buffer 里写数据。

如果 Buffer 中有一些未读的数据,调用 clear() 方法,数据将“被遗忘”,意味着不再有任何标记会告诉你哪些数据被读过,哪些还没有。如果 Buffer 中仍有未读的数据,且后续还需要这些数据,但是此时想要先写些数据,那么使用 compact() 方法。compact() 方法将所有未读的数据拷贝到 Buffer 起始处。然后将 position 设到最后一个未读元素正后面。limit 属性依然像 clear() 方法一样,设置成 capacity。现在 Buffer 准备好写数据了,但是不会覆盖未读的数据。

Buffer 参数

Buffer 有 3 个重要的参数:位置 (position)、容量 (capacity) 和上限 (limit)。

capacity 是指 Buffer 的大小,在 Buffer 建立的时候已经确定。

limit 当 Buffer 处于写模式,指还可以写入多少数据;处于读模式,指还有多少数据可以读。

position 当 Buffer 处于写模式,指下一个写数据的位置;处于读模式,当前将要读取的数据的位置。每读写一个数据,position+1,也就是 limit 和 position 在 Buffer 的读/写时的含义不一样。当调用 Buffer 的 flip 方法,由写模式变为读模式时,limit(读)=position(写),position(读) =0。

散射&聚集

NIO 提供了处理结构化数据的方法,称之为散射 (Scattering) 和聚集 (Gathering)。散射是指将数据读入一组 Buffer 中,而不仅仅是一个。聚集与之相反,指将数据写入一组 Buffer 中。散射和聚集的基本使用方法和对单个 Buffer 操作时的使用方法相当类似。在散射读取中,通道依次填充每个缓冲区。填满一个缓冲区后,它就开始填充下一个,在某种意义上,缓冲区数组就像一个大缓冲区。在已知文件具体结构的情况下,可以构造若干个符合文件结构的 Buffer,使得各个 Buffer 的大小恰好符合文件各段结构的大小。此时,通过散射读的方式可以一次将内容装配到各个对应的 Buffer 中,从而简化操作。如果需要创建指定格式的文件,只要先构造好大小合适的 Buffer 对象,使用聚集写的方式,便可以很快地创建出文件。清单 1 以 FileChannel 为例,展示如何使用散射和聚集读写结构化文件。

 三、NIO

FileInputStream

FileInputStream(File file);

FileInputStream 对文件进行读取的流,构造方法的参数为一个 File 对象,或者 File 的路径 ,不能使用 InputStream 对象来构造 FileInputStream

主要方法:

int read(); 
int read(byte[]);
int read(bytep[],int,int) 

这几个重载的读取方法,返回的都是一个 int 值

第一个方法每次读一个字节,返回值就是读取到的字节,如果读不到时返回 -1

后面的两个方法也是每次读一个字节,但是会把读到的字节存到 byte 数组中,返回值为读取到的字节数,如果读不到时返回 -1

清单 1. 使用散射和聚集读写结构化文件
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOScatteringandGathering {
 public void createFiles(String TPATH){
 try {
 ByteBuffer bookBuf = ByteBuffer.wrap("java 性能优化技巧".getBytes("utf-8"));
ByteBuffer autBuf = ByteBuffer.wrap("test".getBytes("utf-8"));
int booklen = bookBuf.limit();
int autlen = autBuf.limit();
ByteBuffer[] bufs = new ByteBuffer[]{bookBuf,autBuf};
File file = new File(TPATH);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
FileOutputStream fos = new FileOutputStream(file);
FileChannel fc = fos.getChannel();
fc.write(bufs);
fos.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

ByteBuffer b1 = ByteBuffer.allocate(booklen);
ByteBuffer b2 = ByteBuffer.allocate(autlen);
ByteBuffer[] bufs1 = new ByteBuffer[]{b1,b2};
File file1 = new File(TPATH);
try {
FileInputStream fis = new FileInputStream(file);
FileChannel fc = fis.getChannel();
fc.read(bufs1);
String bookname = new String(bufs1[0].array(),"utf-8");
String autname = new String(bufs1[1].array(),"utf-8");
System.out.println(bookname+" "+autname);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

 }

 public static void main(String[] args){
 NIOScatteringandGathering nio = new NIOScatteringandGathering();
 nio.createFiles("C://1.TXT");
 }
}

输出如下清单 2 所示。

  1.概述

  NIO使用内存映射的方式处理输入输出,将文件或文件的一段区域映射到内存中,这样就可以像访问内存一样来访问文件了。

  相关的包有:java.nio.channels包:主要包含Channel和Selector相关的类,java.nio.charset包:主要包含和字符集相关的类

  NIO系基于两个基本的元素:缓冲和通道。缓冲区容纳数据,通道代表队I/O设备的开放式连接。一般而言使用NIO系统,需要获得到I?O设备的一个通道和容纳数据的一个缓冲区,然后可以对缓冲区进行操作,随意输入和输出数据。除此之外,NIO还提供了用于将Unicode字符串映射成字节序列以及逆映射操作的Charset类,还有支持非阻塞式输入输出的Selector类。

BufferedInputStream
BufferedInputStream(InputStream inputStream); 

构造方法是一个 InputStream ,一般在使用流传递时会从别的地方得到一个 InputStream 对象,即可创建 BufferedInputStream 对象

BufferedInputStream 是 FileInputStream 的子类,是具有缓存功能的字节输入流

主要方法:

int read(); 
int read(byte[]);
int read(bytep[],int,int) 

如果 read 方法不使用参数时为一次读取一个字节,返回值为读取到的 byte 字节,读不到时返回 -1

后面两个方法会将读取到的数据缓存在一个 byte[] 字节数组中,只读满时或读取结束时返回,返回值表示读取到的字节数,读不到时返回 -1

清单 2. 运行结果
java 性能优化技巧 test

清单 3 所示代码对传统 I/O、基于 Byte 的 NIO、基于内存映射的 NIO 三种方式进行了性能上的对比,使用一个有 400 万数据的文件的读、写操作耗时作为评测依据。

  2.缓冲区

   缓冲(buffer)可以理解成一个容器,它的本质是一个数组,发送到Channel中的所有对象都必须首先放到buffer中,从channel中读取的数据也必须先读到buffer中。

   Buffer中有三个重要的参数:

    • capacity:表示该Buffer的最大存储容量
    • limit:第一个不应该被读出或写入的缓冲区位置索引
    • position:用于指明下一个可以被读出或写入的缓冲区位置索引

    除此之外还有一个可选的mark标记,该mark允许程序直接将position定位到mark处。位置如下所示:

  图片 2

    每放入一个数据,position向后移动一位,当Buffer装入数据结束后,调用flip方法,将limit设置为position所在的位置,将position设置为0,这样使得从Buffer中读数据总是从0开始。当Buffer输出数据结束后,Buffer调用 clear方法,它将position置为0,,置limit为capacity,这样为再次向Buffer中装入数据做好准备。Buffer还提供了put和get方法,用于向Buffer中放入数据和读取数据,既支持对单个数据的访问也支持对批量数据的访问。

  eg.

public class Test
{
    public static void main(String[] args)
    {
        CharBuffer m=CharBuffer.allocate(8);
        m.put('a');
        m.put('b');
        m.put('c');
        System.out.println("position:"+m.position());
        System.out.println("limit:"+m.limit());
        m.flip();
        System.out.println("第一个元素"+m.get());
        System.out.println("第二个元素"+m.get());
        System.out.println("position:"+m.position());
    }
}

   执行结果:

  图片 3

DataInputStream
DataInputStream(InputStream in);

DataInputStream 用来处理纯文本时使用,定义了对各种基本类型的写入操作,构造参数为一个 InputStream,要保证该 InputStream 流中的数据为二进制的

主要方法:

int read(byte[]);
int readInt();
double readDouble();
...
清单 3. I/O 的三种方式对比试验
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class NIOComparator {
 public void IOMethod(String TPATH){
 long start = System.currentTimeMillis();
 try {
DataOutputStream dos = new DataOutputStream(
 new BufferedOutputStream(new FileOutputStream(new File(TPATH))));
for(int i=0;i<4000000;i++){
dos.writeInt(i);//写入 4000000 个整数
}
if(dos!=null){
dos.close();
}
 } catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
 } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
 }
 long end = System.currentTimeMillis();
 System.out.println(end - start);
 start = System.currentTimeMillis();
 try {
DataInputStream dis = new DataInputStream(
 new BufferedInputStream(new FileInputStream(new File(TPATH))));
for(int i=0;i<4000000;i++){
dis.readInt();
}
if(dis!=null){
dis.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

 end = System.currentTimeMillis();
 System.out.println(end - start);
 }

 public void ByteMethod(String TPATH){
 long start = System.currentTimeMillis();
 try {
FileOutputStream fout = new FileOutputStream(new File(TPATH));
FileChannel fc = fout.getChannel();//得到文件通道
ByteBuffer byteBuffer = ByteBuffer.allocate(4000000*4);//分配 Buffer
for(int i=0;i<4000000;i++){
byteBuffer.put(int2byte(i));//将整数转为数组
}
byteBuffer.flip();//准备写
fc.write(byteBuffer);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 long end = System.currentTimeMillis();
 System.out.println(end - start);

 start = System.currentTimeMillis();
 FileInputStream fin;
try {
fin = new FileInputStream(new File(TPATH));
FileChannel fc = fin.getChannel();//取得文件通道
ByteBuffer byteBuffer = ByteBuffer.allocate(4000000*4);//分配 Buffer
fc.read(byteBuffer);//读取文件数据
fc.close();
byteBuffer.flip();//准备读取数据
while(byteBuffer.hasRemaining()){
byte2int(byteBuffer.get(),byteBuffer.get(),byteBuffer.get(),byteBuffer.get());//将 byte 转为整数
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 end = System.currentTimeMillis();
 System.out.println(end - start);
 }

 public void mapMethod(String TPATH){
 long start = System.currentTimeMillis();
 //将文件直接映射到内存的方法
 try {
FileChannel fc = new RandomAccessFile(TPATH,"rw").getChannel();
IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE, 0, 4000000*4).asIntBuffer();
for(int i=0;i<4000000;i++){
ib.put(i);
}
if(fc!=null){
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 long end = System.currentTimeMillis();
 System.out.println(end - start);

 start = System.currentTimeMillis();
 try {
FileChannel fc = new FileInputStream(TPATH).getChannel();
MappedByteBuffer lib = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
lib.asIntBuffer();
while(lib.hasRemaining()){
lib.get();
}
if(fc!=null){
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 end = System.currentTimeMillis();
 System.out.println(end - start);

 }

 public static byte[] int2byte(int res){
 byte[] targets = new byte[4];
 targets[3] = (byte)(res & 0xff);//最低位
 targets[2] = (byte)((res>>8)&0xff);//次低位
 targets[1] = (byte)((res>>16)&0xff);//次高位
 targets[0] = (byte)((res>>>24));//最高位,无符号右移
 return targets;
 }

 public static int byte2int(byte b1,byte b2,byte b3,byte b4){
 return ((b1 & 0xff)<<24)|((b2 & 0xff)<<16)|((b3 & 0xff)<<8)|(b4 & 0xff);
 }

 public static void main(String[] args){
 NIOComparator nio = new NIOComparator();
 nio.IOMethod("c://1.txt");
 nio.ByteMethod("c://2.txt");
 nio.ByteMethod("c://3.txt");
 }
}

清单 3 运行输出如清单 4 所示。

  3.通道

   Channel与传统的InputStream、OutputStream最大的区别在于它提供了一个map方法,通过该map方法可以直接将一块数据映射到内存中。

     Channel是一个接口,系统为该接口提供了FileChannel等实现类,所有的Channel都是通过传统节点InputStream、OutputSteam的getChannel方法来返回对应的Channel。

   Channel中最常见的三个方法是:map、read和write。其中map将Channel对应的部分或全部数据映射的ByteBuffer,read或write方法有一系列重载的形式用于读取数据。

  eg.将WelcomeServlet.java的内容复制到a.txt中去,并在控制台打印处内容。

public class FileChannelTest
{
    public static void main(String[] args)
    {
        FileChannel inChannel=null;
        FileChannel outChannel=null;
        FileChannel randomChannel=null;
        File f=new File("D://WelcomeServlet.java");
        try
        {
            FileInputStream fs=new FileInputStream(f);
            inChannel=fs.getChannel();

            MappedByteBuffer buffer=inChannel.map(FileChannel.MapMode.READ_ONLY,0, f.length());//将inChannel里的全部数据映射成ByteBuffer
            Charset charset=Charset.forName("GBK");
            outChannel=new FileOutputStream("D://a.txt").getChannel();

            outChannel.write(buffer);
            buffer.clear();

            CharsetDecoder decoder=charset.newDecoder();//创建解码器对象
            CharBuffer charBuffer=decoder.decode(buffer);//使用解码器将ByteBuffer转换为charBuffer
            System.out.println(charBuffer);     //获取对应字符串
        } 
        catch (FileNotFoundException e)
        {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } 
        catch (IOException e)
        {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
}

 

 

 

 

 

 

 

 

 

  

  

 

  

ByteArrayInputStream

ByteArrayInputStream(byte[]);
ByteArrayInputStream(byte[],int,int);

ByteArrayInputStream 构造方法的参数为将一个字节数组写入自己的缓冲区,缓冲区也是一个字节数组,并使用 read 方法先问提供接口。

主要方法:

int read(byte[]);
int read(byte[],int,int);

read 方法会将自己内部缓冲区的数组写入到参数中的数组中,返回值为读取到的字节的数量,读不到时返回 -1