本文目录一览：
- 1、如何用JAVA NIO读取文件的指定内容？
- 2、java nio读取文件是全部写入内存吗
- 3、java nio bytebuffer文件读写问题
- 4、利用java.nio的FileChannel能够实现按行读取文件吗？（解决了）
- 5、io和nio的文件读取方式的不同
如何用JAVA NIO读取文件的指定内容？
为什么要用NIO？我理解的NIO是管道对管道的时候才用的。既然你的文件里面开头就是这个，为什么不自己读了，拿正则搞一下就出来了呀
补充------
package com.huawei.baidu;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest {
public static void main(String[] args) {
String regex="(width=)(\\d+);";
String testString="width=123;";
Pattern reg = Pattern.compile(regex);
Matcher regexMatcher = reg.matcher(testString);
if(regexMatcher.find())
{
System.out.println(regexMatcher.group(2));
}
}
}
java nio读取文件是全部写入内存吗
NIO采用更接近操作系统执行IO的方式：通道和缓存器；顾名思义，数据源的数据由缓存器通过通道进行传输。并不是全写入内存。
java nio bytebuffer文件读写问题
JDK1.4以后就提供java.nio的包，nio主要提供字节与字符的映射、内存映射文件和文件加锁机制
其中内存映射文件在读取大文件时可能会用上，因为内存映射不是直接把文件加载到JVM内存空间
而是借用操作系统对文件的读取，这经历了由当前Java态进入到操作系统内核态，再由操作系统读取文件，
并返回数据到当前Java态的过程。由Java态进入操作系统内核态离不开nio包中两个重要的类
FileChannel 和 ByteBuffer。FileChannel表示文件通道，可以从FileInputStream、FileOutputStream
以及RandomAccessFile对象获取文件通道，你可以从文件通道直接读取文件，也可以使用“内存映射”
即使用通道，将文件内存映射到ByteBuffer，可以映射一部分内容，也可以映射全部内容，使用内存映射
能大幅提高我们操作大文件的速度
FileChannel 和 ByteBuffer文件读取
[java] view plain copy
package nio;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
/**
*
* Channel类似与流,数据可以从Channel读取到Buffer,也可以从Buffer写入到Channel
* 但通道和流还是有区别,比如流只能是单向读或写,而通道可以异步读写
*
* @author yli
*/
public class FileChannelTest {
利用java.nio的FileChannel能够实现按行读取文件吗？（解决了）
利用java.nio的FileChannel能够实现按行读取文件：
具体思路是：设置两个缓冲区，一大一小，大的缓冲区为每次读取的量，小的缓冲区存放每行的数据（确保大小可存放文本中最长的那行）。读取的时候判断是不是换行符13，是的话则返回一行数据，不是的话继续读取，直到读完文件。-用nio读取文件
实现方法：
FileChannel fc=raf.getChannel();
//一次读取文件，读取的字节缓存数
ByteBuffer fbb=ByteBuffer.allocate(1024*5);
fc.read(fbb);
fbb.flip();
//每行缓存的字节 根据你的实际需求
ByteBuffer bb=ByteBuffer.allocate(500);
//判断是否读完文件
public boolean hasNext() throws IOException {
if(EOF)return false;
if(fbb.position()==fbb.limit()){//判断当前位置是否到了缓冲区的限制
if(readByte()==0) return false;
}
while(true){
if(fbb.position()==fbb.limit()){
if(readByte()==0) break;
}
byte a=fbb.get();
if(a==13){
if(fbb.position()==fbb.limit()){
if(readByte()==0) break;
}
return true;
}else{
if (bb.position() bb.limit()) {
bb.put(a);
}else {
if(readByte()==0) break;
}
}
}
return true;
}
io和nio的文件读取方式的不同
io,也称old io,读取文件主要通过流，从磁盘上一个一个字符的读，效率比较低下。
nio，在对文件操作下改进了方式，通过块读取，一整块一整块的读取，所以读取出来的不会是一个字符，而是一个块，把这些数据放到内存缓冲区内。在进行操作。通过块的读取来提高速度。（块操作，fileChannel)-用nio读取文件
内存映射，MappedByteBuffer,这个主要是通过内存映射，即利用虚拟内存（把文件某一部分当成内存），直接操作文件，对于一些要在内存中大块操作的文件，比如1G的文件
你要在内存中操作200M的部分，，把200M读到物理内存是比较耗内存和CPU的，不如直接把那部分文件虚拟成内存直接操作。
下面是对用以上三个文式对一个300M的文件进行读取，并写入另一个文件的测试:
1. inputstream CPU5.6% 内存2.6M costTime:4.039S 使用缓冲区byte:4kb-用nio读取文件
2. filechannel CPU1.3% 内存2.6M costTime:3.359S 使用缓冲区byte:0(transferTo方式）-用nio读取文件
3. MappedByteBuffer CPU6.9% 内存2.4M costTime:6.966S 内存映射：300M
可见对大文件块读取是最好的;如果要直接操作文件的很大的一部分的内容，则比较适合MappedByteBuffer ;如读取很小的内容，比如8B的内容，inputStream可能是最好的。
代码如下，选几个文件自已试下。使用jdk自带JConsole进行观察。
public class Test {
public static void main(String[] args)throws Exception{
File ff=new File("F:/workspace/pureMQ/src/mq/pure/file/cc.rar");
File[] f=new File[7];
File[] f_write=new File[7];
Thread.sleep(15000);
for(int i=0;i7;i++){
f[i]=new File("F:/workspace/pureMQ/src/mq/pure/file/1"+(i+1)+".jpg");
}
for(int i=0;i7;i++){
f_write[i]=new File("F:/workspace/pureMQ/src/mq/pure/file/"+i+".jpg");
if(!f_write[i].exists()){
f_write[i].createNewFile();
}
}
f[0]=ff;
long begin=System.currentTimeMillis();
int choice=1;
for(int i=0;i7;i++){
switch(choice){
case 1:
System.out.println("1");
InputStream ips=new FileInputStream(f[i]);
OutputStream ops=new FileOutputStream(f_write[i]);
byte[] b=new byte[4096];
int index;
while((index=ips.read(b))!=-1){
ops.write(b);
}
if(ips!=null){
ips.close();
}
if(ops!=null){
ops.close();
}
break;
case 2:
System.out.println("2");
RandomAccessFile raf=new RandomAccessFile(f[i],"r");
RandomAccessFile raf_write=new RandomAccessFile(f_write[i],"rw");
FileChannel fc=raf.getChannel();
FileChannel fc_write=raf_write.getChannel();
fc.transferTo(0, fc.size(), fc_write);
fc.close();
fc_write.close();
raf.close();
raf_write.close();
break;
case 3:
System.out.println("3");
RandomAccessFile raf2=new RandomAccessFile(f[i],"r");
RandomAccessFile raf2_write=new RandomAccessFile(f_write[i],"rwd");
FileChannel fc2=raf2.getChannel();
FileChannel fc2_write=raf2_write.getChannel();
MappedByteBuffer mbb=fc2_write.map(MapMode.READ_WRITE, 0, fc2.size());
ByteBuffer bb=ByteBuffer.allocate(4096);
while(fc2.read(bb)!=-1){
bb.flip();
mbb.put(bb);
bb.compact();
}
mbb.force();
fc2.close();
fc2_write.close();
raf2.close();
raf2_write.close();
break;
default:
break;
}
}
long end=System.currentTimeMillis();
System.out.println("all time cost:"+ (end-begin));
}
}
