新I/O

    在JDK1.4的java.nio.*包中引入了新的I/O库，主要目的是为了提高速度，原有的I/O库也已经使用nio重新实现过了。速度的提高来自于nio所使用的结构更接近于操作系统执行I/O的方式，使用了通道和缓冲器，我们直需要和缓冲器交互，并把缓冲器派送到通道。
    那么根据上面的说明，我们操作流时所做的事情就应该是得到通道，然后从通道中得到缓冲器，操作缓冲器得到数据。或者是把数据保存到缓冲器然后把缓冲器送给通道。看例子：

public class GetChannel { public final int BSIZE = 1024; public void readFile() throws IOException{ FileChannel fc = new FileInputStream("/data.txt").getChannel(); ByteBuffer buff = ByteBuffer.allocate(BSIZE); fc.read(buff); buff.flip(); while(buff.hasRemaining()){ System.out.println((char)buff.get()); } } /** * 加入到文件的末尾 * @param s * @throws IOException */ public void addToEnd(String s) throws IOException{ FileChannel fc = new RandomAccessFile("/data.txt", "rw").getChannel(); fc.position(fc.size()); fc.write(ByteBuffer.wrap(s.getBytes())); fc.close(); } /** * 写入到文件中 * @param s * @throws IOException */ public void writeToFile(String s) throws IOException{ FileChannel fc = new FileOutputStream("/data.txt").getChannel(); fc.write(ByteBuffer.wrap(s.getBytes())); fc.close(); } public void channelCopy() throws IOException{ FileChannel in = new FileInputStream("/data.txt").getChannel(), out = new FileOutputStream("/datacopy.txt").getChannel(); ByteBuffer buffer = ByteBuffer.allocate(BSIZE); while(in.read(buffer) != -1){ buffer.flip(); out.write(buffer); buffer.clear(); } } public void transferTo() throws IOException{ FileChannel in = new FileInputStream("/data.txt").getChannel(), out = new FileOutputStream("/dataTransfer.txt").getChannel(); in.transferTo(0, in.size(), out); // 或者用out.transferFrom(in, 0, in.size()); } public static void main(String[] args) throws IOException { GetChannel channel = new GetChannel(); String s = "abc你好"; channel.writeToFile(s); channel.addToEnd(s); channel.readFile(); channel.channelCopy(); channel.transferTo(); } }

 

• 例子中使用流类的getChannel()方法得到通道FileChannel。
• ByteBuffer是一个字节的缓冲器，只能保存字节，可以使用put方法进行直接填充。也可以使用warp(byte[])方法把已经存在的字节数组包装到ByteBuffer中。
• 通过FileChannel的position方法能够随意移动其在文件中的位置。
• 只读访问的时候，必须使用allocate()方法分配ByteBuffer。或者是使用allocateDirect()来分配，这种分配方式耦合了系统的缓冲器，会随着平台的不同而不同。
• 一旦使用fc的read方法，就会告知FC向ByteBuffer存储字节。这是我们必须调用缓冲器上的flip()，让它做好让别人读取字节的准备。
• channelCopy方法中使用了两个通道进行文件的存储，其中使用writer(buffer)的时候要注意，使用之后需要使用buffer.clear()来清空缓存区，以方便缓存区继续接受值
• 在channelCopy中的方式能够看到两个通道是通过Buffer暂存了一下数据进行转移的，这种方式看起来就比较笨拙，咋个不能两个通道直接进行转移呢。transferTo方法就演示了两个通道直接交互的方式。

   上面的例子中每次只能够读取一个字节的数据，这样似乎有点儿笨，如果能把读取出来的字节数组转化为字符串就比较合适了。使用buff.asCharBuffer()方法就能够实现这一点。但是如果是使用字符型的缓存就会涉及到编码的问题，看例子：

public class BufferToText { /** * 使用默认的字符集进行解码 * @throws IOException */ public void decodingWithDefault() throws IOException{ FileChannel fc = new FileInputStream("/data.txt").getChannel(); ByteBuffer buff = ByteBuffer.allocate(1024); fc.read(buff); buff.flip(); System.out.println(buff.asCharBuffer().toString()); // 会发现打印的是乱码 // 需要使用系统默认的字符集进行编码 buff.rewind(); String encoding = System.getProperty("file.encoding"); System.out.println("使用字符集" + encoding + ":" + Charset.forName(encoding).decode(buff)); } /** * 写入文件的时候进行编码 * @throws IOException */ public void writeByUTF() throws IOException{ FileChannel fc = null; ByteBuffer buff = ByteBuffer.allocate(1024); // 使用指定的格式进行编码 fc = new FileOutputStream("/data3.txt").getChannel(); fc.write(ByteBuffer.wrap("abc你好".getBytes("UTF-16BE"))); fc.close(); // 进行了编码之后的文件重新使用charBuffer读取一下试试 fc = new FileInputStream("/data3.txt").getChannel(); buff.clear(); fc.read(buff); buff.flip(); System.out.println(buff.asCharBuffer().toString()); } /** * 使用CharBuffer写入文件 * @throws IOException */ public void writeByCharBuffer() throws IOException{ FileChannel fc = null; ByteBuffer buff = ByteBuffer.allocate(24); // 使用charBuffer进行写文件。 fc = new FileOutputStream("/data4.txt").getChannel(); buff.asCharBuffer().put("adbd你好"); fc.write(buff); fc.close(); fc = new FileInputStream("/data4.txt").getChannel(); buff.clear(); fc.read(buff); buff.flip(); System.out.println(buff.asCharBuffer().toString()); } public static void main(String[] args) throws IOException { BufferToText bufferToText = new BufferToText(); bufferToText.decodingWithDefault(); bufferToText.writeByUTF(); bufferToText.writeByCharBuffer(); } }

直接打印buff.asCharBuffer()会是乱码，必须要经过编码处理
处理的方式为两种，要不就在输出的时候进行解码像writeByUTF中那样，或者是在输入的时候进行编码。

 

获取原始类型

ByteBuffer虽然只能保存字节类型的数据，但是它提供了产生各种不同原始类型的方法。例子如下：

public class GetData { ByteBuffer bb = ByteBuffer.allocate(256); /** * 测试默认初始化的buffer中的所有的值都为0 * */ public void checkDefaultIsZero(){ for (int i = 0; i < bb.limit(); i++) { if(bb.get() != 0){ System.out.println("nonzero"); } } } /** * 读取char * */ public void storeReadChar(){ bb.rewind(); bb.asCharBuffer().put("abcd你好"); char c; while((c = bb.getChar()) != 0){ System.out.println(c + " "); } } /** * 读取整型和浮点型 * */ public void storeReadOther(){ bb.rewind(); bb.asIntBuffer().put(12345); System.out.println(bb.getInt()); bb.rewind(); bb.asDoubleBuffer().put(2.124); System.out.println(bb.getDouble()); } public static void main(String[] args) { GetData data = new GetData(); data.checkDefaultIsZero(); data.storeReadChar(); data.storeReadOther(); } } //读取 public class ViewBuffers { public static void main(String[] args) { ByteBuffer bb = ByteBuffer.wrap(new byte[]{0,0,0,0,0,0,0,'a'}); bb.rewind(); StringBuffer sb = new StringBuffer(); sb.append("<html><head></head><body><table border='1'><tbody><tr>"); sb.append("<td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr>"); while(bb.hasRemaining()){ sb.append("<td>" + bb.get() + "</td>"); } sb.append("</tr><tr>"); // CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer(); // while(cb.hasRemaining()){ // sb.append("<td colspan='2'>" + cb.get() + "</td>"); // } bb.rewind(); while(bb.hasRemaining()){ sb.append("<td colspan='2'>" + bb.getChar() + "</td>"); } sb.append("</tr><tr>"); bb.rewind(); while(bb.hasRemaining()){ sb.append("<td colspan='2'>" + bb.getShort() + "</td>"); } sb.append("</tr><tr>"); bb.rewind(); while(bb.hasRemaining()){ sb.append("<td colspan='4'>" + bb.getInt() + "</td>"); } sb.append("</tr><tr>"); bb.rewind(); while(bb.hasRemaining()){ sb.append("<td colspan='8'>" + bb.getDouble() + "</td>"); } sb.append("</tr></tbody></table></body></html>"); System.out.println(sb.toString()); } }

 

不管是通过试图还是缓冲器直接添加的数据实际上都是改变了缓冲器中的byte的内容。
当使用不同的试图查看数据的时候，查看的结果是按照下列规则进行的

1	2	3	4	5	6	7	8
0	0	0	0	0	0	0	97
						a
0		0		0		97
0				97
4.8E-322

 

字节排序方式。

有高位优先和低位优先两种。高位优先是把比较重要的字节放在地址最高的存储器单元，低位反之。ByteBuffer默认为高位反之。看例子：

public class Endians { public static void main(String[] args) { ByteBuffer bb = ByteBuffer.wrap(new byte[12]); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); bb.rewind(); bb.order(ByteOrder.BIG_ENDIAN); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); bb.rewind(); bb.order(ByteOrder.LITTLE_ENDIAN); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); } }

看这个例子就很好的展示了怎样使用bb.order(ByteOrder.LITTLE_ENDIAN);更改读取的次序。
综上所述，使用nio进行数据转移的时候我们要知道只有ByteBuffer才能够跟通道进行交互。

 

缓冲器的组成

缓冲器是能够跟通道进行通信的唯一方式。下面就来说一下这个缓冲器的内部结构。
在缓冲器中存在的是byte类型的数据和用于操作数据的四个索引。这些索引为：mark,position,limit,capacity。
其中mark代表标记能够把这个标记指定到某个位置，其他操作会借助这个标记。
position是当前缓存所在的位置。
limit指限额。
capacity指容量。
缓冲器又提供了如下的方法来使用这些索引。
capacity()得到容量，也就是position。
clear() 。清空缓存区，将position置0，limit置为容量。
flip()。 将limit置为position,position设置为0.此方法用于准备从缓存区读取已经写入的数据。
limit()。返回limit值。
mark()将mark设置为position。
position()返回position的值。
remaining() 返回limit-position。
hasRemaining() 若有介于position和limit之间的元素，则返回true。

看例子：

public class UserBuffers { private static void changeIndex(CharBuffer buffer){ while(buffer.hasRemaining()){ buffer.mark(); char c1 = buffer.get(); char c2 = buffer.get(); buffer.reset(); buffer.put(c2).put(c1); } } public static void main(String[] args) { char[] data = "abcedf你好".toCharArray(); ByteBuffer bb = ByteBuffer.allocate(data.length * 2); CharBuffer cb = bb.asCharBuffer(); cb.put(data); System.out.println(cb.rewind()); changeIndex(cb); System.out.println(cb.rewind()); changeIndex(cb); System.out.println(cb.rewind()); } }

 

最开始调用put之后的结果是position指向0，limit指向容量。
当调用了mark之后。会把mark指向当前position的位置。使用get方法后position会+1.
调用reset()方法会把position的值设置为mark的值。使用了put方法之后position也会+1.
这里还要说一下flip()方法，因为在调用了read方法之后limit的值为容量，但是有可能并没有填满，而这时position指向的是最后一个存在的元素，因此调用了flip()方法之后能够保证limit指向了最后一个存在的元素，这个时候使用hasRemaining判断的时候能够保证不会输出空的元素。

 

存储器映射文件

这种方式允许我们创建和修改哪些因为太大而不能放入内存的文件。使用存储器映射文件我们可以假定整个文件都在内存中，而且可以完全把它当做非常大的数组来访问。

public class LargeMappedFiles { static int length = 0x8FFFFFF; public static void main(String[] args) throws FileNotFoundException, IOException { MappedByteBuffer out = new RandomAccessFile("/data.txt","rw").getChannel().map(FileChannel.MapMode.READ_WRITE, 0, length); for (int i = 0; i < length; i++) { out.put((byte)'x'); } System.out.println("finished"); } }

使用这种映射文件的方式要比常规的流的方式效率上高很多。

 

对象序列化

把一个对象转化为一个字节序列，对象的序列化加入到java语言中主要是为了对RMI提供支持，使得其他计算机能够像使用本地对象一样使用远程对象。另一个原因是为了支持javaBeans的序列化。
只要对象实现了Serializable接口(这个接口仅仅是一个标记，没有任何的方法)，对象就能够被序列化。

public class SeriaObject implements Serializable{ private static final long serialVersionUID = 1L; private String name = ""; private int age = 0; private Date date = null; public SeriaObject() { } public SeriaObject(String name,int age,Date date) { this.name = name; this.age = age; this.date = date; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } public String getName() { return name; } public void setName(String name) { this.name = name; } public static void main(String[] args) throws IOException, ClassNotFoundException { SeriaObject seriaObject = new SeriaObject("小王", 23, new Date()); ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("/seriaObject.out")); output.writeObject("你好"); output.writeObject(seriaObject); System.out.println("序列化完成之后进行读取"); ObjectInputStream input = new ObjectInputStream(new FileInputStream("/seriaObject.out")); String s = (String)input.readObject(); SeriaObject o = (SeriaObject)input.readObject(); System.out.println(s); System.out.println(o.getName() + ":" + o.getAge() + ":" + o.getDate()); } }

上面的例子表示了一个对象进行序列号之后是能够进行还原的。

 

序列化的控制。

如果我们想对序列号进行一些控制，可以怎样办呢？

public class UsersExtern implements Externalizable{ private static final long serialVersionUID = 1L; private String name = ""; private int age = 0; // 必须有public的默认的构造函数，因为在反序列化的时候需要调用这个构造函数 public UsersExtern(){ System.out.println("UsersExtern"); } public UsersExtern(String name, int age){ System.out.println("UsersExtern(String name, int age)"); this.name = name; this.age = age; } @Override public String toString() { return name + ":" + age; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { System.out.println("readExternal"); name = (String)in.readObject(); // age = in.readInt(); } public void writeExternal(ObjectOutput out) throws IOException { System.out.println("writeExternal"); out.writeObject(name); out.writeInt(age); } public static void main(String[] args) throws IOException, ClassNotFoundException { UsersExtern usersExtern = new UsersExtern("王", 23); System.out.println(usersExtern); // 序列号对象 ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("/userEx.out")); output.writeObject(usersExtern); output.close(); // 重新得到对象 ObjectInputStream input = new ObjectInputStream(new FileInputStream("/userEx.out")); UsersExtern user = (UsersExtern)input.readObject(); System.out.println(user); } }
在上面这个例子中，我们可以通过实现Externalizable接口来控制序列化，首先必须有public的默认的构造器，因为反序列化的时候会调用。
接口中有两个方法writeExternal在进行序列号的时候会调用，我们可以通过out.writeXX()来控制序列化哪些元素。
还有一个readExternal方法，可以通过in.readXX()方法来控制还原哪些元素。

如果不想使用Externalizable接口还可以在实现了Serializable接口后，在类中自定义writeObject(ObjectOutputStream output)
和readObject(ObjectInputStream input)方法，分别来控制序列号和反序列化的动作。
下面的例子可以看出transient关键字在默认的序列化中是不会被序列化的，但是可以通过手工添加的方式进行序列化。

public class UsersSeria implements Serializable{ private static final long serialVersionUID = 1L; private String name; private transient String password; public UsersSeria(String name, String password) { this.name = name; this.password = password; } @Override public String toString() { return name + "==" + password; } private void writeObject(ObjectOutputStream output) throws IOException{ output.defaultWriteObject(); output.writeObject(password); } private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException{ input.defaultReadObject(); this.password = (String)input.readObject(); } public static void main(String[] args) throws IOException, ClassNotFoundException { UsersSeria usersSeria = new UsersSeria("王","wzj123"); System.out.println(usersSeria); // 把对象序列化到内存中 ByteArrayOutputStream buff = new ByteArrayOutputStream(); ObjectOutputStream output = new ObjectOutputStream(buff); output.writeObject(usersSeria); // 从内存中拿回数据 ObjectInputStream input = new ObjectInputStream(new ByteArrayInputStream(buff.toByteArray())); UsersSeria users = (UsersSeria)input.readObject(); System.out.println(users); } }

序列化能够维护整个对象网的信息

class People implements Serializable{ } public class Hourse implements Serializable{ private People people; public Hourse(People people){ this.people = people; } public People getPeople() { return people; } public void setPeople(People people) { this.people = people; } public String toString() { return super.toString() + "people" + getPeople() + "/n"; } public static void main(String[] args) throws IOException, ClassNotFoundException { People people = new People(); Hourse hourse1 = new Hourse(people); Hourse hourse2 = new Hourse(people); List<Hourse> hourses = new ArrayList<Hourse>(); hourses.add(hourse1); hourses.add(hourse2); System.out.println(hourses); ByteArrayOutputStream buf1 = new ByteArrayOutputStream(), buf2 = new ByteArrayOutputStream(); ObjectOutputStream o1 = new ObjectOutputStream(buf1), o2 = new ObjectOutputStream(buf2); o1.writeObject(hourses); o2.writeObject(hourses); // 进行反序列化 ObjectInputStream in1 = new ObjectInputStream(new ByteArrayInputStream(buf1.toByteArray())), in2 = new ObjectInputStream(new ByteArrayInputStream(buf2.toByteArray())); List<Hourse> hourses1 = (List<Hourse>)in1.readObject(); List<Hourse> hourses2 = (List<Hourse>)in2.readObject(); System.out.println(hourses1); System.out.println(hourses2); } }

在这个例子中我们会发现在同一个流中读出的list中的两个hourse对象所含有的原来一个People的引用在反序列化之后仍然是一个引用。
这个可以成为深度复制，及不光复制了原来对象的引用，还复制了整个对象网。