Java-IO流

一、流的概念
概念：内存与存储设备之间传输数据的通道。
数据借助流传输
二、流的分类
1.按方向【重点】
输入流：将<硬盘存储设备>中的内容读入到<JVM虚拟机内存>中
输出流：将<内存>中的内容写入到<存储设备>中

2.按单位：
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据，只能处理字符

3.按功能
节点流：具有实际传数据的读写功能
过滤流：在节点流的基础之上增强功能

三、字节流
1.字节流的父类（抽象类）：
(1)InputStream:字节输入流

public int read(){}//从输入流中读取数据的下一个字节
public int read(byte[] b){}  //从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
public int read(byte[] b,int off,int len){}//将输入流中最多len个数据字节读入byte数组。
public int available()
public void close()
public void mark(int readlimit)
public boolean markSupport()
public void reset()
public long skip(long n)

//
public abstract class InputStream extends Object implements Closeable
此抽象类是表示字节输入流的所有类的超类。
需要定义InputStream子类的应用程序必须总是提供返回输入字节的方法。
//
(2)OutputStream:字节输出流

public void close() //关闭此输出释放与此流有关的所有系统资源
public void flush() //刷新此输出流并强制写出所有缓冲的输出字节。
public void write(int n){}//将指定的字节写入此输出流
public void write(byte[] b){}//将b.length个字节从指定的byte数组写入此输出流
public void write(byte[] b.int off,int len){}//将指定byte数组中从偏移量off开始的len个字节写入此输出流。

public abstract class OutputStream extends Object implements Closeable, Flushuable
此抽象类是表示所有字节输出流的类的超类。输出流接收输出字节并将这些字节发送到某个接收器
需要定义OutputStream子类的应用程序必须始终提供至少一种可写入一个输出字节的方法。、

2.字节节点流
(1)FileOutputStream
public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流
/public classs FileOutputStream extends OutputStream
文件输出流是用于将数据写入File或FileDescriptor的输出流。文件是否可用或能否可以创建取决于基础平台。特别是某些平台一次只允许一个FileOutputStream（或其他文件写入对象）打开文件进行写入。这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。
FileOutputStream用于写入诸如图像数据之类的原始字节的流。写入字符流，请考虑使用FileWriter.
构造方法//

FileOutputStream(File file)//创建一个向指定File对象表示的文件写入数据的文件输出流
FileoutputStream(File file,Boolean append)//创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(FileDescriptor fdObj)//创建一个向指定文件描述符写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接
FileOutputStream(String name) // 创建一个向指定名称的文件中写入数据的输出文件流
FileOutputStream(String name,Boolean append)//创建一个向具有指定name的文件中写入数据的输出文件流

//

main()throws IOException{
//字节输出流//绝对路径 E:\\Target.txt  硬编码写死
//相对路径：相对于当前的项目的根目录
FileOutputStream fos = new FileOutputStream(“Files\\Target.txt”,ture);//E:\//追加true/不追加false///在项目根目录下创建Files文件夹里的Target文本
fos.write(65); //A 一次输出一个字节
byte[] bs = new byte[]{65,66,67,68,69}
fos.write(bs); //一次输出一组字节
fos.write(bs,1,3);//一次输出一组字节的一部分}

//
(2)FileInputStream
public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果到达文件的尾部，则返回-1

public class FileInputStream extends InputStream 
FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。
FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用FileReader
///构造方法//
FileInputStream(File file)通过打开一个实际文件的连接
FileInputStream(FileDescriptor fdObj) 通过使用文件描述符fdObj创建一个FileInputStream，该文件描述符表示到文件系统某个实际文件的现有连接。
FileInputStream(String name)通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径名name指定。

main() throws FileNotFoundException{
FileInputStream fis = new FileInputStream(“Files\\Target.txt”);
//一次读一个字节
while(true){
int n = fis.read();
if(n == 1){ break;}
System.out.println((char)n); }

//一次读一组字节
byte[] cache = new byte[4];//创建一个长度4的数组，作为了读取时的缓存  1024*1024  1M
while(true){
int count = fis.read(cache);//每读取一次，填满数组（注意：最后一次可能无法填满）
if(count == -1 ){break;}
for(int i=0;i<count;i++){//根据读取字节的个数，决定打印的次数
System.out.println((char)catche[i] + “\t”);
}}}

//
3.字节过滤流
(1)缓冲流：BufferedOutputStream/BufferedInputStream
提高IO效率，减少访问磁盘的次数；
数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

public class BufferedOutputStream extends FilterOutputStream
该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
buf存储数据的内部缓冲区
count 缓冲区的有效字节数
BufferedOutputStream(OutputStream out)//创建一个新的缓冲区输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out,int size)//创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
void flush() 刷新此缓冲区的输出流
void write(byte[] b,int off,int len)将指定byte数组中从偏移量off开始的len个字节写入此缓冲的输出流
void write(int b) 将指定的字节写入此缓冲的输出流
/

main() throws IOException{
	FileOutputStream os =new FileOutputStream(“Files\\offer.txt”);//节点流
	BufferedOutputStream bos = new BufferedOutputStream(os);//过滤流
	bos.write(‘A’);
	bos.flush();//刷新缓冲（将缓冲中的数据，一次性写入有文件中，并清空缓冲区）
	bos.close();//级联执行flush()

/

	FileInputStream is = new FileInputStram(“Files\\ndas.txt”);
	byte[] cache =new [4];
	while(true){
	int  count = is.read(cache);
	if(count == -1) break;
	for(int i=0;i<count;i++{
		System.out.prinltn(cache[i]+“\t”);}
	System.out.println();)}}

public class BufferedInputStream extends FilterInputStream
BufferesInputStream为另一个输入流添加一些功能，即缓冲输入以及支持mark和reset方法的能力。在创建BufferedInputStream时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark操作记录输入流中的某个点，reset操作使得在从包含的输入流中获得新字节之前，再次读取自最后一次mark操作后读取的所有字节。
buf 存储数据的内部缓冲区数组
count 比缓冲区中最后一个有效字节的索引大1的索引
marklimit 调用mark方法后，在后续调用reset方法失败之前所允许的最大提前读取量
markpos 最后一次调用mark方法时pos字段的值
pos 缓冲区中的当前位置。
BufferedInputStream(InputStream out)
//创建一BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream out,int size)
//创建具有指定缓冲区大小的BufferedInputStream并保存其参数，即输入流in，以便将来使用。

///
(2)对象流：ObjectOutputStream/ObjectInputStream
增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能：
readObject()从流中读取一个对象
writeObject(Object obj)向流中写入一个对象
使用流传输对象的过程称为序列化，反序列化
///1///
public class ObjectOutputStream extends OutputStream implements ObjectOutput,ObjectStreamConstants
ObjectOutputStream将Java对象的基本数据类型和图形写入OutputStream。可以使用ObjectOutputStream读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接自流，则可以在另一台主机上或另一个进程中重构对象。
只能将支持java.io.Serializable接口的对象写入流中。所有对象（包括String和数组）都可以通过writeObject写入。可将多个对象或基元写入流中。必须使用与写入对象时相同的类型和顺序从相应ObjectInputStream中读回对象。
还可以使用DataOutput中的适当方法将基本数据类型写入流中，还可以使用writeUTF方法写入字符串
对象的默认序列化机制写入的内容是：对象的类，类签名，以及非瞬态和非静态字段的值。其他对象的引用（瞬态和静态字段除外）也会导致写入哪些对象。可使用引用共享机制对单个对象的多引用进行编码，这样即可将对象的图形恢复为最初写入它们时的形状。
把对象存到文件里是序列化，把文件把对象读出是反序列化
ObjectOutputStream()为完全重新实现ObjectOutputstream的子类提供一种方法，让它不必分配仅由OnjectOutputStream的实现使用的私有数据
ObjectOutputStream(OutputStream out)
创建写入指定OutputStream的ObjectOutStream

//

main()throws IOException{
OutputStream os = new FileOutputStream(“Files\\Object.txt”);
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeDouble(3.5);//将该数据写入文件（而非文本）
oos.flush();
InputStream is = new FileInputSteam(“File\\Object.txt”);
ObjectInputStream ois = new ObjectInputStream(is);
double result = ois.readDouble();
System.out.println(result);}

///
public interface Serializable
类通过实现java.io.Serializable接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
要允许不可序列化的子类类型序列化，可以假定该子类型负责保存和恢复超类型的公用（public）、受保护的（protected）和（如果可访问）包（package）字段的状态。仅在子类类型扩展的类有一个可访问的无参构造方法来初始化该类的状态时，才可以假定子类型有此职责。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。
在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数构造方法。可序列化子类的字段从该流中恢复
当遍历一个图形时，可能回遇到不支持Serializable接口的对象。在此情况下，将抛出NotSerializableExeception，并将标识不可序列化对象的类。
在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

public void writeObject(java.io.ObjectOutputStream out) throws IOException
private void readObject(java.io.ObjectOutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws OnjectStreamException

//

main()throws Exception{
OutputStream os = new FileOutputStream(“Files\\Object.txt”);
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeDouble(new Student(“tom”,20,“男”，99D)); 
oos.flush();
//--------------------------------
InputStream is = new FileInputSteam(“File\\Object.txt”);
ObjectInputStream ois = new ObjectInputStream(is);
Object obj = ois.readObject();
Student stu = (Student)obj;
System.out.println(stu.name + stu.age + stu.sex + stu.score);}

class Student implements Seriazlizable{
String name;
string sex;
Integer age;
Double score;
public Student(String name,Integer age,String sex,Double score){
super();
this.name=name;
this.age=age;
this.sex=sex;
this.score=score;}
}

///

4对象序列化
对象序列化的细节
必须实现Serializable接口
必须保证其所有属性均可序列化
transient修饰为临时属性，不参与序列化
读取到文件尾部的标准：java.io.EOFEXception
///

main()throws Exception{
OutputStream os = new FileOutputStream(“Files\\Object.txt”);
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeDouble(new Student(“tom”,20,“男”，99D,new Address())); 
oos.flush();
//--------------------------------
InputStream is = new FileInputSteam(“File\\Object.txt”);
ObjectInputStream ois = new ObjectInputStream(is);
while(true){
try{
Object obj = ois.readObject();
System.out.pritnln(obj.toString());
}catch(EOFEException e){break;}}//读到末尾，处理异常

class Student implements Seriazlizable{
String name;
string sex;
transient Integer age;//瞬时，不会存缓存中
Double score;
Address addr;
public Student(String name,Integer age,String sex,Double score,Address addr){
super();
this.name=name;
this.age=age;
this.sex=sex;
this.score=score;
this.addr=addr;}
public String toString(){
return “Student[name=“+ name+”， age=“+ age+”， sex=“+ sex+”， score=“+ score+”， addr=“ +addr+”]”} 
 }
class Address implements Serializable{
String position;
String zipCode;}

//
四、编码方式
1.字符编码
ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
UTF-8 针对Unicode的可变长度字符编码
GB2312 简体中文
GBK 简体中文、扩充
BIG5 繁体中文
当编码方式和解码方式不一致时，会出现乱码
///

main(){
String s1 =“你好世界123adc”;//一个字符“编码”两字节
byte[] bs =s1.getBytes();
for(int i=0;i<bs.length;i++){
System.out.println(bs[i]);}}
//
main() throws UnsupportedEncodingException{
String s1 =“你好世界123adc”;//一个字符两字节
byte[] bs =s1.getBytes(“GBK”);//GBK文本转二进制
//使用流写入到文件中
FileOutputStream os =new FileOutputStream(“xxx”);
os.write(bs);
String s2= new String(bs,“GBK”);//二进制“解码”转换GBK文本
System.out.println(s2);
}

五、字符流
1.字符流的父类
Reader:字符输入流
public int read(){}
public int read(char[] c){}
public int read(char[] b,int off,int len){}
///
public abstract class Reader extends Object implements Readable,Closeable
用于读取字符流的抽象类，子类必须实现的方法只有read(char[],int,int)和close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。

Writer:字符输出流

public void write(int n){}
public void write(String str){}
public void write(char[] c){}

public abtract class Writer extends Object implements Appendable, Closeable, Flushable
写入字符流的抽象类。子类必须实现的方法仅有write(char[],int,int)、flush()和close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
///
2.字符节点流
FileWrite
public void write(String str)//一次写多个字符，将b组中所有字符，写入输出流
///
public class FileWriter extends OutputStreamWruter
用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在FileOutputStream上构造一个OutputStreamWriter.
文件是否可用或是否可以被创建取决于底层平台。特别是某些平台一次只允许一个FileWriter（或其他文件写入对象）打开文件进行写入。在这种情况下，如过所涉及的文件已经打开，则此类中的构造方法将失败。
FileWriter用于写入字符流。要写入原始字节流，清考虑使用FileOutputStream.

FileWriter(String fileName) 根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,Boolean append) 根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter对象。
//

main() throws IOException{
Writer fw new FileWriter(“Files\\chars.txt”);
fw.write(“HelloWorld”);
fw.flush();
fw.close();

Reader fr = new FileReader(“Files\\chars.txt”);

while(true){
int n = fr.read();
if(n == -1 ) break;
System.out.println((char)n)}
///或///
char[] cache =new char[5];
while(true){
int n = fr.read(cache);
if(n == -1 ) break;
for(int i=0;i<n;i++){
System.out.println(cache[i]);}
System.out.println();
}
}

//
FileReader
public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1

public class FileReader extends InputStreamReader
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以现在FileInputStream上构造一个InputStreamReader。
FileReader用于读取字符流。要读取原始字节流，请考虑使用FileInputStream

FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新FileReader

3.字符过滤流
缓冲流：BufferedWriter/BufferedReader
支持输入换行符
可一次写一行、读一行
PrintWriter
封装了print()/println()方法，支持写入后换行

1
public class BufferedWriter extends Writer
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
可以指定缓冲区的大小，或者接收默认的大小。在大多数情况下，默认值就足够大了。
该类提供了newLine()方法，它使用平台自己的分行分隔符概念，此概念有系统属性line.separator定义。并非所有平台都使用新行符（’\n’）来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。
通常Writer将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用BufferedWriter包装所有其write()操作可能开销很高Writer(如FileWriters 和 OutputStreamWriters)。例如:
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(“foo.out”)));
将缓冲PrintWriter对文件的输出，如果每次调用print()方法会导致将字符转换为字节，然后立即写入到文件，而这是极其低效的。

2///
public class BufferedReader extends Reader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
可以指定缓冲区的大小、或者可使用默认的大小。大多数情况下，默认值就足够大了。
通常，Reader所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求，因此，建议用BufferedReader包装所有其read()操作可能开销很高的Reader（如FileReader和InputStreamReader）。例如
BufferedReader in = new BufferedReader(new FileReader(“foo.in”));
将缓冲指定文件的输入。如果没有缓冲，则每次调用read()或readLine()都会导致文件中读取字节，并将其转换为字符后返回，而这是极其低效的。
通过用合适的BufferedReader替代每个DaraInputStream，可以对将DataInputStream用于文字输入的程序进行本地化。

main(){
Writer fe = new FileWriter(“Files\\b.txt”);
BufferedWriter bw =new BufferedWriter(fw);
bw.write(“Hello”);
bw.newLine();//分隔符
bw.write(“World”);
bw.close();

Reader fr  = new FileReader(“Files\\b.txt”);
BufferedReader br = new BufferedReader(fr);
for(;;){
	String s = br.readLine();
	if(s == null)break;
	System.out.println(s);
}
}

///3PrintWriter//
public class PrintWriter extends Writer
向文本输出流打印对象的格式化表示形式。此类实现在PrinStream中的所有print方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用为编码的字节流进行写入
与PrintStream类不同，如果启用了自动刷新。则只有在调用println、printf或format的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。
此类中的方法不会抛出I/O异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用checkError()是否出现错误
PrintStream//
public class PrintStream extends FilterOutputStream implements Appendable, Closeable
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream永远不会抛出IOException；而是，异常情况仅设置可通过checkError方法测试的内部标志。另外、为了自动刷新，可以创建一个PrintStream；这意味着可在写入byte数组之后自动调用flush方法，可调用其中一个println方法，或写入一个换行符或字节（’\n’）。
PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类
///

main(){
Writer fe = new FileWriter(“Files\\b.txt”);
PrintWriter pw = new PrintWriter(fw);
pw.println(“Hello”);
pw.println(“World”);
pw.close();

Reader fr  = new FileReader(“Files\\b.txt”);
BufferedReader br = new BufferedReader(fr);
for(;;){
	String s = br.readLine();
	if(s == null)break;
	System.out.println(s);
}
}

4.桥转换流 ：InputStreamReader/OutputStreamWriter
可将字节流转换为字符流
可设置字符的编码方式
// OutputStreamWriter///
public class OutputStreamWriter extends Writer

OutputStreamWriter是字符流通向字节流的桥梁：可使用指定的charset将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显示给定，否则将接受平台默认的字符集
每次调用write()方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区累积，可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给write()方法的字符没有缓冲。
为了获得最高效率，可考虑将OutputStreamWriter包装到BufferedWriter 中，以避免频繁调用转换器。例如。
Writer out =new BufferedWriter(new OutputStreamWriter(System.out));
代理对是一个字符，它由两个char 值序列表示：高代理项的范围为‘\uD800‘到’\uDBFF’，后跟范围为’\uDC00‘到’\uDFFF’的低代理项。
错误代理元素指的是后面不跟低代理项的高代理项。或前面没有高代理项的低代理项。
此类总是使用字符集的默认替代序列替代错误代理元素和不可映射的字符序列。如果需要更多地控制编码过程.则应该使用CharsetEncoder 类。
//构造方法
OutputStreamWriter(OutputStream out)
创建使用默认字符编码的OutputStreamWriter
OutputStreamWriter(OutputStream out,Charset cs)
创建使用给定字符集的OutputStreamWriter
OutputStreamWriter(OutputStream out,CharsetEncode enc)
创建使用给定字符集编码器的OutputStreamWriter
OutputStreamWriter(OutputStream out,String charsetName)
创建使用指定字符集的OutputStreamWriter

/

public static void main(String[] args) throws IOException {
//原来持有字节输出流
OutputStream os = new FileOutputStream("Files\lconvert.txt");
//转换为字符输出流
OutputStreamWriter osw = new OutputStreamWriter(os,"GBK");
//再包装一层
PrintWriter pw = new PrintWriter(osw);
pw.print1n("Hello");
pw.close();
}

///
/ InputStreamReader/

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

public static void main(String[] args) throws I0Exception {
//原来持有字节输出流
OutputStream os = new File0utputStream("Files\\convert.txt");
//转换为字符输出流
OutputStreamWriter osw = new OutputStreamWriter(os, "GBK" );//设置编码方式
//再包装一层
PrintWriter pw = new Printwriter(osw);
pw.println("你好");
pw.println("世界");
pw.close();
//-----------------
InputStream is = new FileInputStream("Files\\convert.txt");
InputStreamReader isr = new InputStreamReader(is , "GBK");//设置编码方式
BufferedReader br = new BufferedReader(isr);
while(true){
String s = br.readLine();
if(s == null) break;
System.out.println(s);
}

//
5.使用步骤
创建节点流
[创建过滤流 设置字符编码集]
封装过滤流
读写数据
关闭流

//--------------

main(){
	OutputStream os = null;
	InputStram is = null;
	BufferedOutputStream bos =null;//缓冲
	
try{
os = new FileOutputStream(“Files\\test.txt”);//输出流
bos = new BufferedOutputStream(os);
	//os.write(‘A’);
	bos.write(‘A’);//带缓冲的
	is = new FileInputStream(“Files\\text.txt”);	//输入流
	while(true){
int n = is.read()
if(n==-1)break;
System.out.println((char)n);}
}catch(IOException e){
	e.printStrackTrace();
}finally{
	try{
if(is!=null){
is.close();
}if(os!=null){
//os.close();
bos.close();
}
catch(IOException e){
e.printStackTrace();}}
}}

///
六、File类
1.概念：代表物理盘符的一个文件或者文件夹
File是Java中的一个对象可以代表物理盘符里的一个文件。
public class File extends Object implements Serizalizabke, Comparable

//---------------
File(File parent,String child)根据parent抽象路径名和child路径名字符串一个新File实例
File(String pathname)通过将给定路劲名字字符串转换为抽象路径名来创建一个新File实例
File(String parent,String child)根据parent路径名字字符串和child路劲名字符串创建一个新File实例
File(URI uri)通过将给定的file：URI转换为一个抽象路径名来创建一个新的Fiel实例

///----------
2.方法：
createNewFile()//创建一个新文件
Mkdir() //创建一个新目录
Delete() //删除文件或空目录
Exists() //判断File对象或对象所代表的对象是否存在
getAbsolutePath() //获取文件的绝对路径
getName() //取的名字
getParent() //获取文件/目录所在的目录
isDirectory() //是否是目录
isFile() //是否是文件
length() //获得文件的长度
listFiles() /列出目录中的所有内容
返回一个抽象路劲名数组，这些路径表示此抽象路劲名表示的目录的文件
renameTo() //修改文件名为

查询文件且后缀为.class文件

Boolean accept(File pathname)测试指定抽象路径名是否应该包含在某个路径名列表中
参数：pathname 要测试的抽象路劲名
返回：当且仅当应该包含pathname时返回true

3.FileFilter接口
public interface FileFilter
Boolean accept(File pathname)
当调用File类中的ListFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。

/***查找文件里面的所有.class文件***/
static int count =0;
main(){ showAll(
	new File(“E:\\”));
System.out.println(count);
}//用方法
public static void showAll(File dir){
//获取dir所代表的“E”盘中，所有的文件夹+所有的.class文件
File[] files = dir.listFiles(new FileFilter(){//获取所有文件
public Boolean accept(File file){
	if(file.isDirectory()){return true;}//是文件夹
if(file.isFile()){//是一个文件
if(file.getName().endsWith(“.class”)){
return ture;} }
return false;
} }); 
		if(files != null){
for(File file : files){
	if(file.isFile()){
	count++;
System.out.println(file.getAbsolutePath());}
else{
if(file.getName().equals(“eclipse(3)”)){
continue;//判断除去文件名为eclipse
}showAll(file);}} }//递归查找所有文件夹里面的.class文件}

七、总结
1.流的概念：
内存存储设备之间传输数据的通道
2.流的分类
输入流、输出流；字节流、字符流；节点流、过滤流；
3.序列化、反序列化
将对象通过流写入到文件，或将对象通过流读取到内存，必须实现Serializable接口
4.File对象
代表物理盘符中的一个文件或者文件夹。