Java IO流知识总结

一、File类：对文件和文件夹进行操作

1：创建。
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
boolean mkdir()：创建此抽象路径名指定的目录。
boolean mkdirs()：创建多级目录。
2：删除。
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
3：获取.
long length()：获取文件大小。
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
4：判断：
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
5：重命名。
boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。
File[] listFile():列出该抽象路径名表示的目录中的文件。

6：递归算法：就是函数自身调用自身。

什么时候用递归呢？
当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。
简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：
1：一定要定义递归的条件。
2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
其实递归就是在栈内存中不断的加载同一个函数。

*递归删除文件夹*

public static void f1(File file){
   //判断是文件还是文件夹，如果是文件则直接删除，如果是文件夹则删除其中的文件，再删除文件夹
    if (file.isDirectory()){
        File[] files = file.listFiles();
        for (File file1:files){
            f1(file1);
        }
        file.delete();
    }else{
        file.delete();
    }
}

二、流的分类：
1、四个基类（都是抽象类）
字节流：InputStream OuputStream
字符流：Reader Writer

1)字节流：
字节输入流：FileInputStream
字节输出流：FileOutputStream

2)字符流：
字符输入流：FileReader
字符输出流：FileWtiter

3)转换流
转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。
字符流是使用了本机默认的编码表，转换流可以指定编码格式
转换输入流：IuputStreamReader（是字符输入流的父类）
转化输出流：OutputStreamWriter（是字符输出流的分类）
如果需要制定码表，必须用转换流。
转换流 = 字节流+编码表。
转换流的子类File = 字节流 + 默认编码表。
凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

4. 字节缓存流
   BufferedInputSream
   BufferedOutputStream
   字符缓存流
   BuferedReader
   常用方法：readLine() 整行读取
   BufferedWriter
   常用方法： newLine 换行写入

   键盘输入，控制台输出
   	//记住，只要一读取键盘录入，就用这句话。
     BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
   BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//输出到控制台
   String line = null;
   while((line=bufr.readLine())!=null){
   	if("over".equals(line))
   		break;
   	bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出
   	bufw.newLine();
   	bufw.flush();
   	}
   bufw.close();
   bufr.close();
   

5)打印流：PrintStream
1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。
2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。
3：它使用的本机默认的字符编码.
4：该流的print方法不抛出IOException。

该对象的构造函数。
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)

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。
PrintWriter：具备了PrintStream的特点同时，还有自身特点：
该对象的目的地有四个：1：File对象。2：字符串路径。3：字节输出流。4：字符输出流。

6)序列化流：

对象的序列化：
目的：将一个具体的对象进行持久化，写入到硬盘上。
注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。
如何将非静态的数据不进行序列化？用transient 关键字或者static修饰此变量即可。
Serializable（接口）：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

 **对象的序列化与反序列化**
 
public class SerializablePerson {
    public static void main(String[] args) {
        //序列化对个对象是可用可变参数或者集合来操作；         
Person p1 = new Person("小强",19,"男");
        Person p2 = new Person("小王",17,"男");
        Person p3 = new Person("小红",18,"女");
        f1(p1,p2,p3);
        //反序列化
        f2("D:\\mydoc\\person.txt");
    }
    private static void f2(String path) {
        try {
            //反序列化关联文件
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path));
            //反序列化
            try {
                //反序列化输出一个对象
               /* Person p = (Person) ois.readObject();
                System.out.println(p.getName()+"-"+p.getAge()+"-"+p.getSex());*/
               //反序列化输出多个对象的信息
               Person p;
                while ((p = (Person) ois.readObject())!=null){
                System.out.println(p.getName()+"-"+p.getAge()+"-"+p.getSex());
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //关流
            ois.close();
        }catch (IOException e){
            e.getStackTrace();
        }
    }
private static void f1(Person ... person) {
        try {
            //创建对象序列化流关联文件
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\mydoc\\person.txt"));
            //序列化对象
            for (Person p:person){
                oos.writeObject(p);
            }
            //关流
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7)二进制文件的读写：

**二进制文件的读写(图片等文件的读写)**
DataOutputStream、DataInputStream：专门用于操作基本数据类型数据的对象。
DataOutputStream dos =  new DataOutputStream(new FileOutputStream("data.txt"));
	dos.writeInt(256);
	dos.close();

	DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
	int num = dis.readInt();
	System.out.println(num);
	dis.close();

三、装饰设计模式：

装饰设计模式解决：对一组类进行功能的增强。
包装：写一个类(包装类)对被包装对象进行包装；

• 1、包装类和被包装对象要实现同样的接口；
• 2、包装类要持有一个被包装对象；
• 3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；

四、close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。