《Java编程思想》之I/O系统
2012-02-05 19:40 java线程例子 阅读(704) 评论(0) 编辑 收藏 举报1、Java中“流“类库让人迷惑的主要原因：创建单一的结果流，却需要创建多个对象。
2、使用层叠的数个对象为单个对象动态地、透明地添加职责的方式，称作“修饰器“模式。修饰器必须与其所修饰的对象具有相同的接口，这使得修饰器的基本应用具有透明性——我们可以想修饰过或没有修饰过的对象发送相同的消息。
3、为什么使用修饰器？
在直接使用扩展子类的方法时，如果导致产生了大量的、用以满足所需的各种可能的组合的子类，这是通常就会使用修饰器——处理太多的子类已经不太实际。
4、修饰器的缺点：增加代码的复杂性。
5、JavaI/O类库操作不便的原因在于：我们必须创建许多类——“核心”I/O类型加上所有的修饰器，才能得到我们所希望的单个I/O对象。
6、FilterInputStream和FilterOutputStream是用来提供修饰器类接口以控制特定输入流和输出流的俩个类。它们分别继承自I/O类库中的基类InputStream和OutputStream。
7、DataInputStream是FilterInputStream的直接子类，它允许我们读取不用的基本类型数据以及String对象。
8、InputStream和OutputStream是面向字节的，而Reader和Writer是面向字符与兼容Unicode。
9、在InputStream和OutputStream的继承层次结构仅支持8位的字节流，并且不能很好地处理16位的Unicode。由于Unicode用用于字符国际化，所以添加Reader和Write继承结构就是为了在所有的I/O操作中都支持Unicode。另外添加了Reader和Write的I/O流类库使得它的操作比旧类库更快。
10、但是，Reader和Write并不是用来取代nputStream和OutputStream的，因为InputStream和OutputStream在面向字节形式的I/O中仍然提供了极有价值的功能。
11、有时，我们需要把来自于“字节”层次结构的类和“字符”层次结构的类结合起来使用。这时，需要使用“适配器(adapter)”类：InputStreamReader可以把InputStream转换为Reader，而OutputStreamWriter可以把OutputStream转换为Writer。
12、当我们使用DataOutputStream时，写字符串并且让DataInputStream能够恢复它的唯一可靠的做法就是使用UTF-8编码。UTF-8是Unicode的变体，后者把所有字符都存储成两个字节的形式。而我们使用的只是ASCII或者几乎是ASCII字符（只占7位），这么做就显得极其浪费空间和宽带，所以UTF-8将ASCII字符编码成单一字节的形式，而非ASCII字符则编码成两到三个字节的形式。另外，字符串的长度存储在两个字节中。
13、System.in是一个没有被加工过的InputStream，所以在读取System.in之前必须对其进行加工。
14、标准I/O重定向：如果我们突然开始在显示器上创建大量输出，而这些输出滚动得太快以至于无法阅读是，重定向输出就显得极为有用。重定向有一下方法：
SetIn(InputStream) SetOut(InputStream) SetErr(InputStream)
注意：重定向操作的是字节流（InputStream、OutputStream），而不是字符流。
15、JDK1.4的java.nio.*包引入了新的JavaI/O类库，其目的在于提高速度。速度的提高来自于所使用的结构更接近操作系统的I/O的方式：通道和缓冲器。
我们可以把它想象成一个煤矿，通道是一个包含煤层（数据）的矿藏，而缓冲器则是派送到矿藏的卡车。卡车载满煤炭而归，我们再从卡车上获得煤炭。也就是说，我们并没有直接和通道交互；只是和缓冲器交互，并把缓冲器派送到通道。通道要么从缓冲器获得数据，要么向缓冲器发送数据。
唯一直接与通道交互的缓冲器是ByteBuffer——也就是说，可以存储未加工字节的缓冲器。ByteBuffer是一个相当基础的类：通过告知分配多少存储空间来创建一个ByteBuffer对象，并且还有一个方法选择集，用以原始的字节形式或基本数据类型输出和读取数据。
16、FileInputStream、FileOutputStreaam以及用于既读又写的RandomAccessFile被使用nio重新实现过，都有一个getChannel()方法返回一个FileChannel（通道）。通道是一种相当基础的东西：可以向它传送用于读写的ByteBuffer，并且可以锁定文件的某些区域用于独占式访问。Reader和Writer这种字符模式类不能产生通道；但是java.nio.channels.Channels类提供了实用方法，用以在通道中产生Reader和Wirter。
以下
17、转换数据：缓冲器容纳的是普通的字节，为了把它们转化成字符，我们要么在输入它们的时候对其进行编码，要么在将其从缓冲器输出时对它们进行解码。请参看下面例子：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
public class GetChannel{
public static void main(String[] args) throws Exception{
//写入data.txt
FileChannel fc = new FileOutputStream("data.txt").getChannel();
fc.write(ByteBuffer.wrap("Some text".getBytes()));
fc.close();
//读取data.txt
fc = new FileInputStream("data.txt").getChannel();
ByteBuffer buff = ByteBuffer.allocate(1024);
fc.read(buff);
buff.flip();
System.out.println(buff.asCharBuffer());
//使用系统默认的字符集进行解码（输出时对其进行解码）
buff.rewind();/返回数据开始的部分
String encoding = System.getProperty("file.encoding");
System.out.println("Decodedusing " + encoding + ":"
+ Charset.forName(encoding).decode(buff));
//再次写入（输入时对其进行编码）
fc = new FileOutputStream("data.txt").getChannel();
fc.write(ByteBuffer.wrap("Some text".getBytes("UTF-16BE")));
fc.close();
//再次读取
fc = new FileInputStream("data.txt").getChannel();
buff = ByteBuffer.allocate(1024);
fc.read(buff);
buff.flip();
System.out.println(buff.asCharBuffer());
//再次写入（输入时对其进行编码）
fc = new FileOutputStream("data.txt").getChannel();
buff = ByteBuffer.allocate(24);
buff.asCharBuffer().put("Some text");
fc.write(buff);
fc.close();
//再次读取
fc = new FileInputStream("data.txt").getChannel();
buff.clear();
fc.read(buff);
buff.flip();
System.out.println(buff.asCharBuffer());
}
}
运行结果：
18、获取基本类型：尽管ByteBuffer只能保存字节类型的数据，但是它具有从其所容纳的字节中产生出各种不同的类型值的方法。
import java.nio.ByteBuffer;
public class GetData{
private final static int BSIZE = 1024;
public static void main(String[] args){
ByteBuffer bb = ByteBuffer.allocate(BSIZE);
int i = 0;
while(i++ < bb.limit()){
if(bb.get() != 0){
System.out.println("nonzero");
}
}
System.out.println("i = " + i);
bb.rewind();
//char
bb.asCharBuffer().put("Howdy");
char c;
while((c = bb.getChar()) != 0){
System.out.print(c + " ");
}
System.out.println();
bb.rewind();
//short。是一个特例，必须加上（short）进行类型转换
bb.asShortBuffer().put((short)471142);
System.out.println(bb.getShort());
bb.rewind();
//int
bb.asIntBuffer().put(99471142);
System.out.println(bb.getInt());
bb.rewind();
//long
bb.asLongBuffer().put(99471142);
System.out.println(bb.getLong());
bb.rewind();
//float
bb.asFloatBuffer().put(99471142);
System.out.println(bb.getFloat());
bb.rewind();
//double
bb.asDoubleBuffer().put(99471142);
System.out.println(bb.getDouble());
bb.rewind();
}
}
运行结果：
19、视图缓冲器：可以让我们通过某个特定的基本数据类型的视窗查看其底层的ByteBuffer。
ByteBuffer bb = ByteBuffer.allocate(BSIZE); //asIntBuffer() 创建此字节缓冲区的视图，作为 int 缓冲区。 IntBuffer ib = bb.asIntBuffer();
20、不同机器可能会有不同的字节排序方法来存储数据。默认的ByteBuffer是以高位优先的顺序存储数据的。考虑下面两个字节：
如果我们以short（ByteBuffer.asShortBuffer）高位优先读出的是97（0000000001100001），若更改ByteBuffer更改为地位优先，则读出的是24832（0110000100000000）。再看下面例子：
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
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");
//array()只能对有数组支持的缓冲器调用
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()));
}
}
运行结果：
21、如果想把一个字节数组写到文件中去，那么应该使用ByteBuffer.wrap()方法把字节数组包装起来，然后用getChannel()方法在FileOutputStream上打开一个通道，接着将来自于ByteBuffer的数据写到FileChannel中去。
22、存储器映射文件：允许我们创建和修改那些因为太大而不能放入内存的文件。有了存储器映射文件，我们就可以假定整个文件都在内存中，而且可以完全把它当作非常大的数组来访问。
尽管“旧”的I/O在用nio实现后性能有所提高，但是“映射文件访问”往往可以更加显著地加快速度。
23、文件加锁机制：允许我们同步访问某个作为共享资源的文件。文件锁对其它操作系统进程是可见的，因为Java的文件加锁之间映射到本地操作系统的加锁工具。另外，利用对映射文件的部分加锁，可以对巨大的文件进行部分加锁，以便其他进程可以对修改文件中未被加锁的部分。
24、压缩：Java压缩类库是按字节方式的，它们继承自InputStream和OutputStream。
1).GZIP:如果只想对单个数据流（而不是一系列互异数据）进行压缩，那么它是比较适合的选择。下面是对单个文件进行压缩的例子：
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
public class GZIPcompress{
public static void main(String[] args) throws IOException{
//InputStreamReader中设置字符编码为GBK
BufferedReader in = new BufferedReader(new InputStreamReader(new
FileInputStream("test.txt"), "GBK"));
BufferedOutputStream out = new BufferedOutputStream((
new GZIPOutputStream(new FileOutputStream("test.txt.gz"))));
System.out.println("Writingfile");
int c;
while((c = in.read()) != -1){
//使用GBK字符编码将此 String编码到 out中
out.write(String.valueOf((char) c).getBytes("GBK"));
}
in.close();
out.close();
System.out.println("ReadingFile");
BufferedReader in2 = new BufferedReader((new InputStreamReader
(new GZIPInputStream(new FileInputStream("test.txt.gz")))));
String s;
while((s = in2.readLine()) != null){
System.out.println(s);
}
}
}
2).用Zip进行多文件压缩：对于每一个要加入压缩档案的文件，都必须调用putNextEntry(),并将其传递给一个ZipEntry对象。
25、对象的序列化：将那些实现Serializable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。利用它可以实现“轻量持久性”。
1).“持久化”：意味一个对象的生存周期并不取决于程序是否正在执行。通过将一个序列化对象写入磁盘，然后再重新调用程序时恢复该对象，就能够实现持久性的效果。
2).“轻量级”：因为它不能用某种“persistent”(持久)关键字来简单定一个对象，并让系统自动维护其他细节问题。相反，对象必须在程序中显示地序列化和反序列化还原。
26、对象序列化的概念加入到语言中是为了支持两种主要特性：
1).Java的“远程方法调用”（Remote Method Invocation,RMI）。
2).Java Beans。
27、
1).序列化：创建OutputStream对象，封装到ObjectOutputStream,再调用writeObject()
2).反序列化：创建InputStream对象，封装到ObjectInputStream,再调用readObject()
3).Serializable的对象在还原的过程中，没有调用任何构造器。
28、对象序列化是面向字节的，因此采用InputStream和OutputStream层次结构。
29、序列化的控制：
1).实现Externalizable接口，接口继承自Serializable，添加了writeExternal()和readExternal()两个方法，它们会在序列化和反序列化还原的过程中被自动调用。
2).反序列过程中,对于Serializable对象，对象完全以它存储的二进制位为基础来构造，而不是调用构造器。而Externalizeble对象，普通的缺省构造函数会被调用。
3).transient(瞬时)关键字：只能和Serializable对象一起使用。
private transient String password;
password将不会被保存到磁盘中。
30、序列化/反序列化static成员：显示调用serializeStaticState()和deserializeStaticState()
31、Preferences:用于存储和读取用户的偏好（preferences）以及程序配置项的设置。只能用于小的、受限的数据集合——我们只能保存基本数据类型和字符串，并且每个字符串的存储类型长度不能超过8K（不是很小，单我们也不想用它来创建任何重要的东西）。它是一个键-值集合（类似映射），存储在一个节点层次结构中。
import java.util.Arrays;
import java.util.Iterator;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;
public class PreferencesDemo{
public static void main(String[] args) throws BackingStoreException{
Preferences prefs = Preferences.userNodeForPackage(PreferencesDemo.class);
prefs.put("日期", "2012年02月05日");
prefs.put("天气", "晴");
prefs.putInt("放假多少天了？", 24);
prefs.putBoolean("现在在家？", true);
int usageCount = prefs.getInt("寒假还剩多少天？", 16);
usageCount--;
prefs.putInt("寒假还剩多少天？", usageCount);
Iterator<String> it = Arrays.asList(prefs.keys()).iterator();
while(it.hasNext()){
String key = it.next().toString();
//null作为缺省
System.out.println(key + ":" + prefs.get(key, null));
}
System.out.println("放假多少天了？" + prefs.getInt("放假多少天了？", 0));
}
}
注意：每次运行，usageCount的值没都减少1。即每次打印出“寒假还剩多少天？”后面的数字都减少1。然而，在程序第一次运行之后，并没有任何本地文件出现。Preferences API利用合适的系统资源完成了这个任务，并且这些资源会随操作系统的不同而不同。例如在windows里，就使用注册表。
32、正则表达式：
1). 在Java ，“\\”意味“我正在插入一个正则表达式反斜杠”，那么随后的字符具有特殊意义。若想插入一个字面意义上的反斜杠，得这样子表示“\\\\”。
2).量词：
·贪婪的：竟可能的模式发现尽可能的匹配。
·勉强的：用问号来指定，匹配满足模式所需的最少字符数。
·占有的：只有在Java语言中才可用，并且它也更高效，常常用于防止正则表达式失控，因此可以是正则表达式执行起来更有效。
3).注意abc+与(abc)+的不同。
4).在java中，正则表达式是通过java.util.regex包里面的Pattern和Matcher类来实现的。
·Pattern对象表示一个正则表达式的编译版本。静态的complie()方法将一个正则表达式字符串编译成Pattern对象。
·Matcher对象有matcher()方法和输入字符串编译过的Pattern对象中产生Matcher对象。
5).split()分裂操作将输入字符串断开成字符串对象数组。
