Java IO/输入与输出(续)

qdl2010

BufferedReader和BufferedWriter类
                                                                                                                                      
BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如:
BufferedReader in = new BufferedReader(new FileReader("foo.in"));将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。

构造方法摘要

BufferedReader
(
Reader
in)
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。


BufferedReader
(
Reader
in, int sz)
          创建一个使用指定大小输入缓冲区的缓冲字符输入流。

方法摘要
void

close
()
          关闭该流并释放与之关联的所有资源。
void

mark
(int readAheadLimit)
          标记流中的当前位置。
boolean

markSupported
()
          判断此流是否支持 mark() 操作（它一定支持）。
int

read
()
          读取单个字符。
int

[url=http://www.blogjava.net/java/io/BufferedReader.html#read(char[], int, int)]read[/url]
(char[] cbuf, int off, int len)
          将字符读入数组的某一部分。

String

readLine
()
          读取一个文本行。
boolean

ready
()
          判断此流是否已准备好被读取。
void

reset
()
          将流重置到最新的标记。
long

skip
(long n)
          跳过字符。
BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入通常 Writer 将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。例如，
PrintWriter out   = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));
将缓冲 PrintWriter 对文件的输出。如果没有缓冲，则每次调用 print() 方法会导致将字符转换为字节，然后立即写入到文件，而这是极其低效的。
构造方法摘要

BufferedWriter
(
Writer
out)
          创建一个使用默认大小输出缓冲区的缓冲字符输出流。


BufferedWriter
(
Writer
out, int sz)
          创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

方法摘要
void

close
()
          关闭此流，但要先刷新它。
void

flush
()
          刷新该流的缓冲。
void

newLine
()
          写入一个行分隔符。
void

[url=http://www.blogjava.net/java/io/BufferedWriter.html#write(char[], int, int)]write[/url]
(char[] cbuf, int off, int len)
          写入字符数组的某一部分。
void

write
(int c)
          写入单个字符。
void

write
(
String
s, int off, int len)
          写入字符串的某一部分。

BufferedReader的readLine方法可以一次读取一行文本，BufferedWriter的newLine方法可以向字符流中写入不同操作系统下的换行符。

PrintStream类
                                                                                                                                      
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用
PrintWriter
类。
●     PrintStream类提供了一系列的print和println方法，可以将基本数据类型的数据格式化成字符串输出。
●     格式化输出是什么意思？例如：97被格式化输出的实际字节数据为0x39和0x37。
构造方法摘要

PrintStream
(
File
file)
          创建具有指定文件且不带自动行刷新的新打印流。


PrintStream
(
File
file,
String
csn)
          创建具有指定文件名称和字符集且不带自动行刷新的新打印流。


PrintStream
(
OutputStream
out)
          创建新的打印流。


PrintStream
(
OutputStream
out, boolean autoFlush)
          创建新的打印流。


PrintStream
(
OutputStream
out, boolean autoFlush,
String
encoding)
          创建新的打印流。


PrintStream
(
String
fileName)
          创建具有指定文件名称且不带自动行刷新的新打印流。


PrintStream
(
String
fileName,
String
csn)
          创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

方法摘要

PrintStream

append
(char c)
          将指定字符添加到此输出流。

PrintStream

append
(
CharSequence
csq)
          将指定字符序列添加到此输出流。

PrintStream

append
(
CharSequence
csq, int start, int end)
          将指定字符序列的子序列添加到此输出流。
boolean

checkError
()
          刷新流并检查其错误状态。
protected  void

clearError
()
          清除此流的内部错误状态。
void

close
()
          关闭流。
void

flush
()
          刷新该流的缓冲。

PrintStream

format
(
Locale
l,
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化字符串写入此输出流中。

PrintStream

format
(
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化字符串写入此输出流中。
void

print
(boolean b)
          打印 boolean 值。
void

print
(char c)
          打印字符。
void

[url=http://www.blogjava.net/java/io/PrintStream.html#print(char[])]print[/url]
(char[] s)
          打印字符数组。
void

print
(double d)
          打印双精度浮点数。
void

print
(float f)
          打印浮点数。
void

print
(int i)
          打印整数。
void

print
(long l)
          打印 long 整数。
void

print
(
Object
obj)
          打印对象。
void

print
(
String
s)
          打印字符串。

PrintStream

printf
(
Locale
l,
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化的字符串写入此输出流的便捷方法。

PrintStream

printf
(
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化的字符串写入此输出流的便捷方法。
void

println
()
          通过写入行分隔符字符串终止当前行。
void

println
(boolean x)
          打印 boolean 值，然后终止行。
void

println
(char x)
          打印字符，然后终止该行。
void

[url=http://www.blogjava.net/java/io/PrintStream.html#println(char[])]println[/url]
(char[] x)
          打印字符数组，然后终止该行。
void

println
(double x)
          打印 double，然后终止该行。
void

println
(float x)
          打印 float，然后终止该行。
void

println
(int x)
          打印整数，然后终止该行。
void

println
(long x)
          打印 long，然后终止该行。
void

println
(
Object
x)
          打印 Object，然后终止该行。
void

println
(
String
x)
          打印 String，然后终止该行。
protected  void

setError
()
          将该流的错误状态设置为 true。
void

[url=http://www.blogjava.net/java/io/PrintStream.html#write(byte[], int, int)]write[/url]
(byte[] buf, int off, int len)
          将 len 字节从指定的初始偏移量为 off 的 byte 数组写入此流。
void

write
(int b)
          将指定的字节写入此流。

PrintWriter类
                                                                                                                                      
向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用 checkError() 是否出现错误
●     与PrintStream对应的PrintWriter类，即使遇到了文本换行标识符（\n），PrintWriter类也不会自动清空缓冲区。
●     PrintWriter的println方法能根据操作系统的不同而生成相应的文本换行标识符。在Windows下的文本换行标识符是”\r\n”，而Linux下的文本换行标识符是”\n”。
构造方法摘要

PrintWriter
(
File
file)
          使用指定文件创建不具有自动行刷新的新 PrintWriter。


PrintWriter
(
File
file,
String
csn)
          创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter。


PrintWriter
(
OutputStream
out)
          根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。


PrintWriter
(
OutputStream
out, boolean autoFlush)
          通过现有的 OutputStream 创建新的 PrintWriter。


PrintWriter
(
String
fileName)
          创建具有指定文件名称且不带自动行刷新的新 PrintWriter。


PrintWriter
(
String
fileName,
String
csn)
          创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。


PrintWriter
(
Writer
out)
          创建不带自动行刷新的新 PrintWriter。


PrintWriter
(
Writer
out, boolean autoFlush)
          创建新 PrintWriter。

方法摘要

PrintWriter

append
(char c)
          将指定字符添加到此 writer。

PrintWriter

append
(
CharSequence
csq)
          将指定的字符序列添加到此 writer。

PrintWriter

append
(
CharSequence
csq, int start, int end)
          将指定字符序列的子序列添加到此 writer。
boolean

checkError
()
          如果流没有关闭，则刷新流且检查其错误状态。
protected  void

clearError
()
          清除此流的错误状态。
void

close
()
          关闭该流并释放与之关联的所有系统资源。
void

flush
()
          刷新该流的缓冲。

PrintWriter

format
(
Locale
l,
String
format,
Object
... args)
          使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。

PrintWriter

format
(
String
format,
Object
... args)
          使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。
void

print
(boolean b)
          打印 boolean 值。
void

print
(char c)
          打印字符。
void

[url=http://www.blogjava.net/java/io/PrintWriter.html#print(char[])]print[/url]
(char[] s)
          打印字符数组。
void

print
(double d)
          打印 double 精度浮点数。
void

print
(float f)
          打印一个浮点数。
void

print
(int i)
          打印整数。
void

print
(long l)
          打印 long 整数。
void

print
(
Object
obj)
          打印对象。
void

print
(
String
s)
          打印字符串。

PrintWriter

printf
(
Locale
l,
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化的字符串写入此 writer 的便捷方法。

PrintWriter

printf
(
String
format,
Object
... args)
          使用指定格式字符串和参数将格式化的字符串写入此 writer 的便捷方法。
void

println
()
          通过写入行分隔符字符串终止当前行。
void

println
(boolean x)
          打印 boolean 值，然后终止该行。
void

println
(char x)
          打印字符，然后终止该行。
void

[url=http://www.blogjava.net/java/io/PrintWriter.html#println(char[])]println[/url]
(char[] x)
          打印字符数组，然后终止该行。
void

println
(double x)
          打印双精度浮点数，然后终止该行。
void

println
(float x)
          打印浮点数，然后终止该行。
void

println
(int x)
          打印整数，然后终止该行。
void

println
(long x)
          打印 long 整数，然后终止该行。
void

println
(
Object
x)
          打印 Object，然后终止该行。
void

println
(
String
x)
          打印 String，然后终止该行。
protected  void

setError
()
          指示已发生错误。
void

[url=http://www.blogjava.net/java/io/PrintWriter.html#write(char[])]write[/url]
(char[] buf)
          写入字符数组。
void

[url=http://www.blogjava.net/java/io/PrintWriter.html#write(char[], int, int)]write[/url]
(char[] buf, int off, int len)
          写入字符数组的某一部分。
void

write
(int c)
          写入单个字符。
void

write
(
String
s)
          写入字符串。
void

write
(
String
s, int off, int len)
          写入字符串的某一部分。

ObjectInputStream
                                                                                                                                    
ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。ObjectOutputStream和ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。
readObject 方法用于从流读取对象。应该使用 Java 的安全强制转换来获取所需的类型。在Java中，字符串和数组都是对象，所以在序列化期间将其视为对象。读取时，需要将其强制转换为期望的类型。可以使用 DataInput上的适当方法从流读取基本数据类型。
默认情况下，对象的反序列化机制会将每个字段的内容恢复为写入时它所具有的值和类型。反序列化进程将忽略声明为瞬态或静态的字段。对其他对象的引用使得根据需要从流中读取这些对象。使用引用共享机制能够正确地恢复对象的图形。反序列化时始终分配新对象，这样可以避免现有对象被重写。
读取对象类似于运行新对象的构造方法。为对象分配内存并将其初始化为零 (NULL)。为不可序列化类调用无参数构造方法，然后从以最接近 java.lang.object 的可序列化类开始和以对象的最特定类结束的流恢复可序列化类的字段。
例如，要从由 ObjectOutputStream 中的示例写入的流读取：
        FileInputStream fis = new FileInputStream("t.tmp");        ObjectInputStream ois = new ObjectInputStream(fis);        int i = ois.readInt();        String today = (String) ois.readObject();        Date date = (Date) ois.readObject();         ois.close();

类控制实现 java.io.Serializable 或 java.io.Externalizable 接口时的序列化方式。
实现 Serializable 接口允许对象序列化，以保存和恢复对象的全部状态，并且允许类在写入流时的状态和从流读取时的状态之间变化。它自动遍历对象之间的引用，保存和恢复全部图形。

构造方法摘要
protected

ObjectInputStream
()
          为完全重新实现 ObjectInputStream 的子类提供一种方式，让它不必分配仅由 ObjectInputStream 的实现使用的私有数据。


ObjectInputStream
(
InputStream
in)
          创建从指定 InputStream 读取的 ObjectInputStream。
方法摘要
int

available
()
          返回可以不受阻塞地读取的字节数。
void

close
()
          关闭输入流。
void

defaultReadObject
()
          从此流读取当前类的非静态和非瞬态字段。
protected  boolean

enableResolveObject
(boolean enable)
          使流允许从该流读取的对象被替代。
int

read
()
          读取数据字节。
int

[url=http://www.blogjava.net/java/io/ObjectInputStream.html#read(byte[], int, int)]read[/url]
(byte[] buf, int off, int len)
          读入 byte 数组。
boolean

readBoolean
()
          读取一个 boolean 值。
byte

readByte
()
          读取一个 8 位的字节。
char

readChar
()
          读取一个 16 位的 char 值。
protected  
ObjectStreamClass

readClassDescriptor
()
          从序列化流读取类描述符。
double

readDouble
()
          读取一个 64 位的 double 值。

ObjectInputStream.GetField

readFields
()
          按名称从流中读取持久字段并使其可用。
float

readFloat
()
          读取一个 32 位的 float 值。
void

[url=http://www.blogjava.net/java/io/ObjectInputStream.html#readFully(byte[])]readFully[/url]
(byte[] buf)
          读取字节，同时阻塞直至读取所有字节。
void

[url=http://www.blogjava.net/java/io/ObjectInputStream.html#readFully(byte[], int, int)]readFully[/url]
(byte[] buf, int off, int len)
          读取字节，同时阻塞直至读取所有字节。
int

readInt
()
          读取一个 32 位的 int 值。

String

readLine
()
          已过时。 此方法不能正确地将字节转换为字符。请参见 DataInputStream 以获取详细信息和替代方法。
long

readLong
()
          读取一个 64 位的 long 值。

Object

readObject
()
          从 ObjectInputStream 读取对象。
protected  
Object

readObjectOverride
()
          此方法由 ObjectOutputStream 的受信任子类调用，这些子类使用受保护的无参数构造方法构造 ObjectOutputStream。
short

readShort
()
          读取一个 16 位的 short 值。
protected  void

readStreamHeader
()
          提供的 readStreamHeader 方法允许子类读取并验证它们自己的流头部。

Object

readUnshared
()
          从 ObjectInputStream 读取“非共享”对象。
int

readUnsignedByte
()
          读取一个无符号的 8 位字节。
int

readUnsignedShort
()
          读取一个无符号的 16 位 short 值。

String

readUTF
()
          读取
UTF-8 修改版
格式的 String。
void

registerValidation
(
ObjectInputValidation
obj, int prio)
          在返回图形前注册要验证的对象。
protected  
Class

resolveClass
(
ObjectStreamClass
desc)
          加载指定流类描述的本地等价类。
protected  
Object

resolveObject
(
Object
obj)
          在反序列化期间，此方法允许 ObjectInputStream 的受信任子类使用一个对象替代另一个。
protected  
Class

[url=http://www.blogjava.net/java/io/ObjectInputStream.html#resolveProxyClass(java.lang.String[])]resolveProxyClass[/url]
(
String
[] interfaces)
          返回一个代理类，该类实现在代理类描述符中命名的接口；子类可以实现此方法，以便从流及动态代理类的描述符中读取自定义数据，允许它们使用接口和代理类的替换加载机制。
int

skipBytes
(int len)
          跳过字节。

●     ObjectInputStream和ObjectOutputStream这两个包装类，用于从底层输入流中读取对象类型的数据和将对象类型的数据写入到底层输出流。
●     ObjectInputStream和ObjectOutputStream类所读写的对象必须实现了Serializable接口。对象中的transient(临时的)和static类型的成员变量不会被读取和写入。
●     一个可以被序列化的MyClass类的定义：
public class MyClass implements Serilizable
{
       public transient Thread t;
       private String customerID;
       private int total;
}

ObjectOutputStream
                                                                                                                                       
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。
只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。
writeObject 方法用于将对象写入流中。所有对象（包括 String 和数组）都可以通过 writeObject 写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应 ObjectInputstream 中读回对象。
还可以使用 DataOutput 中的适当方法将基本数据类型写入流中。还可以使用 writeUTF 方法写入字符串。
对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。其他对象的引用（瞬态和静态字段除外）也会导致写入那些对象。可使用引用共享机制对单个对象的多个引用进行编码，这样即可将对象的图形恢复为最初写入它们时的形状。
例如，要写入可通过 ObjectInputStream 中的示例读取的对象，请执行以下操作：
        FileOutputStream fos = new FileOutputStream("t.tmp");        ObjectOutputStream oos = new ObjectOutputStream(fos);        oos.writeInt(12345);        oos.writeObject("Today");        oos.writeObject(new Date());        oos.close();

构造方法摘要
protected

ObjectOutputStream
()
          为完全重新实现 ObjectOutputStream 的子类提供一种方法，让它不必分配仅由 ObjectOutputStream 的实现使用的私有数据。


ObjectOutputStream
(
OutputStream
out)
          创建写入指定 OutputStream 的 ObjectOutputStream。
方法摘要
protected  void

annotateClass
(
Class
cl)
          子类可以实现此方法，从而允许在流中存储类数据。
protected  void

annotateProxyClass
(
Class
cl)
          子类可以实现此方法，从而在流中存储定制数据和动态代理类的描述符。
void

close
()
          关闭流。
void

defaultWriteObject
()
          将当前类的非静态和非瞬态字段写入此流。
protected  void

drain
()
          排空 ObjectOutputStream 中的所有已缓冲数据。
protected  boolean

enableReplaceObject
(boolean enable)
          允许流对流中的对象进行替换。
void

flush
()
          刷新该流的缓冲。

ObjectOutputStream.PutField

putFields
()
          获取用于缓冲写入流中的持久存储字段的对象。
protected  
Object

replaceObject
(
Object
obj)
          在序列化期间，此方法允许 ObjectOutputStream 的受信任子类使用一个对象替代另一个对象。
void

reset
()
          重置将丢弃已写入流中的所有对象的状态。
void

useProtocolVersion
(int version)
          指定要在写入流时使用的流协议版本。
void

[url=http://www.blogjava.net/java/io/ObjectOutputStream.html#write(byte[])]write[/url]
(byte[] buf)
          写入一个 byte 数组。
void

[url=http://www.blogjava.net/java/io/ObjectOutputStream.html#write(byte[], int, int)]write[/url]
(byte[] buf, int off, int len)
          写入字节的子数组。
void

write
(int val)
          写入一个字节。
void

writeBoolean
(boolean val)
          写入一个 boolean 值。
void

writeByte
(int val)
          写入一个 8 位字节。
void

writeBytes
(
String
str)
          以字节序列形式写入一个 String。
void

writeChar
(int val)
          写入一个 16 位的 char 值。
void

writeChars
(
String
str)
          以 char 序列形式写入一个 String。
protected  void

writeClassDescriptor
(
ObjectStreamClass
desc)
          将指定的类描述符写入 ObjectOutputStream。
void

writeDouble
(double val)
          写入一个 64 位的 double 值。
void

writeFields
()
          将已缓冲的字段写入流中。
void

writeFloat
(float val)
          写入一个 32 位的 float 值。
void

writeInt
(int val)
          写入一个 32 位的 int 值。
void

writeLong
(long val)
          写入一个 64 位的 long 值。
void

writeObject
(
Object
obj)
          将指定的对象写入 ObjectOutputStream。
protected  void

writeObjectOverride
(
Object
obj)
          子类用于重写默认 writeObject 方法的方法。
void

writeShort
(int val)
          写入一个 16 位的 short 值。
protected  void

writeStreamHeader
()
          提供 writeStreamHeader 方法，这样子类可以将其自身的头部添加或预加到流中。
void

writeUnshared
(
Object
obj)
          将“未共享”对象写入 ObjectOutputStream。
void

writeUTF
(
String
str)
          以
UTF-8 修改版
格式写入此 String 的基本数据。

编程举例：创建了一个可序列化的学生对象，并用ObjectOutputStream类把它存储到一个文件（student.txt）中，然后再用ObjectInputStream类把存储的数据读取到一个学生对象，即恢复保存的学生对象。
import java.io.Serializable;

public class Student implements Serializable
{
       String name="";
       int age;
       public Student(String name,int age)
       {
              this.name=name;
              this.age=age;
       }
}

import java.io.*;
public class ObjectStream
{
       public static void main(String[] args)
       {
              // TODO: Add your code here
              Student stu1=new Student("张三",18);
              Student stu2=new Student("李四",20);
              File f=new File("student.txt");
              try
              {
                     FileOutputStream fos=new FileOutputStream(f);
                     ObjectOutputStream oos=new ObjectOutputStream(fos);
                     oos.writeObject(stu1);
                     oos.writeObject(stu2);
                     oos.writeObject(new Date());
                     oos.close();
                     
                     FileInputStream fis=new FileInputStream(f);
                     ObjectInputStream ois=new ObjectInputStream(fis);
                     stu1=(Student)ois.readObject();
                     stu2=(Student)ois.readObject();
                     System.out.println("姓名="+stu1.name);
                     System.out.println("年龄="+stu1.age);
                     System.out.println("姓名="+stu2.name);
                     System.out.println("年龄="+stu2.age);
                     System.out.println((Date)ois.readObject());
                     ois.close();     
              }
              catch(Exception e)
              {
                     e.printStackTrace();
              }
       }     
}

InpuStreamReader
                                                                                                                                         
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的
charset
读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如：
BufferedReader in   = new BufferedReader(new InputStreamReader(System.in));

构造方法摘要

InputStreamReader
(
InputStream
in)
          创建一个使用默认字符集的 InputStreamReader。


InputStreamReader
(
InputStream
in,
Charset
cs)
          创建使用给定字符集的 InputStreamReader。


InputStreamReader
(
InputStream
in,
CharsetDecoder
dec)
          创建使用给定字符集解码器的 InputStreamReader。


InputStreamReader
(
InputStream
in,
String
charsetName)
          创建使用指定字符集的 InputStreamReader。

方法摘要
void

close
()
          关闭该流并释放与之关联的所有资源。

String

getEncoding
()
          返回此流使用的字符编码的名称。
int

read
()
          读取单个字符。
int

[url=http://www.blogjava.net/java/io/InputStreamReader.html#read(char[], int, int)]read[/url]
(char[] cbuf, int offset, int length)
          将字符读入数组中的某一部分。
boolean

ready
()
          判断此流是否已经准备好用于读取。

OutputStreamWriter
                                                                                                                                       
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的
charset
将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。
为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。例如：
BufferedWriter out   = new BufferedWriter(new OutputStreamWriter(System.out));

字节流与字符流的转换
                                                                                                                       
●     能不能找到一种简单的方式来读取键盘上输入的一行字符，如何找？
●     InputStreamReader和OutputStreamWriter，是用于将字节流转换成字符流来读写的两个类，InputStreamReader可以将一个字节流中的字节解码成字符后读取，OutputStreamWriter将字符编码成字节后写入到一个字节流中。
●      避免频繁地在字符与字节之间进行转换，最好不要直接使用InputStreamReader和OutputStreamWriter类来读写数据，应尽量使用BufferedWriter类包装OutputStreamWriter类，用BufferedReader类包装InputStreamReader。
BufferedReader in
   = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter out
   = new BufferedWriter(new OutputStreamWriter(System.out));
例:
import java.io.*;
public class BufferedTest
{
       public static void main(String[] args) throws Exception
       {
              // TODO: Add your code here
              System.out.println("请输入文字:");
              BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
              String str=br.readLine();
              br.close();
              //System.out.println(str);
              
              FileReader fr=new FileReader("b.txt");
              char[]buf=new char [1024];
              int len=fr.read(buf);
              String strInfo=new String(buf,0,len);
              BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
              bw.write(strInfo);
              System.out.println(strInfo);
              bw.close();
              
              
              FileWriter fw=new FileWriter("buffered.txt");
              fw.write(str);
              fw.close();
              
              FileOutputStream fos=new FileOutputStream("fos.txt");
              byte[]buf=str.getBytes();
              fos.write(buf);
              fos.close();
              
              FileReader fr=new FileReader("a.txt");
              char[]bufChar=new char[1024];
              int len=fr.read(bufChar);
              System.out.println(new String(bufChar,0,len));
              fr.close();
       }     
}

Java程序与其它进程的数据通信
                                                                                                                                       
●     在Java程序中可以用Process类的实例对象来表示子进程，子进程的标准输入和输出不再连接到键盘和显示器，而是以管道流的形式连接到父进程的一个输出流和输入流对象上。
●     调用Process类getOutputStream和getInputStream方法可以获得连接到子进程的输出流和输入流对象。
●     管道缓冲区满后，与PipedInputStream相连的PipedOutputStream无法再写入新的数据，PipedOutputStream.writer方法将处于阻塞状态。
●     用Process类的destroy方法结束子进程的运行。
●     编程实例：在TestInOut类中启动java.exe命令执行另外一个MyTest类，TestInOut和MyTest通过进程间的管道相互传递数据。
分析：
父进程（TestInOut）启动子进程（MyTest类），主线程（main）不停向子进程发送数据(send方法)，另一线程不停从子进程中读取数据（run方法），在构造函数中启动子进程和一线程。
import java.io.*;
public class TestInOut implements Runnable
{
       Process p=null;
       public TestInOut()
       {
              try
              {
                     p=Runtime.getRuntime().exec("java MyTest");
                     new Thread(this).start();
              }
              catch(Exception e)
              {
                     e.printStackTrace();
              }
              
       }
       public static void main(String[] args)
       {
              // TODO: Add your code here
              TestInOut ti=new TestInOut();
              ti.send();
       }

       public void send()
       {
              try
              {
                     OutputStream ops=p.getOutputStream();
                     while(true)
                     {
                            ops.write("Hello\r\n".getBytes());
                     }
              }
              catch(Exception e)
              {
                     e.printStackTrace();
              }
       }
       public void run()
       {
              try
              {
                     InputStream ips=p.getInputStream();
                     BufferedReader br=new BufferedReader(new InputStreamReader(ips));
                     while(true)
                     {
                            String str=br.readLine();
                            if(str!=null)
                            {
                                   System.out.println(str);
                            }
                            else
                            {
                                   return ;
                            }     
                     }
              }
              catch(Exception e)
              {
                     e.printStackTrace();
              }
                     
       }
}

import java.io.*;
public class MyTest
{
       public static void main(String[] args)
       {
              // TODO: Add your code here
              try
              {
                     BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                     while(true)
                     {
                            String str=br.readLine();
                            if(str!=null)
                            {
                                   System.out.println(str+"World");
                            }
                            else
                            {
                                   return ;
                            }
                     }
              }
              catch(Exception e)
              {
                     e.printStackTrace();
              }
       }     
}

字节输入流类
                                                                                                                                      

字节输出流类
                                                                                                                                      

字符输入流类
                                                                                                                                      

字符输出流类
                                                                                                                                      

Decorator设计模式
                                                                                                                                      
●     在程序中用一个对象（the Decorators）包装另外一个对象，这是一种被称为Decorator的设计模式。
●     如果要设计自己的IO包装类，这个类需要继承以FilterXXX命名的类，例如，设计一对输入输出包装类：RecordInputStream和RecorderOutputStream,来完成从数据库文件中读取记录和往数据库文件中写入记录。
●     Excption类从Throwable类继承的三个printStackTrace方法的定义如下：
        n Public void printStackTrace();
        n Public void printStackTrace(PrintStream s);
        nPublic void printStackTrace(PrintWriter s);
该如何把printStackTrace方法打出的详细异常信息存储到一个字符串中？
编写下面的程序代码，分析和观察程序的运行结果：
import java.io.*;
public class TestPrintWriter
{
      
       public static void main(String[] args) throws Exception
       {
              // TODO: Add your code here
              try
              {
                     throw new Exception("test");
              }
              catch(Exception e)
              {
                     /*StringWriter sw=new StringWriter();
                     PrintWriter pw=new PrintWriter(sw);
                     e.printStackTrace(pw);
                     System.out.println(sw.toString());
                     File f=new File("a.txt");
                     PrintStream ps=new PrintStream(f);
                     e.printStackTrace(ps);
                     FileInputStream fis=new FileInputStream(f);
                     byte []buf=new byte [1024];
                     int len=fis.read(buf);
                     System.out.println(new String(buf,0,len));*/
                     FileOutputStream fos=new FileOutputStream("b.txt");
                     PrintStream ps=new PrintStream(fos);
                     e.printStackTrace(ps);
                     System.out.println(fos.toString());
              }
       }     
}
思考与实践
                                                                                                                                      
编写下面的程序代码，分析和观察程序的运行结果：
import java.io.*;
class InputReader
{
       public static void main(String[] args) throws Exception
       {
              // TODO: Add your code here
              InputStreamReader ips=new InputStreamReader(System.in,"iso8859-1");
              BufferedReader br=new BufferedReader(ips);
              System.out.println("请输入文字:");
              String str=br.readLine();
              int len=str.length();
              for(int i=0;i
              {
                     System.out.println(Integer.toHexString((int)str.charAt(i)));
              }
              System.out.println(str);
              ips.close();
       }     
}
程序运行结果：
请输入文字:
中国
d6
d0
b9
fa
???ú
请按照下面的两种要求修改上面的程序代码，让程序能够正常打印出输入的中文字符：
（1）     修改程序中的语句：     
                    InputStreamReader ips=new InputStreamReader(System.in,"iso8859-1");                        
               修改如下：                                                                                                        
                    InputStreamReader ips=new InputStreamReader(System.in);     
（2）     修改下面的语句：                                                                                                   
                    System.out.println(str);
               修改如下：
                    System.out.println(new String(str.getBytes("iso8859-1"),"GBK"));


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/65993/showart_2001442.html