JAVA基础之Properties类、序列化流及打印流、commons-IO

个人理解：

　　Properties类是个存储String类型的键值对的集合类，可以用其存储一些关键的账号密码什么的，同时后面的注释可以很好的帮助理解，但是需要注意的是其文件中不能出现其他的符号，存用store,取用load；序列化与反序列化主要是用于把对象写入文本文件，或者从里面调出来。打印流只是输出流的一种，好处在于其可以自动刷新，还可以设置其换行。

一、Properties类：以file结尾的文件

1、特点：

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

②、该集合没有泛型，键值必须都是字符串String类型；

③、它是一个可以持久化的属性集，键值可以存储在集合中，也可以存储在持久化的设备上，键值的来源也可以是持久化的设备。

2、方法：

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

store(OutputStream,comments)把集合中的数据，保存到指定的流所对应的文件中，后面的参数代表对描述信息--一个注释，可以是空字符串！！！

#this is a person
#Tue Jun 18 11:25:59 CST 2019
age=123
name=zhangsan
#this is a person
#Tue Jun 18 11:27:39 CST 2019
name2=zhangsan
age2=123

import java.util.Properties;

public class Demo01 {
    public static void main(String[] args) {
        //搭配的文件是.properties文件（只能存String类键值对）里面的注释是# 不能写中文，并且里面的=前后不能有空格，不能出现什么; "",不允许换行等等
        Properties pro=new Properties();
        //往集合中存储键值对
        pro.setProperty("a","1");
        pro.setProperty("b", "2");
        pro.setProperty("c", "3");
        //从集合中取值
        System.out.println(pro.getProperty("a"));
        System.out.println(pro.getProperty("b"));
        System.out.println(pro.getProperty("c"));
        
    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Demo02 {
    public static void main(String[] args) throws IOException {
        //明确数据源-相对路径不需要双\\，用/就行
        FileInputStream fis=new FileInputStream("src/com/oracle/demo01/pro.properties");
        //创建properties集合
        Properties pro=new Properties();
        //讲properties文件中的键值对存到properties集合中
        pro.load(fis);
        System.out.println(pro);//MAP子类，取出来无序
    }
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Demo03 {
    public static void main(String[] args) throws IOException {
        //明确目的地
        FileOutputStream fos=new FileOutputStream("src/com/oracle/demo01/pro.properties",true);
        //创建集合
        Properties pro=new Properties();
        pro.setProperty("name2", "zhangsan");
        pro.setProperty("age2", "123");
        //将集合中的键值对存到集合中---注意的是键不可以重复！！！
        pro.store(fos, "this is a person");
        
    }
}

二、序列化流与反序列化流：

1、序列化ObjectOutputStream：将对象存到文件中，目的就是把对象存到本地（不是让您看懂）；

　　　　　　writeObject()往ObjectInputStream中存对象

2、反序列化ObjectInputStream:从文件中读出来

　　　　　　readObject()从ObjectInputStream读取对象（需要向下转型）

3、序列化接口Serializable（标价接口，没有功能需要实现）：

每个文件被解析的时候都会生成一个序列化号，当被序列化流时从流中获得的序列化号将与文件的序列化号进行比对，若不一样会产生序列化异常。解决方法：在类中定死序列化号就可以了。

4、瞬态关键字transient

同static类似，可以使属性不被序列化，当被写时，输出其初始化值。

package com.oracle.demo02;

import java.io.Serializable;

public class Person implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;//=后面的序列号可以随便改（静态最终Long类型的常量）
    //瞬态关键字transient(效果同static）
    private transient String name;
    private static int 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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    
}

package com.oracle.demo02;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Demo01 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        write();
        read();
    }
    //序列化：将对象存到文件中，目的是将对象存到本地---静态后的不能序列化
    public static void write() throws IOException {
        // 序列化的前提：要序列化的类必须实现Serializable接口
        // 明确目的地
        FileOutputStream fos = new FileOutputStream("D:\\java\\person.txt");
        // 创建对象
        Person p = new Person("zhangsan", 18);
        // 创建序列化流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        // 将Person对象写入文件中
        oos.writeObject(p);
        // 释放资源
        oos.close();
    }
    //反序列化--从文件中读出来
    public static void read() throws ClassNotFoundException, IOException{
        //明确数据源
        FileInputStream fis=new FileInputStream("D:\\java\\person.txt");
        //创建反序列化流
        ObjectInputStream ois=new ObjectInputStream(fis);
        //将文件中的对象读到person对象中
        Person p=(Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
}

三、打印流：

　1、输出流的一种，只有输出目的，没有数据源。

　　PrintStream、PrintWriter

方法：print、println()可以输出任意类型的数据

2、打印流完成数据自动刷新：

PrintWriter(OutStream/Writer,true)  

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class Demo02 {
    public static void main(String[] args) throws FileNotFoundException {
        //明确目的地
        //开启续写功能
        FileOutputStream fos=new FileOutputStream("D:\\java\\a.txt",true);
        //开启自动刷新功能
        PrintWriter pw=new PrintWriter(fos,true);
        //向文件中写入字符串
        pw.print(100);
        pw.println("   ");
        pw.print("ccc");
        //释放资源
        pw.close();
    }
}

复制文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Copy {
    public static void main(String[] args) throws IOException {
        //明确数据源
        FileReader fr=new FileReader("D:\\java\\a.txt");
        //创建缓冲输入字符流
        BufferedReader br=new BufferedReader(fr);
        //明确目的地
        FileWriter fw=new FileWriter("D:\\java\\aaa.txt");
        //创建打印流--true是自动刷新
        PrintWriter pw=new PrintWriter(fw,true);
        //开始复制
        String line=null;
        while(((line)=br.readLine())!=null){
            pw.println(line);
        }
        //释放资源
        br.close();
        pw.close();
    }
}

 四、commons-IO

1、导入：

加入classPath的第三方jar包内的class文件才能在项目中使用；

2、FilenameUtils:处理文件名；

import org.apache.commons.io.FilenameUtils;

public class Demo01 {
    public static void main(String[] args) {
        // 获取文件扩展名
        String ext = FilenameUtils.getExtension("D:\\java\\a.txt");
        System.out.println("扩展名为" + ext);
        // 获取文件名
        String fname = FilenameUtils.getName("D:\\java\\a.txt");
        System.out.println("文件名为" + fname);
        // 判断扩展名
        boolean flag = FilenameUtils.isExtension("D:\\java\\a.txt", "txt");
        System.out.println(flag);
    }
}

3、FileUtils:文件操作

import java.io.File;
import java.io.IOException;

import org.apache.commons.io.FileUtils;

public class Demo02 {
    public static void main(String[] args) throws IOException {
        copydir();
    }
    public static void read() throws IOException {
        // 明确数据源
        File file = new File("D:\\java\\a.txt");
        // 从文件中读取数据
        String content = FileUtils.readFileToString(file);
        System.out.println(content);
    }
    public static void write() throws IOException{
        //明确目的地
        File file=new File("D:\\java\\a.txt");
        FileUtils.writeStringToFile(file,"你好吗",true);    
    }
    //复制文件夹
    public static void copydir() throws IOException{
        //明确数据源
        File src=new File("D:\\java");
        //明确目的地
        File dest=new File("D:\\java2");
        //开始复制
        FileUtils.copyDirectoryToDirectory(src, dest);
    }
}

 

转载于:https://www.cnblogs.com/21-forever/p/11046707.html