25_IO_第25天（Properties、序列化流、打印流、CommonsIO）_讲义

曾经终败给现在 2022-04-12 05:58 186阅读 0赞

# 第17天 IO流 #

今日内容介绍  
 Properties集合  
 序列化流与反序列化流  
 打印流  
 commons-IO

## 01Properties集合的特点 ##

*  A: Properties集合的特点
 *  a: Properties类介绍
 *  Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串
 *  b: 特点
 *  Hashtable的子类，map集合中的方法都可以用。
 *  **该集合没有泛型**。**键值都是字符串**。
 *  它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的
 *  设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
 *  有和流技术相结合的方法。
 *  c: 方法介绍
    
     *  **load(InputStream inputStream) 把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中**
     *  load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）
     *  store(OutputStream outputStream,String commonts) 把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息
     *  stroe(Writer writer,String comments) 以适合使用 load(Reader)
     *  方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符

## 02Properties集合存储键值对 ##

*  A: Properties集合存储键值对
    
     *  a: 方法介绍
        
         *  **集合对象Properties类,继承Hashtable,实现Map接口**
         *  可以和IO对象结合使用,实现数据的持久存储
         *  **使用Properties集合,存储键值对**
         *  **setProperty等同与Map接口中的put**
         *  setProperty(String key, String value)
         *  **通过键获取值, getProperty(String key)**

## 03Properties集合的方法load ##

*  A: Properties集合的方法load
    
     *  a: 方法介绍
        
         *  Properties集合特有方法 load
         *  load(InputStream in)
         *  load(Reader r)
         *  传递任意的字节或者字符输入流
         *  流对象读取文件中的键值对,保存到集合

## 04Properties集合的方法store ##

*  A: Properties集合的方法store
    
     *  a: 方法介绍
        
         *  Properties集合的特有方法store
         *  store(OutputStream out)
         *  store(Writer w)
         *  接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存

package cn.itcast.demo;
    
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    
    /*
     * 集合对象Properties类,继承Hashtable,实现Map接口
     * 可以和IO对象结合使用,实现数据的持久存储
     */
    public class PropertiesDemo {
    	public static void main(String[] args) throws IOException {
    		//function();
    		//funciton_1();
    		function_2();
    	}
    	/*
    	 * Properties集合特有方法store
    	 * void store(OutputStream out, String comments) 
    	 * void store(Writer writer, String comments) 
    	 * 接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
    	 */
    	public static void function_2() throws IOException{
    		Properties pro = new Properties();
    		pro.setProperty("name", "zhangsan1");
    		pro.setProperty("age", "32");
    		pro.setProperty("eamil", "123456@163.com");
    		FileWriter fw = new FileWriter("E:\\pro.properties");
    		//键值对,存回文件,使用集合的方法store传递字符输出流
    		pro.store(fw, "abc");
    		fw.close();
    	}
    	/*
    	 * Properties集合特有方法load
    	 * void load(InputStream inStream) 
    	 * void load(Reader reader) 
    	 * 传递任意的字节或者字符输入流
    	 * 流对象读取文件中的键值对,保存到集合
    	 */
    	public static void funciton_1() throws IOException{
    		Properties pro = new Properties();
    		FileReader fr = new FileReader("E:\\pro.properties");
    		//调用集合的方法load,传递字符输入流
    		pro.load(fr);
    		fr.close();
    		System.out.println(pro);
    	}
    	/*
    	 * 使用Properties集合,存储键值对
    	 * setProperty等同于Map接口中的put
    	 * Object setProperty(String key, String value) 
    	 * 通过键获取值
    	 * String getProperty(String key)  
    	 * 用指定的键在此属性列表中搜索属性
    	 */
    	public static void function(){
    		Properties pro = new Properties();
    		//Object setProperty(String key, String value)  
    		//调用 Hashtable 的方法 put
    		pro.setProperty("a", "1");
    		pro.setProperty("b", "2");
    		pro.setProperty("c", "3");
    		
    		String value = pro.getProperty("c");
    		System.out.println(value);
    		
    		//方法：Set<String> stringPropertyNames()  
    		//返回此属性列表中的键集，其中该键及其对应值是字符串
    		//如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键
    		Set<String> set = pro.stringPropertyNames();
    		for(String key : set){
    			System.out.println(key + "..." + pro.getProperty(key));
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]

## 05对象的序列化与反序列化 ##

*  A: 对象的序列化与反序列化
    
     *  a: 基本概念
        
         *  对象的序列化
            
             *  对象中的数据，以流的形式，写入到文件中保存过程称为写出对象，对象的序列化
             *  ObjectOutputStream将对象写道文件中，实现序列化
         *  对象的反序列化
            
             *  在文件中，以流的形式，将对象读出来，读取对象，对象的反序列化
             *  ObjectInputStream 将文件对象读取出来

## 06ObjectOutputStream流写对象 ##

*  A: ObjectOutputStream流写对象
    
     *  a: 简单介绍
        
         *  IO流对象,实现对象Person序列化和反序列化
         *  ObjectOutputStream 写对象,实现序列化
         *  ObjectInputStream 读取对象,实现反序列化

## 07ObjectInputStream流读取对象 ##

*  A: ObjectInputStream流读取对象
    
     *  a: 简单介绍
        
         *  ObjectInputStream
         *  构造方法:ObjectInputStream(InputStream in)
         *  传递任意的字节输入流,输入流封装文件,必须是序列化的文件
         *  Object readObject() 读取对象

package cn.itcast.demo1;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /*
     * IO流对象,实现对象Person序列化和反序列化
     * ObjectOutputStream 写对象,实现序列化
     * ObjectInputStream 读取对象,实现反序列化
     
     * 用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流
     * 用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流
     * 
     * java.io.NotSerializableException: cn.itcast.demo1.Person
     */
    public class OutputStreamDemo {
    	public static void main(String[] args) throws IOException, ClassNotFoundException {
    		//writeObject();
    		readObject();
    	}
    	/*
    	 * ObjectOutputStream
    	 * 构造方法：ObjectOutputStream(OutputStream out) 
    	 * 传递任意的字节输出流
    	 * void writeObject(Object obj) 写出对象的方法
    	 */
    	public static void writeObject() throws IOException{
    		//创建字节输出流,封装文件
    		FileOutputStream fos = new FileOutputStream("E:\\person.txt");
    		//创建写出对象的序列化流的对象,构造方法传递字节输出流
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		Person p = new Person("lisi",25);
    		//void writeObject(Object obj)  
    		//调用序列化流的方法writeObject,写出对象
    		//将指定的对象写入 ObjectOutputStream
    		oos.writeObject(p);
    		oos.close();
    	}
    	/*
    	 * ObjectInputStream
    	 * 构造方法:ObjectInputStream(InputStream in) 
    	 * 传递任意的字节输入流,输入流封装文件,必须时序列化的文件
    	 * Object readObject()  
    	 * 从 ObjectInputStream 读取对象
    	 */
    	public static void readObject() throws IOException, ClassNotFoundException{
    		FileInputStream fis = new FileInputStream("E:\\person.txt");
    		//创建反序列化流,构造方法中,传递字节输入流
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		Object obj = ois.readObject();
    		System.out.println(obj);
    		ois.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]

## 08静态不能序列化 ##

*  A: 静态不能序列化
    
     *  a: 原因
        
         *  序列化是把对象数据进行持久化存储
         *  静态的东西不属于对象，而属于类

package cn.itcast.staticdemo;
    /*
     * public interface Serializable
     * 类通过实现 java.io.Serializable 接口以启用其序列化功能
     * 未实现此接口的类将无法使其任何状态序列化或反序列化
     * 可序列化类的所有子类型本身都是可序列化的
     * 序列化接口没有方法或字段，仅用于标识可序列化的语义
     */
    import java.io.Serializable;
    
    public class Person implements Serializable{
    	private String name;
    	private static int age;//静态不能序列化
    	
    	public Person() {
    		super();
    		
    	}
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	
    }

package cn.itcast.staticdemo;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /*
     * IO流对象,实现对象Person序列化和反序列化
     * ObjectOutputStream 写对象,实现序列化
     * ObjectInputStream 读取对象,实现反序列化
     
     * 用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流
     * 用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流
     * 
     * java.io.NotSerializableException: cn.itcast.demo1.Person
     */
    public class OutputStreamDemo {
    	public static void main(String[] args) throws IOException, ClassNotFoundException {
    		//writeObject();
    		readObject();
    	}
    	/*
    	 * ObjectOutputStream
    	 * 构造方法：ObjectOutputStream(OutputStream out) 
    	 * 传递任意的字节输出流
    	 * void writeObject(Object obj) 写出对象的方法
    	 */
    	public static void writeObject() throws IOException{
    		//创建字节输出流,封装文件
    		FileOutputStream fos = new FileOutputStream("E:\\person.txt");
    		//创建写出对象的序列化流的对象,构造方法传递字节输出流
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		Person p = new Person("lisi",15);
    		//void writeObject(Object obj)  
    		//调用序列化流的方法writeObject,写出对象
    		//将指定的对象写入 ObjectOutputStream
    		oos.writeObject(p);
    		oos.close();
    	}
    	/*
    	 * ObjectInputStream
    	 * 构造方法:ObjectInputStream(InputStream in) 
    	 * 传递任意的字节输入流,输入流封装文件,必须时序列化的文件
    	 * Object readObject()  
    	 * 从 ObjectInputStream 读取对象
    	 */
    	public static void readObject() throws IOException, ClassNotFoundException{
    		FileInputStream fis = new FileInputStream("E:\\person.txt");
    		//创建反序列化流,构造方法中,传递字节输入流
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		Object obj = ois.readObject();
    		System.out.println(obj);
    		ois.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]

## 09transient关键字 ##

*  A: transient关键字
    
     *  a: 作用
        
         *  被transient修饰的属性不会被序列化
         *  transient关键字只能修饰成员变量

package cn.itcast.transientdemo;
    /*
     * public interface Serializable
     * 类通过实现 java.io.Serializable 接口以启用其序列化功能
     * 未实现此接口的类将无法使其任何状态序列化或反序列化
     * 可序列化类的所有子类型本身都是可序列化的
     * 序列化接口没有方法或字段，仅用于标识可序列化的语义
     */
    import java.io.Serializable;
    
    public class Person implements Serializable{
    	private String name;
    	private transient /*阻止成员变量序列化*/ int age;
    	
    	public Person() {
    		super();
    		
    	}
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	
    }

package cn.itcast.transientdemo;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /*
     * IO流对象,实现对象Person序列化和反序列化
     * ObjectOutputStream 写对象,实现序列化
     * ObjectInputStream 读取对象,实现反序列化
     
     * 用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流
     * 用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流
     * 
     * java.io.NotSerializableException: cn.itcast.demo1.Person
     */
    public class OutputStreamDemo {
    	public static void main(String[] args) throws IOException, ClassNotFoundException {
    		//writeObject();
    		readObject();
    	}
    	/*
    	 * ObjectOutputStream
    	 * 构造方法：ObjectOutputStream(OutputStream out) 
    	 * 传递任意的字节输出流
    	 * void writeObject(Object obj) 写出对象的方法
    	 */
    	public static void writeObject() throws IOException{
    		//创建字节输出流,封装文件
    		FileOutputStream fos = new FileOutputStream("E:\\person.txt");
    		//创建写出对象的序列化流的对象,构造方法传递字节输出流
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		Person p = new Person("lisi",15);
    		//void writeObject(Object obj)  
    		//调用序列化流的方法writeObject,写出对象
    		//将指定的对象写入 ObjectOutputStream
    		oos.writeObject(p);
    		oos.close();
    	}
    	/*
    	 * ObjectInputStream
    	 * 构造方法:ObjectInputStream(InputStream in) 
    	 * 传递任意的字节输入流,输入流封装文件,必须时序列化的文件
    	 * Object readObject()  
    	 * 从 ObjectInputStream 读取对象
    	 */
    	public static void readObject() throws IOException, ClassNotFoundException{
    		FileInputStream fis = new FileInputStream("E:\\person.txt");
    		//创建反序列化流,构造方法中,传递字节输入流
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		Object obj = ois.readObject();
    		System.out.println(obj);
    		ois.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]

## 10Serializable接口的含义 ##

*  A：Serializable接口的含义
    
     *  a: 作用
        
         *  给需要序列化的类上加标记。该标记中没有任何抽象方法
         *  只有实现了 Serializable接口的类的对象才能被序列化

## 11序列化中的序列号冲突问题 ##

*  A: 序列化中的序列号冲突问题
    
     *  a: 问题产生原因
        
         *  当一个类实现Serializable接口后，创建对象并将对象写入文件，之
         *  后更改了源代码(比如：将成员变量的修饰符有private改成public)，  
            再次从文件中读取对象时会报异常
         *  见day25\_source文件夹下的"序列号的冲突.JPG"文件 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]

package cn.itcast.staticfinalDemo;
    /*
     * public interface Serializable
     * 类通过实现 java.io.Serializable 接口以启用其序列化功能
     * 未实现此接口的类将无法使其任何状态序列化或反序列化
     * 可序列化类的所有子类型本身都是可序列化的
     * 序列化接口没有方法或字段，仅用于标识可序列化的语义
     */
    import java.io.Serializable;
    
    public class Person implements Serializable{
    	//public String name;
    	private String name;
    	public /*transient阻止成员变量序列化*/ int age;
    	//private /*transient阻止成员变量序列化*/ int age;
    	//类,自定义了序列号,编译器不会计算序列号
    	//即使修改了源代码,也不能重新计算序列号
    	//private static final long serialVersionUID = 42L;//一旦定义好,就不要乱动
    	
    	public Person() {
    		super();
    		
    	}
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	
    }

package cn.itcast.staticfinalDemo;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /*
     * IO流对象,实现对象Person序列化和反序列化
     * ObjectOutputStream 写对象,实现序列化
     * ObjectInputStream 读取对象,实现反序列化
     
     * 用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流
     * 用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流
     * 
     * java.io.NotSerializableException: cn.itcast.demo1.Person
     */
    public class OutputStreamDemo {
    	public static void main(String[] args) throws IOException, ClassNotFoundException {
    		//writeObject();
    		readObject();
    	}
    	/*
    	 * ObjectOutputStream
    	 * 构造方法：ObjectOutputStream(OutputStream out) 
    	 * 传递任意的字节输出流
    	 * void writeObject(Object obj) 写出对象的方法
    	 */
    	public static void writeObject() throws IOException{
    		//创建字节输出流,封装文件
    		FileOutputStream fos = new FileOutputStream("E:\\person.txt");
    		//创建写出对象的序列化流的对象,构造方法传递字节输出流
    		ObjectOutputStream oos = new ObjectOutputStream(fos);
    		Person p = new Person("lisi",15);
    		//void writeObject(Object obj)  
    		//调用序列化流的方法writeObject,写出对象
    		//将指定的对象写入 ObjectOutputStream
    		oos.writeObject(p);
    		oos.close();
    	}
    	/*
    	 * ObjectInputStream
    	 * 构造方法:ObjectInputStream(InputStream in) 
    	 * 传递任意的字节输入流,输入流封装文件,必须时序列化的文件
    	 * Object readObject()  
    	 * 从 ObjectInputStream 读取对象
    	 */
    	public static void readObject() throws IOException, ClassNotFoundException{
    		FileInputStream fis = new FileInputStream("E:\\person.txt");
    		//创建反序列化流,构造方法中,传递字节输入流
    		ObjectInputStream ois = new ObjectInputStream(fis);
    		Object obj = ois.readObject();
    		System.out.println(obj);
    		ois.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]  
将成员变量age，从原来的private修改为public  
输出：

Exception in thread "main" java.io.InvalidClassException: cn.itcast.staticfinalDemo.Person; local class incompatible: stream classdesc serialVersionUID = -813961507673909598, local class serialVersionUID = -8489189509674553104
    	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:617)
    	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1622)
    	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1517)
    	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1771)
    	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1350)
    	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
    	at cn.itcast.staticfinalDemo.OutputStreamDemo.readObject(OutputStreamDemo.java:53)
    	at cn.itcast.staticfinalDemo.OutputStreamDemo.main(OutputStreamDemo.java:22)

## 12序列化中自定义的序列号 ##

*  A: 序列化中自定义的序列号
    
     *  a: 定义方式
        
         *  private static final long serialVersionUID = 1478652478456L;
            
             *  这样每次编译类时生成的serialVersionUID值都是固定的  
                ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]

package cn.itcast.staticfinalDemo;
    /*
     * public interface Serializable
     * 类通过实现 java.io.Serializable 接口以启用其序列化功能
     * 未实现此接口的类将无法使其任何状态序列化或反序列化
     * 可序列化类的所有子类型本身都是可序列化的
     * 序列化接口没有方法或字段，仅用于标识可序列化的语义
     */
    import java.io.Serializable;
    
    public class Person implements Serializable{
    	//public String name;
    	private String name;
    	//public /*transient阻止成员变量序列化*/ int age;
    	private /*transient阻止成员变量序列化*/ int age;
    	//类,自定义了序列号,编译器不会计算序列号
    	//即使修改了源代码,也不能重新计算序列号
    	private static final long serialVersionUID = 42L;//一旦定义好,就不要乱动
    	
    	public Person() {
    		super();
    		
    	}
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]  
将成员变量修饰符从private修改为public，直接运行readObject，查看输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]

## 13打印流和特性 ##

*  A: 打印流和特性
    
     *  a: 概述
        
         *  打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
         *  打印流根据流的分类：
            
             *  **字节打印流 PrintStream**
             *  **字符打印流 PrintWriter**
         *  方法：
            
             *  void print(String str): 输出任意类型的数据，
             *  **void println(String str): 输出任意类型的数据，自动写入换行操作**
     *  b: 特点
        
         *  **此流不负责数据源,只负责数据目的**
         *  为其他输出流,添加功能
         *  永远不会抛出IOException，但是可能抛出别的异常
         *  两个打印流的方法,完全一致
         *  ***构造方法,就是打印流的输出目的端***
         *  **PrintStream构造方法**
            
             *  **接收File类型,接收字符串文件名,接收字节输出流OutputStream**
         *  **PrintWriter构造方法**
            
             *  **接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer**

## 14打印流输出目的是File对象 ##

package cn.itcast.PrintStream;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流
     * 	  PrintStream
     * 
     */
    public class PrintStreamDemo {
    	public static void main(String[] args) throws IOException {
    		//function_3();
    		//function_2();
    		function_1();
    	}
    	/*
    	 * 打印流,向File对象的数据目的写入数据
    	 * 方法print println 原样输出
    	 * write方法走码表
    	 */
    	public static void function_1() throws FileNotFoundException{
    		File file = new File("E:\\1.txt");
    		PrintWriter pw = new PrintWriter(file);
    		pw.println(true);
    		pw.write(100);
    		pw.close();
    	}
    	/*
    	 * 打印流输出目的是String和流对象
    	 * 打印流,输出目的,是流对象
    	 * 可以是字节输出流,可以是字符的输出流
    	 * OutputStream  Writer
    	 */
    	public static void function_2() throws IOException{
    		//FileWriter-字符输出流
    		//FileWriter fw = new FileWriter("E:\\3.txt");
    		//FileOutputStream-字节输出流
    		FileOutputStream fos = new FileOutputStream("E:\\4.txt");
    		PrintWriter pw = new PrintWriter(fos);
    		pw.println("打印流");
    		pw.close();
    	}
    	/*
    	 * 打印流,可以开启自动刷新功能
    	 * 满足2个条件：
    	 * 	  1.输出的数据目的的必须是流对象
    	 * 		OutputStream  Writer
    	 *    2.必须调用println,printf,format三个方法中的一个,启用自动刷新
    	 */
    	public static void function_3() throws IOException{
    		//File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象
    		File f = new File("E:\\6.txt");
    		//将File对象,转为流对象方式
    		FileOutputStream fos = new FileOutputStream(f);//"E:\\5.txt"
    		PrintWriter pw = new PrintWriter(fos,true);
    		pw.println("i");
    		pw.println("love");
    		pw.println("java");
    		//还是要关流的,但是关流前,启用自动刷新
    		pw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]

## 15输出语句是char数组 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]

package cn.itcast.PrintStream;
    /*
     * println数组,只有打印字符数组时,有遍历数组元素,其余均打印数组的地址
     *   因为API中定义了打印字符数组的方法,其底层是在遍历数组中的元素
     *   而其他打印数组的方法,都是将数组对象编程Object,其底层再将对象编程String
     *   调用了String s = String.valueOf(x);
     */
    public class CharDemo {
    
    	public static void main(String[] args) {
    		int[] arr = {1};
    		System.out.println(arr);
    		
    		char[] ch = {'a','b'};
    		System.out.println(ch);
    		
    		byte[] b = {};
    		System.out.println(b);
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]

## 16打印流输出目的是String和流对象 ##

package cn.itcast.PrintStream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流
     * 	  PrintStream
     * 
     */
    public class PrintStreamDemo {
    	public static void main(String[] args) throws IOException {
    		//function_3();
    		function_2();
    	}
    	/*
    	 * 打印流输出目的是String和流对象
    	 * 打印流,输出目的,是流对象
    	 * 可以是字节输出流,可以是字符的输出流
    	 * OutputStream  Writer
    	 */
    	public static void function_2() throws IOException{
    		//FileWriter-字符输出流
    		FileWriter fw = new FileWriter("E:\\3.txt");
    		//FileOutputStream-字节输出流
    		//FileOutputStream fos = new FileOutputStream("E:\\4.txt");
    		PrintWriter pw = new PrintWriter(fw);
    		pw.println("打印流");
    		pw.close();
    	}
    	/*
    	 * 打印流,可以开启自动刷新功能
    	 * 满足2个条件：
    	 * 	  1.输出的数据目的的必须是流对象
    	 * 		OutputStream  Writer
    	 *    2.必须调用println,printf,format三个方法中的一个,启用自动刷新
    	 */
    	public static void function_3() throws IOException{
    		//File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象
    		File f = new File("E:\\6.txt");
    		//将File对象,转为流对象方式
    		FileOutputStream fos = new FileOutputStream(f);//"E:\\5.txt"
    		PrintWriter pw = new PrintWriter(fos,true);
    		pw.println("i");
    		pw.println("love");
    		pw.println("java");
    		//还是要关流的,但是关流前,启用自动刷新
    		pw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]

package cn.itcast.PrintStream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流
     * 	  PrintStream
     * 
     */
    public class PrintStreamDemo {
    	public static void main(String[] args) throws IOException {
    		//function_3();
    		function_2();
    	}
    	/*
    	 * 打印流输出目的是String和流对象
    	 * 打印流,输出目的,是流对象
    	 * 可以是字节输出流,可以是字符的输出流
    	 * OutputStream  Writer
    	 */
    	public static void function_2() throws IOException{
    		//FileWriter-字符输出流
    		//FileWriter fw = new FileWriter("E:\\3.txt");
    		//FileOutputStream-字节输出流
    		FileOutputStream fos = new FileOutputStream("E:\\4.txt");
    		PrintWriter pw = new PrintWriter(fos);
    		pw.println("打印流");
    		pw.close();
    	}
    	/*
    	 * 打印流,可以开启自动刷新功能
    	 * 满足2个条件：
    	 * 	  1.输出的数据目的的必须是流对象
    	 * 		OutputStream  Writer
    	 *    2.必须调用println,printf,format三个方法中的一个,启用自动刷新
    	 */
    	public static void function_3() throws IOException{
    		//File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象
    		File f = new File("E:\\6.txt");
    		//将File对象,转为流对象方式
    		FileOutputStream fos = new FileOutputStream(f);//"E:\\5.txt"
    		PrintWriter pw = new PrintWriter(fos,true);
    		pw.println("i");
    		pw.println("love");
    		pw.println("java");
    		//还是要关流的,但是关流前,启用自动刷新
    		pw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]

## 17打印流开启自动刷新 ##

package cn.itcast.PrintStream;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流
     * 	  PrintStream
     * 
     */
    public class PrintStreamDemo {
    	public static void main(String[] args) throws IOException {
    		function_3();
    	}
    	/*
    	 * 打印流,可以开启自动刷新功能
    	 * 满足2个条件：
    	 * 	  1.输出的数据目的的必须是流对象
    	 * 		OutputStream  Writer
    	 *    2.必须调用println,printf,format三个方法中的一个,启用自动刷新
    	 */
    	public static void function_3() throws IOException{
    		FileOutputStream fos = new FileOutputStream("E:\\5.txt");
    		PrintWriter pw = new PrintWriter(fos,true);
    		pw.println("i");
    		pw.println("love");
    		pw.println("java");
    		
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]

package cn.itcast.PrintStream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流
     * 	  PrintStream
     * 
     */
    public class PrintStreamDemo {
    	public static void main(String[] args) throws IOException {
    		function_3();
    	}
    	/*
    	 * 打印流,可以开启自动刷新功能
    	 * 满足2个条件：
    	 * 	  1.输出的数据目的的必须是流对象
    	 * 		OutputStream  Writer
    	 *    2.必须调用println,printf,format三个方法中的一个,启用自动刷新
    	 */
    	public static void function_3() throws IOException{
    		//File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象
    		File f = new File("E:\\6.txt");
    		//将File对象,转为流对象方式
    		FileOutputStream fos = new FileOutputStream(f);//"E:\\5.txt"
    		PrintWriter pw = new PrintWriter(fos,true);
    		pw.println("i");
    		pw.println("love");
    		pw.println("java");
    		//还是要关流的,但是关流前,启用自动刷新
    		pw.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]

## 18打印流复制文本文件 ##

*  A: 打印流复制文本文件
    
     *  a: 案例代码  
        /\*
        
         *  打印流实现文本复制
         *  读取数据源 BufferedReader+File 读取文本行
         *  写入数据目的 PrintWriter+println 自动刷新  
            \*/

package cn.itcast.PrintStream;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    /*
     * 打印流复制文本文件
     * 	  读取数据源,BufferedReader+File读取文本行
     * 	  写入数据目的PrintWriter+println 自动刷新
     */
    public class PrintWriterDemo1 {
    	public static void main(String[] args) throws IOException {
    		BufferedReader bfr = new BufferedReader(new FileReader("E:\\1.txt"));
    		//PrintWriter(Writer out, boolean autoFlush) 
    		PrintWriter pw = new PrintWriter(new FileWriter("F:\\1.txt"),true);
    		String line = null;
    		//String readLine()  读取一个文本行
    		while((line = bfr.readLine()) != null){
    			pw.println(line);
    		}
    		pw.close();
    		bfr.close();		
    	}
    	/*
    	 * 
    	 */
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]

## 19commons-io工具类介绍 ##

*  A: commons-io工具类介绍
    
     *  a: 工具类介绍
        
         *  解压缩commons-io-2.4.zip文件
         *  commons-io-2.4.jar需要导入到项目中的jar包，里面存放的是class文件
         *  commons-io-2.4-sources.jar工具类中原代码
         *  docs是帮助文档  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]

## 20使用工具类commons\_io ##

*  A: 使用工具类commons\_io
    
     *  **a: 导入jar包**
        
         *  **加入classpath的第三方jar包内的class文件才能在项目中使用**
         *  **创建lib文件夹**
         *  **将commons-io.jar拷贝到lib文件夹**
         *  **右键点击commons-io.jar，Build Path→Add to Build Path**
     *  b: 学会如何看源代码  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]  
        复制此文件：  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]

## 21IO工具类FilenameUtils ##

*  A: IO工具类FilenameUtils
    
     *  a: 方法介绍
        
         *  getExtension(String path)：获取文件的扩展名；
         *  getName()：获取文件名；
         *  isExtension(String fileName,String ext)：判断fileName是否是ext后缀名；

package cn.itcast.commons;
    
    import org.apache.commons.io.FilenameUtils;
    
    /*
     * 
     */
    public class CommonsDemo {
    	public static void main(String[] args) {
    		//第三方工具包
    		//FilenameUtils fis = null;//ctrl+shift+o 导包
    		function();
    		function_1();
    		function_2();
    	}
    	/*
    	 * FilenameUtils类的方法
    	 * public static boolean isExtension(String filename,String extension)
    	 * 判断文件名的后缀是不是 extension     
    	 * 按住F3查看源码可知：return fileExt.equals(extension);
    	 * equals严格区分大小写         
    	 */
    	public static void function_2(){
    		boolean b = FilenameUtils.isExtension("Demo.java", "java");
    		System.out.println(b);
    	}
    	/*
    	 * FilenameUtils类的方法
    	 * public static String getName(String filename)
    	 * 获取文件名
    	 */
    	public static void function_1(){
    		String name = FilenameUtils.getName("C:\\windows");
    		System.out.println(name);
    	}
    	/*
    	 * FilenameUtils类的方法
    	 * public static String getExtension(String filename)
    	 * 获取文件名的扩展名
    	 */
    	public static void function(){
    		String name = FilenameUtils.getExtension("abc.java");
    		System.out.println(name);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]

## 22IO工具类FileUtils ##

*  A: IO工具类FileUtils
    
     *  a: 方法介绍
        
         *  readFileToString(File file)：读取文件内容，并返回一个String；
         *  writeStringToFile(File file，String content)：将内容content写入到file中；
         *  copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制
         *  copyFile(File srcFile,File destFile);文件复制

package cn.itcast.commons;
    
    import java.io.File;
    import java.io.IOException;
    
    import org.apache.commons.io.FileUtils;
    
    public class CommonsDemo1 {
    	public static void main(String[] args) throws IOException {
    		function();
    		function_1();
    		function_2();
    	}
    	/*
    	 * FileUtils工具类的方法
    	 * static void	copyDirectoryToDirectory(File srcDir, File destDir) 
    	 * 复制文件夹
    	 */
    	public static void function_3() throws IOException{
    		FileUtils.copyDirectoryToDirectory(new File("E:\\demo"), new File("F:\\demo"));
    	}
    	/*
    	 * FileUtils工具类的方法
    	 * static void	copyFile(File srcFile, File destFile) 
    	 * 复制文件
    	 */
    	public static void function_2() throws IOException{
    		FileUtils.copyFile(new File("E:\\a.jpg"), new File("f:\\a.jpg"));
    	}
    	/*
    	 * FileUtils工具类的方法
    	 * static void	writeStringToFile(File file, String data) 
    	 * 将字符串直接写到文件中
    	 */
    	public static void function_1() throws IOException{
    		FileUtils.writeStringToFile(new File("E:\\11.txt"), "我爱Java");
    	}
    	/*
    	 * FileUtils工具类的方法
    	 * static String readFileToString(File file) 读取文本,返回字符串
    	 */
    	public static void function() throws IOException{
    		String s = FileUtils.readFileToString(new File("E:\\1.txt"));
    		System.out.println(s);
    	}
    	 
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 31]

## IO流总结 ##

 字节流  
 字节输入流 InputStream  
 FileInputStream 操作文件的字节输入流  
 BufferedInputStream高效的字节输入流  
 ObjectInputStream 反序列化流  
 字节输出流 OutputStram  
 FileOutputStream 操作文件的字节输出流  
 BufferedOutputStream 高效的字节输出流  
 ObjectOuputStream 序列化流  
 PrintStream 字节打印流  
 字符流  
 字符输入流 Reader  
 FileReader 操作文件的字符输入流  
 BufferedReader 高效的字符输入流  
 InputStreamReader 输入操作的转换流(把字节流封装成字符流)  
 字符输出流 Writer  
 FileWriter 操作文件的字符输出流  
 BufferedWriter 高效的字符输出流  
 OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)  
 PrintWriter 字符打印流

 方法：  
 读数据方法：  
 read() 一次读一个字节或字符的方法  
 read(byte\[\] char\[\]) 一次读一个数组数据的方法  
 readLine() 一次读一行字符串的方法(BufferedReader类特有方法)  
 readObject() 从流中读取对象(ObjectInputStream特有方法)  
 写数据方法：  
 write(int) 一次写一个字节或字符到文件中  
 write(byte\[\] char\[\]) 一次写一个数组数据到文件中  
 write(String) 一次写一个字符串内容到文件中  
 writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)  
 newLine() 写一个换行符号(BufferedWriter类特有方法)

 向文件中写入数据的过程  
1，创建输出流对象  
2，写数据到文件  
3，关闭输出流  
 从文件中读数据的过程  
1， 创建输入流对象  
2， 从文件中读数据  
3， 关闭输入流

 文件复制的过程  
1， 创建输入流（数据源）  
2， 创建输出流（目的地）  
3， 从输入流中读数据  
4， 通过输出流，把数据写入目的地  
5， 关闭流

 File类  
 方法  
 获取文件名称 getName()  
 获取文件绝对路径 getAbsolutePath()  
 获取文件大小 length()  
 获取当前文件夹中所有File对象 File\[\] listFiles()  
 判断是否为文件 isFile()  
 判断是否为文件夹 isDirectory()  
 创建文件夹 mkdir() mkdirs()  
 创建文件 createNewFile()

 异常  
 try…catch…finally捕获处理异常  
 throws 声明异常  
 throw 抛出异常对象

 异常的分类  
 编译期异常 Exception  
|- 运行期异常 RuntimeException

 注意：  
编译期异常，必须处理，不然无法编译通过  
运行期异常，程序运行过程中，产生的异常信息

 Properties：Map集合的一种，它是Hashtable集合的子集合,它键与值都是String类型,它是唯一能与IO流结合使用的集合  
 方法  
 load( InputStream in ) 从流所对应的文件中，读数据到集合中  
 load( Reader in ) 从流所对应的文件中，读数据到集合中  
 store( OutputStream out , String message ) 把集合中的数据，写入到流所对应的文件中  
 store( Writer out , String message) 把集合中的数据，写入到流所对应的文件中

 实现文件内容的自动追加  
 构造方法  
 FileOutputStream(File file, boolean append)  
 FileOutputStream(String fileName, boolean append)  
 FileWriter(File, boolean append)  
 FileWriter(String fileName, boolean append)  
 实现文件内容的自动刷新  
 构造方法  
 PrintStream(OutputStream out, boolean autoFlush)  
 PrintWriter(OutputStream out, boolean autoFlush)  
 PrintWriter(Writer out, boolean autoFlush)

 Commons-IO  
 方法  
 readFileToString(File file)：读取文件内容，并返回一个String；  
 writeStringToFile(File file，String content)：将内容content写入到file中；  
 copyDirectoryToDirectory(File srcDir,File destDir);文件夹复制  
 copyFileToDirectory (File srcFile,File destFile);文件复制

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220412/155ead02b4644dccbdd132cd0dcc906d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220412/fdfa727b6f3b4c55a0bcc4dba1841579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220412/eddc338382294ea6b5240e6181110083.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220412/524ed521321941aca45487e7c6dd2a78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220412/9cbe870c9d2a456cb0f0ad1149e23566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220412/09e1a4ff81bc4d47bce8508e88fad1d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220412/837f80e64f4848fa8f07797c60139566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220412/6b185ebd61e843c09259c47bd580539d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220412/866607e874654e31b4e3a51a7fb892f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220412/a7af98f1cc87488ab266f829c3bad5cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220412/1c1a2f99ef904cddaa9c5c59419e25b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220412/7e1be5719a2f417796e47f966f759d74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220412/6819987ad8bb4652a855ec392def284c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220412/befdff6cec6447179125200a47d98524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220412/db74b01a11084089ae80089f93120fc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220412/a087853cae3a46d6b3cd68f18eec38a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220412/12de89c96d584122b5f4d47a84a81de2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]: /images/20220412/0b68b884075542a2b8fdac97c7b3b4a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]: /images/20220412/72f51c194dc5414ca3cc85c9fc778c4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]: /images/20220412/38751abb9068472a8e1cb55ac3141f01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]: /images/20220412/c28e2ed22d684a03981428615270740b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 21]: /images/20220412/34a1c46bb68043dba04821c92911df0c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 22]: /images/20220412/f5005b9f2a884b0591b6deb3660b5f13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 23]: /images/20220412/f00e9a65e0e54550897402f1ad3da297.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 24]: /images/20220412/436d3b9d604c46d48507ae15340e4391.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 25]: /images/20220412/c23c62ff95ab478986665d3e5d7502aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 26]: /images/20220412/f5b0b2db3e6d442ba9c32cb8803ce9f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 27]: /images/20220412/12702bf3a406432ab7edff4adf64448b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 28]: /images/20220412/ae6b79fbf2994efc960df59586603da1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 29]: /images/20220412/2b828fcf41a7426da5284930c1c6741d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 30]: /images/20220412/d573ee3e012c4eb78ea05f4f47cb3006.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 31]: /images/20220412/96d06c2c0e98447ea5ce457fdfa452e0.png