Java学习 之 IO流(Properties、序列化与反序列化、打印流、commons-IO)

/*

Properties类表示一个持久的属性集，可以保存在流中或从流中加载，属性列表中每个键及其对应值都是一个字符串

特点:

       1、Hashtable的子类，map集合中的方法都可以用

       2、该集合没有泛型，键值都是字符串

       3、是一个持久化的属性集，键值可以存储到集合中，也可以存储到持久化的设备(硬盘，u盘、光盘)上，键值的来源也可以是持久化的设备

方法:

     void load(InputStream in)把指定流所对应的文件中的数据，读取出来，保存到Properties集合中

     void load(Reader reader)从输入字符流中读取属性列表

     void store(OutputStream out, String comments)把集合中的数据，保存到指定的流所对应的文件中，参数comments代表对描述的信息

    void store(Writer writer , String comments)将Properties表中的属性列表(键和值)写入输出字符

*/

public class PropertiesDemo1{

   public static void main(String[] args){

    //创建集合对象

   Properties pro = new Properties();

   //添加元素到集合

  pro.setProperty("a" , "1");

  pro.setProperty("b" , "2");

  //遍历集合

 Set<String> keys = pro.stringPropertyNames();

 for(Strng key : keys){

 //通过键，找值

 String value = pro.getProperty(key);

 System.out.println(key +"=="+value);

   }

  }

}

/*

将集合中内容存储到文件

*/

public class PropertiesDemo2{

   public static void main(String[] args) throws IOException{

      //创建Properties集合

    Properties pro = new Properties();

   //添加元素到集合

  pro.setProperty("name" , "张三");

  pro.setProperty("names" , "李四");

  //创建流

  FileWriter fw = new FileWriter("pro.properties");

  //把集合中的数据存储到流对应的文件中

  pro.store(fw , "");

 //关闭流

 fw.close();

   }

}
/*

读取文件中的数据，并保存到集合

*/

public class PropertiesDemo3{

   public static void main(String[] args) throws IOException{

    //创建集合

   Properties pro = new Properties();

  //创建流对象

  FileInputStream fis = new FileInputStream("pro.porperties");

  //把流所对应的文件中的数据，读取到集合中

  pro.load(fis);

  //关闭流

  fis.close();

 //显示集合中的数据

 System.out.println(pro);

 }

}

/*

序列化和反序列化:

    用于从流中读取对象的操作流ObjectInputStream称为反序列化

    构造方法:ObjectInputSream(InputStream in)创建从指定InputStream读取的ObjectInputStream

    方法:Object readObject()从ObjectInputStream读取对象

    用于从流中写入对象的操作流ObjectOutputStream称为序列化
    构造方法: ObjectOutputStream(OutputStream out)创建写入指定OutputStream的ObjectOutputStream

    方法: void writeObject(Object obj)将指定的对象写入ObjectOutputStream

序列化接口:当一个对象要能被序列化,这个对象所属的类必须实现Serializable接口,否则会发生异常NotSerializableException异常

                   同时当反序列化对象时,如果对象所属的class文件在序列化之后进行的修改,那么进行反序列化也会发生异常InvalidClassException,发生异常的原因:

                   1、该类的序列版本号于从流中读取的类描述符的版本号不匹配

                   2、该类包含未知数据类型

                   3、该类没有可访问的无参数构造方法

Serializable标记接口，该接口给需要序列化的类，提供了一个序列版本号，serialVersionUID,该版本号的目的在于验证序列化的对象和对应类是否版本匹配

*/

public class ObjectStreamDemo{

   public static void main(String[] args) throws IOException{

        writeObj() //对象的序列化

   }

   public static writeObj() throws IOException{

      //明确存储对象的文件

     FileOutputStream fos = new FileOutputStream("temp\\obj.object");

     //给操作文件对象加入写入对象功能

    ObjectOutputStream oos = new ObjectOutputStream(fos);

    //调用了写入对象的方法

   oos.writeObject(new Person("张三" , 20));

   //关闭资源

   oos.close();

   }

}

public class Person implements Serializable{

  //给类声明一个序列化版本号

   private static final long serivalVersionUID = 1L;

   private String name;

   private int age;

   public Person(){

     super();

   }

  public Person(String name , int age){

     super();

    this.name = name;

    this.age = age;

   public void setName(String name){

      this.name = name;

  }

  public String getName(){

     return name;

  }

  public void setAge(int age){

    this.age = age;

 }

 public int getAge(){

    return age;

 }

 @Override

 public String toString(){

   return "Person [name=" + name +" , age = " + age +"]";

 }

  }

}

public class ObjectStreamDemo2{

    public static void main(String[] args) throws IOException{

          readObj();

   }

   public staitc readObj() throws IOException , ClassNotFoundException{

     //定义流对象关联存储了对象文件

    FileInputStream fis = new FileInputStream("temp\\obj.object");

   //建立用于读取对象的功能对象

   ObjectInputStream ois = new ObjectInputStream(fis);

   Person obj = (Person)ois.readObj();

   System.out.println(obj.toString());

   } 

}

/*

瞬态关键字transient:

                           当一个类的对象需要被序列化时，某些属性不需要被序列化，不需要序列化的属性可以使用关键字transient修饰

                          静态修饰也不会被序列化,因为序列化是把对象数据进行持久化存储,而静态的属于类加载时的数据，不会被序列化

*/

/*

打印流:

         字节打印流: PrintStream

         字符打印流:PrintWriter

方法:

       void print(String str)输出任意类型的数据

       void println(String str)输出任意类型的数据,自动写入换行操作
打印流完成数据自动刷新:

 构造方法:

        public PrintWriter(OutputStream out , boolean autoFlush)

         public PrintWriter(Writer out , boolean autoFlush)

*/

public class PrintWriterDemo{

    public static void main(String[] args) throws IOException{

       //创建流

      PrintWriter fw = new PrintWriter("print.txt");

      //写数据

     for(int i =0 ; i < 5 ; i++){

       fw.println("hello");

    }

   //关闭流

  fw.close();

   }

}

public class PrintWriterDemo2{

    public static void main(String[] args) throws IOException{

      //创建流

     PrintWriter pw = new PrintWriter("print.txt" , true);

    //写数据

   for(int i = 0 ; i < 5 ; i++){

     pw.println("hello");

   }

  //关闭流

  pw.close();

    }

}

/*

commons - io:

    FilenameUtils:这个工具类用来处理文件名的

    方法:

           getExtension(String path)获取文件的扩展名

           getName()获取文件名

           isExtension(String fileName , String ext) 判断fileName是否是ext后缀名

    FileUtils:提供文件操作的方法

    方法:

           readFileToString(File file) 读取文件内容，并返回一个String

           writeStringToFile(File file , String content)将内容content写入到file中

           copyDirectoryToDirectory(File srcDir , File destDir)文件夹复制

           copyFile(File srcFile , File destFile)文件夹复制



*/