IO框架
1、File
String类中的：
1、
2、String类中有一个可以把字符串转变成byte字节数组的形式，在文件的读写过程中很有用
2、File类
后面这两个经常用到的，常见的面试题：请把给出的一个目录下的所有.java文件打印出来，并且把文件的名字和目录都打印出来。所用到的就是第二个方法，但是参数是接口类的，要去实现接口。
这是个接口，要去实现它。一个类去实现一个接口，并且只创建一个对象， 可以用匿名内部类实现。
File[] fs=f.listFiles(new FileFilter(){//匿名内部类，一个程序员改写的程序
public boolean accept(File arg0) {
// TODO Auto-generated method stub
if(arg0.isDirectory())
return true;
if(arg0.isFile())
{
String name=arg0.getName();
if(name.endsWith(".java"))
return true;
else return false;
}else return false;
}
});
package chp8_final;
import java.io.*;
public class TestFile {
public static void main(String[] args) throws IOException, InterruptedException {
// TODO Auto-generated method stub
File f=new File("E:/javacode");
printJava(f);
}
static void printJava(File dir){
File[] fs=dir.listFiles(new FileFilter(){
@Override
public boolean accept(File arg0) {
// TODO Auto-generated method stub
if(arg0.isDirectory())
return true;
if(arg0.isFile())
{
String name=arg0.getName();
if(name.endsWith(".java"))
return true;
else return false;
}else return false;
}
});
for(File f1:fs)
{
if(f1.isFile()) System.out.println(f1.getAbsolutePath());
else printJava(f1);
}
}
}
用到了很多的方法：f1.getAbsolutePath()
arg0.getName();
File f=new File(“E:/javacode”);
File[] fs=dir.listFiles(new FileFilter(){}）；
if(name.endsWith(".java"))
f1.isFile()
f1.getAbsolutePath()。
2、IO中的字节流
输入流FileInputStream有3个读方法，输出流FileOutputStream有3个写方法,以及他们各自的抛异常的处理。这个字节流的节点流就是要掌握最基本的读写文件功能。
try-catch-finally这三个要连贯中间不可以有别的参杂的代码。局部变量只在定义的代码块到结束有效，所以try-catch的代码里面如果有定义变量的，需要把它放到外面定义，close()释放资源的要放在finally{}里面，而且close()本身也会抛出异常，也要try-catch。
package chp8_final;
import java.io.*;
public class TestFile {
public static void main(String[] args) {
FileInputStream fin = null;
byte[] bs = null;
int len = 0;
try {
fin = new FileInputStream("test.txt");
bs = new byte[3];
len = fin.read(bs);
if(len!=-1)
{
for(int i=0;i<len;i++)
{
System.out.print((char)bs[i]);
}
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
fin.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、过滤流—给节点流增加功能
上面的就是节点流，看一个类是节点流还是过滤流，就看这个类的构造方法。如果这个构造方法的参数是一个节点流类型的，那么说明它必须要先有一个节点流才能构造这个流，所以他就是过滤流，只是增加功能的。
如：第二个构造方法的参数是InputStream类型的，是字节流的父类，所以其实过滤流
1、过滤流FilterOutputStream中的DataOutputStream，用于读写8中基本类型和字符串writeUTF/readUFT.UFT是因为全球统一的UFF-8编码方式编码的，一般不用Data流来读写字符串，（后面会讲怎么读写字符串，有专门的类）这是一个变产编码1B至3B一个字节是8位汉字一般2字节可能3字节
过程：
创建节点流——封装过滤流——读写数据——关闭外层流（一般是过滤流）。都是这个套路
2、过滤流中的BufferedOutputStream，缓冲区，提高IO的效率，在IO中效率很重要。每一个缓冲流，都有一个flush（）方法，因为是缓冲流，缓冲区满了他才会写/读出来，但是如果我们只读或写一个字符是不会满的，那么怎么让他出来呢？方法一是关流，方法二是用flush()方法。一般我们用第二种方法，因为一般没结束之前不会关流。
3、
PrintStream就是System.out中的打印方法。
4、字符流——传数据的时候大部分是字符比较方便。
Reader/Writer 字符流的所有父类
FileReader/FileWriter 文件字符流 节点流
BufferredReader/PintWriter 缓冲流 过滤流
InputStreamReader/OutputStreamWriter既有字节流又有字符流的关键字，所以是桥转换，使用桥转换可以指定编解码方式
1、如果是先有了一个字节流，无法直接获得字符流时，先用桥转换转为字符流。当需要指定编码方式的时候我们要使用桥转换的方式，而不直接获得字符流，写的时候：
OutputStream os=new FileOutputStream(“pome.txt”);//字节流
Writer wr=new OutputStreamWriter(os,"GBK");//桥转换成字符流
PintWriter out=new PintWriter(wr);//封装过滤流
out.println("写进文件”)；
out.println("java测试”)；
out.close();
2、读的时候要注意，readLine()只有读到换行符的时候才会打印出来，不然就一直阻塞。所以要注意上面写的时候要有换行符，println()就有换行符，而print()是没有换行符的。
下面是读出来的代码：
InputStream ins=new FileInputStream("poem.txt");
Reader re=new InputStreamReader(ins,"GBK");
BufferredReader in=new BufferredReader(re);
while(ture){
String str=in.readLine();
if(str==null) break;
System.out.println(str)
}
in.close();
**第二种写文件的方式：**使用PrintWriter类
3、为了避免不同地区和国家的软件的编解码不同，我们 可以指定统一的编解码方式。
把字符变成数字，就是编码的过程，String中有一个把字符串变成字节数组的方法(getBytes()方法)，可以直接调用。
String str=“欢迎光临”；
byte[] bs =str.getBytes（"GBK"）;//原型为：byte[] getBytes(String charsetName)，这个有参函数可以指定什么方式的编码。
String类中还有一个构造方法String（byte[],String charsetName）,可以把一个字节数组通过指定的编码方式转为字符串。
String str2=new String（bs,“GBK”）；
System.out.println(str2);
5对象序列化
上面的所有的方法都不能传对象，但是我们的面相对象的语言还主要是传输对象。所以在字节流中有ObjectInputStream/ObjectOutputStream的过滤流。同样是先创建出字节流，再在外面进行封装过滤流调用读/写对象的方法即可。
本节小结：要点1、对象要序列化的话，必须实现Serializable接口，这个接口只是指示这个对象可以序列化并没有方法要去实现，同样的如果一个对象要实现克隆，也是要实现Cloneable接口，同样只是指示可以克隆，不用去实现方法，但是里面的Object类对象（所有的对象都是Object类的子类）的clone()方法是用protected修饰符修饰的，需要改为public修饰符需要比父类宽，不然会报错。
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
2、不需要序列化的属性可以用transient关键字修饰。
3、如果一个对象的属性是一个对象，在不加transient修饰的时候说明这个属性是要传输的，则这个属性里的对象也要实现Serializable接口。同样的，若属性是一个对象集合，集合里所有的对象都要实现序列化。
4、不要追加内容到对象中，因为只读一次，如果硬要追加，那么就用克隆创建一个新的对象。
package chp14;
import java.io.*;
public class TestObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException, CloneNotSupportedException {
// TODO Auto-generated method stub
Student s1=new Student(18,"sunfengjiao",100);
Student s2=new Student(9,"sunjiaxiang",100);
OutputStream os=new FileOutputStream("test.dat");
ObjectOutputStream oj=new ObjectOutputStream(os);
oj.writeObject(s1);
s1.setAge(25);
Object o=s1.clone();
oj.writeObject(o);
oj.writeObject(s2);
oj.close();
InputStream is=new FileInputStream("test.dat");
ObjectInputStream ij=new ObjectInputStream(is);
Student stu1=(Student)ij.readObject();
Student stu2=(Student)ij.readObject();
ij.close();
System.out.println(stu1.age+""+stu1.name+stu1.score);
System.out.println(stu2.age+stu2.name+stu2.score);
}
}
class Student implements Serializable,Cloneable{
int age;
String name;
int score;
public Student(int age, String name, int score) {
this.age = age;
this.name = name;
this.score = score;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
以上是综合的代码了。