标签:需要 OLE exce 访问 java虚拟机 relative body charset 多次
新IO和传统的IO有相同的目的,都是用于进行输入/输出功能,但新IO使用了不同的方式来处理处理输入/输出,新IO采用内存映射文件的方式来处理输入/输出,新IO将文件或文件的一段区域映射到内存中,这样就可以像访问内存一样来访问文件了(这种方式模拟了操作系统上的虚拟内存的概念),通过这种方式来进行输入/输出比传统的输入/输出要快得多。
下面示意图展示了Java新IO包和各种类之间的树关系:
Java中NIO相关的包如下:
java.nio包:主要提供了一些和Buffer相关的类。
java.nio.channels包:主要包括Channel和Selector相关的类。
java.nio.charset包:主要包含和字符集相关的类。
java.nio.channels.spi包:主要包含提供Channel服务的类。
java.nio.charset.spi包:主要包含提供字符集服务的相关类。
Channel(通道)和Buffer(缓冲)是新IO中的两个核心对象,Channel是对传统输入/输出系统中里的模拟,在新IO系统中所有数据都需要通过通道传输;Channel与传统的InputStream、OutputStream最大的区别在于它提供了一个map方法,通过该map方法可以直接将“一块数据”映射到内存中。如果说传统的输入/输出系统是面向流的处理,而新IO则是面向块的处理。
Buffer可以被理解成一个容器,它的本质是一个数组,发送到Channel中的所有对象都必须首先放到Buffer中,而从Channel中读取的数据也必须先读到Buffer中。此处的Buffer有点类似于前面我们介绍的“竹筒”,但该Buffer既可以像前面那样一次、一次去Channel中取水,也允许使用Channel直接将文件的某块数据映射成Buffer。
除了Channel和Buffer之外,新IO还提供了用于将UNICODE字符串映射成字节序列以及逆映射操作的Charset类,还提供了用于支持非阻塞式输入/输出的Selector类。
从内部结构上来看,Buffer就像一个数组,它可以保存多个类型相同的数据。Buffer是一个抽象类,其最常用的子类是ByteBuffer,它可以在底层字节数组上进行get/set操作,除了ByteBuffer之外,其他基本数据类型(boolean除外)都有相应的Buffer类:ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。
除了ByteBuffer之外,上面的Buffer都采用相同或相似的方法来管理数据,只是各自管理数据的类型不同而已。这些Buffer没有提供构造器,只提供如下方法来获取一个Buffer对象:
static XxxBuffer allocate(int capacity)
//allocate拨…(给); 划…(归); 分配…(给);
ByteBuffer和CharBuffer用得最多,其他Buffer子类用的较少。ByteBuffer类还有一个子类:MappedByteBuffer,它用于表示Channel将磁盘文件的部分或全部内容映射到内存中得到的结果,通常MappedByteBuffer对象由Channel的map()方法返回。
★容量(capacity):缓冲区的 容量(capacity) 表示该Buffer的最大数据容量,即最多可以存储多少数据。缓冲区的容量不可能为负值,在创建后也不能改变。
★界限(limit):第一个不应该被读出或者写入的缓冲区位置索引。也就是说,位于limit后的数据既不可被读,也不可被写。
★位置(position):用于指明下一个可以被读出的或者写入的缓冲区位置索引(类似于IO流中的记录指针)。当使用Buffer从Channel中读取数据时,position的值恰好等于已经读到了多少数据。当刚刚新建一个Buffer对象时,其position为0,如果从Channel中读取了2个数据到该Buffer中,则postion为2,指向Buffer中第三个(第一个位置的索引为0)位置。
除此之外,Buffer还支持一个可选的标记(mark,类似于传统IO流中的mark),Buffer允许直接将position定位到mark处,这些值满足的关系是:
0<=mark<=position<=limit<=capacity
如图显示了某个Buffer读入了一些数据后的示意图:
Buffer的主要作用就是装入数据,然后输出数据(其作用类似于输入输出流的水管),开始时Buffer的position为0,limit为capacity,程序通过put()方法像Buffer中放入一些数据(或则从Channel中取出一些数据),没放入一些数据,Buffr的position位置相应地向后移动一些位置。
Buffer装入数据的示意图:
当Buffer装入数据结束后,调用Buffer的flip()方法,该方法将limit设置为position所在位置,并将position设置为0,这使得Buffer的读写指针又移到开始的位置。也即是说,Buffer调用flip()方法之后,Buffer为输出数据做好了准备;
当Buffer输出数据结束后,Buffer调用clean()方法,clear()方法不是清空Buffer数据,它仅仅只是将position置为0,将limit置为capacity,这样再次向Buffer中装入数据做准备。
Buffer的基本常用方法:
(1)int capacity():返回Buffer的capacity大小。
(2)boolean hasRemaining():判断当前位置(position)和界限之间是否还具有元素可供处理。
(3)int limit():返回Buffer界限(limit)的位置。
(4)Buffer mark():设置Buffer的mark位置,它只能在0和position之间做mark。
(5)int position():返回position的值。
(6)Buffer position(int newPs):设置Buffer的position,并返回position被修改后的Buffer对象。
(7)int remianing():返回当前位置和界限之间元素个数。
(8)Buffer reset:将位置(position)转到mark所在位置。
(9)Buffer rewind():将位置position设置为0,取消设置的mark。
Buffer的所有子类还提供了两个重要的方法:put()、get()方法,用于向Buffer中放入数据和从Buffer中取出数据。支持单个数据访问,也支持毗连数据访问(以数组作为参数)。
当使用put()、get()方法访问Buffer中的数据时,分为相对和绝对两种:
(1)相对(Relative):从Buffer的当前position处开始读取或写入数据,然后将位置position的值按处理后的元素的个数增加。
(2)绝对(Absolute):直接根据索引向Buffer中读取或写入数据,使用绝对的方式访问Buffer里的数据时,并不会影响位置(position)的值。
package section9;
import java.nio.CharBuffer;
public class BufferTest
{
public static void main(String[] args)
{
//创建Buffer,准备装入数据
CharBuffer buff=CharBuffer.allocate(8);//①
System.out.println("Buffer的容量capacity:"+buff.capacity());//8
System.out.println("Buffer的界限(limit):"+buff.limit());//8
System.out.println("Buffer的位置(position):"+buff.position());//0
//放入元素
buff.put(‘a‘);
buff.put(‘b‘);
buff.put(‘c‘);//②
System.out.println("加入三个元素后,position="+buff.position());//3
//调用flip()方法,Buffer为输出数据准备阶段
buff.flip();//③
System.out.println("执行flip()方法后,limit="+buff.limit());//3
System.out.println("执行flip()方法后,position="+buff.position());//0
//取出第一个元素
System.out.println("第一个元素(position=0):"+buff.get());//④ 输出为‘a‘
System.out.println("取出第一个元素后,position="+buff.position());//1
//调用clear()方法,为下次装入数据做好准备
buff.clear();//⑤
System.out.println("执行clear()方法后,limit="+buff.limit());//8
System.out.println("执行clear()方法后,position="+buff.position());//0
System.out.println("执行clear()方法后,Buffer中的内容并没有被清除,第三个元素为"+buff.get(2));//c
System.out.println("执行绝对读取后,position="+buff.position());//0
}
}
下面分析整个程序运行过程:
1、调用CharBuffer的静态方法allocate()创建一个capacity为8的CharBuffer,此时capacity=8,position=0,limit=0,进入准备装入数据的阶段:
2、代码2处王Buffer中装入三个元素,放入元素后的CharBuffer效果图如下所示:
3、代码3处,调用Buffer的flip()方法,该方法将把limit设为position处,再把position设置为0:
当Buffer调用flip()方法之后,limit就就移动到原来的position所在的位置,这时相当于把Buffer中没有数据的存储空间"封印"起来,从而避免读取Buffer数据时读取到null值。
4、代码4处取出第一个元素,取出第一个元素后position向后移动一位,也就是position等于1.
5、代码5处,Buffer调用clear()放啊,将position设为0,将limit设为与capacity相同。执行clear()方法后的Buffer的示意图如下所示:
6、执行代码6处依然可以取出位置2的值,也就是字符‘c‘。代码6处根据索引来取值,属于绝对方式的get(),所以不会影响到position的位置。
通过allocate()只能创建普通Buffer,ByteBuffer还提供了一个allocateDirect()方法来创建直接Buffer,直接Buffer的创建成本比普通Buffer的创建成本高,但直接Buffer的读取效率更高。
直接Buffer只适用于生存期长的Buffer,而不适用于短期、一次性用完就丢弃的Buffer。且只有ByteBuffer才提供allocateDirect()方法,所以只能再ByteBuffer的级别上创建直接Buffer。如果希望使用其他类型,则应该将该Buffer转换为其他类型的Buffer。
直接Buffer的用法上和普通Buffer用法基本相同,没有太大区别
Channel类似于传统的流对象,但与传统的流不同的是,Channel有两个主要的区别:
1、Channel可以直接将指定文件的部分或全部映射成Buffer。
2、程序不能直接访问Channel中的数据,包括读取、写入都不行,Channel只能与Buffer进行交互。
也就是说,如果要从Channel中取得数据,必须先用Buffer从Channel中取出一些数据,然后让程序从Buffer中取出这些数据;如果要将程序中的数据写入Channel,一样先让程序将数据放入Buffer中,程序再将Buffer里的输入写入Channel中。
Channel是一个接口,位于java.nio.channels包下,系统为该接口提供了DatagramChannel、 FileChannel、Pipe.SinkChannel、Pipe.SourceChannel、SelectableChannel、ServerSocketChannel, SocketChannel等实现类,本节主要介绍FileChannel的用法,根据这些Channel的名字我们不难发现新IO里的Channel是按功能来划分的,例如Pipe.SinkChannel、Pipe.SourceChannel用于支持线程之间通信的管道Channel,而ServerSocketChannel、SocketChannel则是用于支持TCP网络通信的Channel。
所有Channel都不应该通过构造器来直接创建,而是通过传统节点InputStream、OutputStream的getChannel()方法返回对应的Channel,不同节点流获取的Channel不一样。例如FileInputStream、FileOutputStream的getChannel()返回的是FileChannel,而PipedInputStream、PipedOutputStream的getChannel()返回的是Pipe.SinkChannel、Pipe.SourceChannel。
1、map():用于将Channel对应的部分或全部数据映射成ByteBuffer;
方法签名->MappedByteBuffer map(FileChannel.MapMode mode,long position,long size),第一个参数执行映射时的模式,分别有只读、读写等模式;第二个、第三个参数用于控制将Channel的哪些数据映射成ByteBuffer.
2、read()和write():都有一系列的重载形式,这些方法用于从Buffer中读取数据或向Buffer中写入数据。
下面程序示范了直接将FileChannel的全部数映射成ByteBuffer的效果:
package section9;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
public class FileChannelTest
{
public static void main(String[] args)
{
File f=new File("src//section9//FileChannelTest.java");
System.out.println(f.length());//返回文件内容的长度:1045
try(
//创建FileInputStream,以该文件输入流创建FileChannel
var inChannel=new FileInputStream(f).getChannel();
//以文件输出流创建FileChannel,用于控制输出
var outChannel=new FileOutputStream("src//section9//a.txt").getChannel()
)
{
//将FileChannel里的全部数据全部映射成ByteBuffer
MappedByteBuffer buffer=inChannel.map(FileChannel.MapMode.READ_ONLY,0,f.length());//代码1
for(int i=0;i<20;i++)//每个转义字符转换占两个位置,一个字母占一个byte
{System.out.print((char)buffer.get());}
System.out.println("\n"+buffer.position());
buffer.position(0);
System.out.println(buffer.position());
//使用GBK的字符集创建解码器
Charset charset=Charset.forName("utf-8");
//直接将Buffer中的数据全部输出
outChannel.write(buffer);//代码2
//再次调用buffer中的clear()方法,复原limit、position
buffer.clear();
//创建解码器(CharsetDecoder)对象
CharsetDecoder decoder=charset.newDecoder();
//使用解码器将ByteBuffer转换成CharBuffer
CharBuffer charBuffer=decoder.decode(buffer);
//CharBuffer的toString方法可以获取对应的字符串
System.out.println(charBuffer);
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
}
}
2159
package section9;
i
20
0
package section9;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.CharBuffer;
...
上面分别使用了FileInputStream、FileOutputStream来获取Channel,虽然FileChannel既可以读也可以写入,但是FileInputSream获取的FileChannel只能读,而FileOutputStrem获取的FileChannel只能写/代码1处直接将Channel中的全部数据映射成ByteBuffer,然后代码2处直接将整个ByteBuffer的全部数据写入一个FileChannel中,这就完成了文件的复制。
程序后面为了将FileChannelTest.java文件中的内容全部打印出来,使用了Charset类和CharsetDecoder类将ByteBuffer全部转换成CharSetBuffer。后面会详细介绍。
在RandomAccessFile中也包含一个getChannel()方法,RandomAccessFile返回得FileChannel是只读还是读写,则取决于RandomAccessFile打开文件得模式,例如下面程序将会对a.txt文件得内容进行复制,最佳在该文件后面。
package section9;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class RandomAccessFileChannelTest
{
public static void main(String[] args)
throws IOException
{
var f=new File("src//section9//a.txt");
try(
//创建一个RandomAccessFile对象
var raf=new RandomAccessFile(f,"rw");
//获取RandomAccessFile对应得Channel
FileChannel randomChannel=raf.getChannel()
)
{
//将Channel中得所有数据全部映射成ByteBuffer
ByteBuffer buffer=randomChannel.map(FileChannel.MapMode.READ_ONLY,0,f.length());
//把Channel得记录指针移动到最后
randomChannel.position(f.length());
//将buffer中得所有数据全部是输出
randomChannel.write(buffer);
}
}
}
上面得程序将Channel得记录指针移动到Channel得最后,从而让程序指定ByteBuffer得数据追加到Channel得后面。每次运行运行上面得程序都会将a.txt文件得内容全部复制一遍,并将全部得内容追加到文件得后面。
如果习惯了传统IO的“用竹筒多次重复取水”的过程,或者担心Channel对应的文件过大,使用map()方法一次将所有文件内容全部映射到内存中引起性能下降,也可以使用Channel和Buffer传统的“用竹筒多次取水”的方式:
package section9;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
public class ReadFile
{
public static void main(String[] args)
throws IOException
{
try(
//创建文件输入流
var fis=new FileInputStream("src//section9//ReadFile.java");
//创建文件输出流
var fos=new FileOutputStream("src//section9//b.txt");
//创建一个FileChannel
var fcIn=fis.getChannel();
var fcOut=fos.getChannel()
)
{
//定义一个Buffer对象,用于重复取水
ByteBuffer buff=ByteBuffer.allocate(256);
//将FileChannel中的全部数据放入ByteBuffer中
while(fcIn.read(buff)!=-1)
{
//锁定Buffer的空白区域
buff.flip();//将limit移动带position处
//将buffer中的数据写入输出Channel中
fcOut.write(buff);
//将buffer初始化,为下一次读取数据做准备
buff.clear();
}
}
}
}
上面的程序将生成一个b.txt文件,复制了Read.java文件的内容。
下面程序改为打印出ReadFile.java文件的内容
package section9;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
public class ReadFile
{
public static void main(String[] args)
throws IOException
{
try(
//创建文件输入流
var fis=new FileInputStream("src//section9//ReadFile.java");
//创建文件输出流
var fos=new FileOutputStream("src//section9//b.txt");
//创建一个FileChannel
var fcIn=fis.getChannel();
var fcOut=fos.getChannel()
)
{
//定义一个Buffer对象,用于重复取水
ByteBuffer bbuff=ByteBuffer.allocate(256);
//将FileChannel中的全部数据放入ByteBuffer中
while(fcIn.read(bbuff)!=-1)
{
//锁定Buffer的空白区域
bbuff.flip();//将limit移动带position处
//创建Charser对象
Charset charset=Charset.forName("UTF-8");
//创建解码器对对象
CharsetDecoder decoder=charset.newDecoder();
//将ByteBuffer中的内容转码
CharBuffer cbuffer=decoder.decode(bbuff);
//打印数
System.out.print(cbuffer);
//将buffer中的数据写入输出Channel中
fcOut.write(bbuff);
// //将buffer中的数据写入输出Channel中—
// fcOut.write(bbuff);
//将buffer初始化,为下一次读取数据做准备
bbuff.clear();
}
}
}
}
上面代码虽然使用了FileChannel和Buffer来读取文件,但处理方式使用了InputStream、Byte[]来读取文件的方式几乎一样,都是采用"用竹筒多次重复取水"的方式。但Buffer的flip()和clear()两个方法,程序处理起来也比较方便。每次读写数据后调用flip()方法将没有数的区域封印起来,避免程序从Buffer中取出null值;数据取出后立即调用clear方法将Buffer的position取为0,为下一次读取数据做好准备。
通常而言,把明文的字符串序列转换成计算机理解的字节序列(二进制文件,普通人看不懂)成为编码,把字节序列转化成普通人能看懂的明文字符串称为解码。
计算机底层是没有文本文件、图片文件之分的,它只是忠诚地记录每个文件的二进制序列而已,当需要保存文本文件时,程序先把文件中的每个字符翻译成二进制序列;当需要读取文本文件时,程序必须把二进制序列转化为一个个的字符。
Java默认使用Unicode字符集,但很多操作系统并不采用Unicode字符集,那么从系统中读取数据到Java程序中时,就可能出现乱码问题。
JDK1.4提供了Charset处理字节序列和字符序列之间的转换关系,该类用于创建解码器和编码器,还提供Charset所支持字符集方法,Charset类是不可变。
Charset类提供了一个availableCharsets()静态方法来获取当前JDK所支持的所有字符集。所以程序可以使用以下程序来获取JDK所支持的全部字符集。
package section9;
import java.nio.charset.Charset;
import java.util.SortedMap;
public class CharsetTest
{
public static void main(String[] args)
{
//获取Java支持的全部字符集
SortedMap<String, Charset> map=Charset.availableCharsets();
for(var alias:map.keySet())
{
//输出字符集的别名和对应的Charset对象
System.out.println(alias+"--->"+map.get(alias));
}
}
}
Big5--->Big5
Big5-HKSCS--->Big5-HKSCS
CESU-8--->CESU-8
EUC-JP--->EUC-JP
EUC-KR--->EUC-KR
GB18030--->GB18030
GB2312--->GB2312
...
上面程序SortedMap<String, Charset> map=Charset.availableCharsets();获取了Java所支持的全部字符集,并用遍历的方式打印了所有字符集的别名(字符集的字符串名称)和Charset对象。从上面的程序可以看出每个字符集都有一个字符串名称,也成为字符串的别名。
对于中国程序员,有几个常用字符集:
字符集 | 介绍 |
---|---|
GBK | 简体中文字符集 |
BIG5 | 繁体字中文字符集 |
ISO-8859-1 | ISO拉丁字母表,也叫作ISO-LATIN-1 |
UTF-8 | 8位UCS转换格式 |
UTF-16BE | 16位UCS转换格式,Big-endian(最低地址存放高位字节)字节顺序 |
UTF-16LE | 16位UCS转换格式,Little-endian(最高地址存放低位字节)字节顺序 |
UTF-16 | 16位UCS转换格式,字节顺序由可选的字节顺序标记来标识 |
一旦知道了字符集别名后,程序就可以调用Charset的forName()方法来创建Charset对象,forName()方法的参数就是相应字符集的别名。例如下面代码:
Charset cs=Charset.forName("ISO-8859-1");
Charset csCn=Charset.forName("GBK");
拓展:java 7 新增了一个StandardCharsets类,该类里包含ISO-8859-1、UTF-8、UTF-16等常用变量,这些变量代表了最常用的字符集对应的Charset对象:
一旦获取了Charset对象后,就可以通过该对象的newDecoder()、newEncoder()这两个方法分别返回CharsetDecoder和CharsetEncoder对象,代表了CharSet的解码器和编码器。
调用CharsetDecoder的decode()就可以将ByteBuffer(字节序列)转换为CharBuffer(字符序列),调用CharsetEncoder的encode()就可以将CharBuffer(字符序列转换为ByteBuffer(字节序列)。
如下程序就使用了CharsetDecoder的decode()和CharsetEncoder的encode()完成ByteBuffer和CharBuffer之间的转换。
package section9;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
public class CharsetTransform
{
public static void main(String[] args) throws CharacterCodingException {
//创建简体中文所对应的Charset
Charset cn=Charset.forName("GBK");
//获取cn对象的解码器和编码器
CharsetEncoder cnEncoder=cn.newEncoder();
CharsetDecoder cnDecoder=cn.newDecoder();
//创建一个CharBuffer对象
CharBuffer cbuff= CharBuffer.allocate(8);
cbuff.put(‘孙‘);
cbuff.put(‘悟‘);
cbuff.put(‘空‘);
cbuff.flip();//将limit设置到position,position=0
System.out.println(cbuff);
System.out.println(cbuff.position());
//将CharBuffer中字符系列转化为字节序列
** ByteBuffer bbuff=cnEncoder.encode(cbuff);**
System.out.println(cbuff);//此时cbuff不存在了,也就输出为空
//循环输出ByteBuffer中的每个字节
for(var i=0;i<bbuff.capacity();i++)
{
System.out.println(bbuff.get()+" ");
}
bbuff.flip();
//将ByteBuffer的数据全部解码成字符序列
** System.out.println("\n"+cnDecoder.decode(bbuff));**
}
}
孙悟空
0
-53
-17
-50
-14
-65
-43
孙悟空
ByteBuffer bbuff=cnEncoder.encode(cbuff);
System.out.println("\n"+cnDecoder.decode(bbuff));
上面两行代码分别实现了将CharBuffer转换成ByteBuffer,将ByteBuffer转换成CharBuffer的功能。实际上Charset里也提供了如下三个方法:
CharBuffer decode(ByteBuffer bb):将ByteBuffer中字节序列转换成字符序列的的便捷方法。
ByteBuffer encode(CharBuffer cb):将CharBuffer中的字符序列转换成字节序列的便捷方法。
ByteBuffer encode(String str):将String中的字符序列转换成字节序列的便捷方法。
也就是说,获取了Charset对象后,如果仅仅只需要进行简单的编码、解码操作,起始可以不用创建CharsetEncoder和CharsetDecoder对象,直接调用Charset的encode()和decode()方法进行编码、解码。
package section9;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
public class CharsetTransformTest
{
public static void main(String[] args)
{
//创建简体中文的Charset
Charset cn=Charset.forName("GBK");
//创建一个Buffer对象
CharBuffer cbuff=CharBuffer.allocate(8);
cbuff.put(‘孙‘);
cbuff.put(‘悟‘);
cbuff.put(‘空‘);
//将limit移动到position所在位置,position=0
cbuff.flip();
System.out.println(cbuff);//孙悟空
System.out.println(cbuff.position());//0
//将字符序列转化为字节序列的便捷方式
ByteBuffer bbuff=cn.encode(cbuff);
System.out.println(cbuff.position());//3
cbuff.flip();//执行上面的准换后,position位置发生改变
System.out.println(cbuff);//孙悟空
System.out.println(bbuff);//java.nio.HeapByteBuffer[pos=0 lim=6 cap=6]
//将字节序列转化为字符序列的便捷方式
CharBuffer cbuff1=cn.decode(bbuff);
System.out.println(cbuff1.position());
System.out.println(cbuff1);//孙悟空
}
}
提示:在String类里也提供了一个getBytes(String charset)方法,该方法返回byte[],该方法也是使用指定的字符集将字符串转换为字节序列。
如果多个系统需要并发修改同一个文件时,程序之间需要某种机制来进行通信,使用文件锁可以有效地阻止多个进程并发修改同一个文件,所以现在大部分操作系统都提供了文件锁的功能。
文件锁控制文件或者文件部分字节的访问,但文件锁在不同操作系统的差别较大,所以早期的JDK版本并未提供文件锁的支持。从JDK1.4的新IO开始,Java开始提供文件锁的支持。
在NIO中,Java提供了FileLock来支持文件锁定功能,在FileChannel中提供的lock()/tryLock()方法可以获取文件锁FileLock对象,从而锁定文件。
Lock()和tryLock()方法的区别在于:
当Lock试图锁定某个文件时,如果无法得到文件锁,程序将一直阻塞;而tryLock()是尝试锁定文件,他将直接返回而不是阻塞,如果获得了文件锁,该方法返回文件锁,否则将返回null。
如果FileChannel只是像锁定文件部分内容,而不是锁定全部内容,可以使用如下的lock()或tryLock()方法:
1、lock(long position,long size,boolean shared):对文件的position开始,长度为size的内容加锁,该方法是阻塞式的。
2、tryLock(long position,long size,boolean shared):非阻塞式的加锁方式。参数同上类似。
当shared为true时,表明该锁是一个共享锁,它允许多个线程来读取该文件,但阻止其他进程获得对该文件的排他锁。当shared为false时,表明该锁是一个排他锁,它将锁住对文件的读写。程序可以通过调用FileLock的isShared来判断它获得的锁是不是共享锁。
直接使用lock()或tryLock()方法获取的文件锁是排他锁
处理完文件后通过FileLock的release()释放文件锁。下面程序示范了使用FileLock锁定文件。
package section9;
import java.io.FileOutputStream;
import java.nio.channels.FileLock;
public class FileLockTest
{
public static void main(String[] args)
{
try(
//使用FileOutputStream获取FileChannel
var channel=new FileOutputStream("src//section9//a.txt").getChannel()
)
{
//使用非阻塞式方式对文件加锁
FileLock lock=channel.tryLock();
System.out.println(lock);//sun.nio.ch.FileLockImpl[0:9223372036854775807 exclusive valid]
//程序暂停10s
Thread.sleep(10000);
//释放锁
lock.release();
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
上面程序FileLock lock=channel.tryLock();对指定文件加锁,接着程序调用Thread.sleep(10000)暂停10s后才释放文件锁,因此在这10s内,其他程序无法对a.txt文件进行修改。
在某些平台上,文件锁仅仅是建议性的,并不是强制式的。这意味着即使一个程序不能获得文件锁,它也可以对该文件进行读写。
在某些平台上,不能同步地锁定一个文件并把它映射到内存中。
文件锁是由Java虚拟机所持有的,如果两个Java程序使用同一个Java虚拟机运行,则它们不能对同一个文件进行加锁。
在某些平台上当关闭 FileChannel时,会释放Java虚拟机在该文件上的所有锁,因此应该避免对同一个被锁定的文件打开多个FileChannel。
标签:需要 OLE exce 访问 java虚拟机 relative body charset 多次
原文地址:https://www.cnblogs.com/weststar/p/12828711.html